Decentralized subcontractor scheduling with divisible jobs

Subcontracting allows manufacturer agents to reduce completion times of their jobs and thus obtain savings. This paper addresses the coordination of decentralized scheduling systems with a single subcontractor and several agents having divisible jobs. Assuming complete information, we design parametric pricing schemes that strongly coordinate this decentralized system, i.e., the agents’ choices of subcontracting intervals always result in efﬁcient schedules. The subcontractor’s revenue under the pricing schemes depends on a single parameter which can be chosen to make the revenue as close to the total savings as required. Also, we give a lower bound on the subcontractor’s revenue for any coordinating pricing scheme. Allowing private information about processing times, we prove that the pivotal mechanism is coordinating, i.e., agents are better off by reporting their true processing times, and by participating in the subcontracting. We show that the subcontractor’s maximum revenue with any coordinating mechanism under private information equals the lower bound of that with coordinating pricing schemes under complete information. Finally, we address the asymmetric case where agents obtain savings at different rates per unit reduction in completion times. We show that coordinating pricing schemes do not always exist in this case.


Introduction
As a common supply chain management practice, manufacturers take advantage of external resources to alleviate the burden of internal operations through subcontracting and outsourcing. While outsourcing externalizes some internal operations, subcontracting allows manufacturers to carry out jobs both internally and externally (Van Mieghem 1999). In this manner, subcontracting enables a manufacturer to speed up the completion times of his jobs. Instances of subcontracting practices can be found in quick-response industries characterized by volatile demand and inflexible capacities, e.g., metal fabrication industry (Parmigiani 2003), electronics assembly (Webster et al. 1997), high-tech manufacturing (Aydinliyim and Vairaktarakis 2011), textile production, and engineering services (Taymaz and Kiliçaslan 2005).
Although a considerable number of papers in the literature analyzes the subcontracting strategies in production planning and scheduling problems of manufacturers (Kamien and Li 1990;Tan and Gershwin 2004;Chen and Li 2008;Lee and Sung 2008), the subcontractors' scheduling problems have received less attention. In reality, a subcontractor by itself faces a limited capacity while providing service to several manufacturers. Given the time-sensitive nature of subcontracting operations, the subcontractor's schedule has critical impact on the performance of manufacturers as well as the supply chain. The lack of due attention to the subcontractors' operations can cause significant complications in the extended supply chain. A well-documented real-life example of this issue has been reported in Boeing's Dreamliner supply chain where the overloaded schedules of subcontractors, each working with multiple suppliers, resulted in long delays in the overall production due dates (see Vairaktarakis (2013) and the references therein).
An important feature of subcontractor's scheduling problem is that the jobs belong to different manufacturers who are concerned with the processing of their own jobs only.
Unlike centralized systems where a single decision maker controls all the relevant decision variables and possesses all the necessary information, the agents in a decentralized system have some control over their individual decisions and/or are privately informed about some aspects of the system. Therefore, in order for the system to achieve a particular objective a mechanism is needed that motivates the agents to make their decisions and reveal their private information in a way that the system's ultimate objective is attained indirectly. In this paper, we focus on the efficiency objective, that is, we are seeking mechanisms that result in subcontracting schedules that maximize the total savings obtained by all manufacturers. In other words, we address the problem of coordination in decentralized subcontracting systems.
The mechanisms considered in this paper are pricing and payment schemes that the subcontractor announces before the manufacturers choose their most desirable subcontracting intervals. Such mechanisms are in fact common in practice. An example is the online reservation system implemented by the Semiconductor Product Analysis and Design Enhancement (SPADE) center of the Hong Kong University of Science and Technology 1 wherein the semiconductor companies choose service time intervals in a first-come-firstbook manner and in consideration of an announced price list for services in different time intervals.
Naturally, the design of mechanisms in the decentralized subcontracting systems must consider the utility of agents, i.e., savings due to subcontracting minus payments, as well as the subcontractor's revenue to ensure that all parties are sufficiently motivated to participate and operate in the system.
In this paper, we study a subcontractor scheduling problem with several manufacturer agents and a single subcontractor that carries out the agents' jobs on a single machine. Of particular interest to this paper is the scenario where a divisible job can be processed simultaneously on the manufacturer's private machine as well as on the subcontractor's machine. The reduction in completion time of an agent's job obtained by such parallel processing provides monetary saving for that agent.
The paper is organized as follows. Section 2 contains a review of related work. In Sects. 3 and 4, we assume complete information and give pricing schemes that coordinate the decentralized system. That is the pricing schemes enforce a choice of subcontracting time intervals that coincides with efficient allocations of the centralized solution 1 http://www.ust.hk/spade for every agent. In particular, Sect. 3 characterizes efficient allocations of the centralized solution. Section 4 provides sufficient conditions for the existence of coordinating pricing schemes and it introduces a family of pricing schemes that are strongly coordinating. With a strongly coordinating pricing scheme, the efficient allocations in the centralized solutions are uniquely optimal for all agents. Moreover, we show a lower bound on the total payments for any coordinating pricing scheme. Finally we show that with the appropriate choice of a single parameter, our proposed pricing schemes enable the subcontractor to obtain a total revenue anywhere between the lower bound and the maximum total savings.
In Sect. 5, we allow the true processing time of each job to be a private information of its agent and we address the intricacies resulting from agents possibly lying by reporting false processing times in order to obtain their preferred subcontracting intervals. In order to achieve efficiency, however, the subcontractor elicits the true processing times of jobs using certain mechanism. We draw upon the class of efficient and incentive compatible mechanisms and on the pivotal mechanism (Vickrey 1961;Clarke 1971;Groves 1973) in particular. The underlying reason for this choice is that the pivotal mechanism is the only efficient and incentive compatible mechanism that always results in nonnegative payments from agents to the subcontractor. This is a desirable property as agents must not be paid if their jobs are processed by the subcontractor in the subcontractor scheduling problem. We obtain a simple closed-form formula for the payments in the pivotal mechanism and prove that the pivotal mechanism results in truth-telling being the unique optimal choice of all agents except the one scheduled last on the subcontractor's machine who can possibly exaggerate his processing time without affecting anyone's utility. This result is particularly interesting as "uniqueness of equilibrium might be thought of as the exception rather than the rule" (Jackson 2000). Since we also show that the mechanism guarantees that all agents are better off by subcontracting, we actually prove that the pivotal mechanism coordinates the decentralized subcontracting problem under private information. Finally, we show that under any coordinating mechanism, the subcontractor's revenue is equivalent to the lower bound of that with the coordinating pricing schemes. Therefore, coordinated system under private information never generates higher total revenue for the subcontractor than that under complete information.
In Sect. 6, we address the asymmetric case where the agents obtain savings at different rates. The efficient centralized allocations in this case are more difficult to characterize. Moreover, we show that it is impossible to devise a coordinating pricing scheme in general for this case. Section 7 contains the concluding remarks.

Related work
The decentralized scheduling problems have been considered in cooperative and non-cooperative settings.
In the former, agents (jobs) are able to communicate and coordinate strategies. The early work of Curiel et al. (1989) studies the cost allocation problem in a cooperative game based on the perennial scheduling problem of Smith (1956). A survey of related research is given by Curiel et al. (2004).
In the non-cooperative settings agents choose their strategies individually and in competition with other agents. This paper falls in this category. Heydenreich et al. (2007) provide an introduction to and a literature review of problems arising in the non-cooperative decentralized scheduling. One important problem pertains to determining the equilibria of individual decisions and the quality of the corresponding solution compared with that of the centralized optimal solution. The pioneering work of Koutsoupias and Papadimitriou (1999), which gave rise to the literature on price of anarchy, analyzes the worst-case performance of a decentralized scheduling system with parallel machines in comparison with that in the centralized system.
As the outcomes of a decentralized system depend on the "policies" employed to handle the agents, another important problem addresses a better design of such policies. The coordination mechanisms discussed by Christodoulou et al. (2004) seek policies which improve the performance of a decentralized parallel sequencing system- Immorlica et al. (2005) review and extend this line of research. Ideally, such policies could make the decentralized system as efficient as the centralized system. Wellman et al. (2001) study pricing schemes for a scheduling problem that could achieve this goal and show that such pricing schemes might not exist in general. Kutanoglu and Wu (1999) report similar non-existence results for another scheduling problem. Even if the existence of such pricing schemes could be proven, the problem of finding the pricing scheme might be NP-hard (Chen et al. 2004).
Private information further complicates the coordination problem. The well-known incentive compatible mechanisms draw upon payment schemes to truthfully elicit the private information of the agents. The Vickery-Clarke-Groves (VCG) mechanisms (Vickrey 1961;Clarke 1971;Groves 1973) characterize all efficient mechanisms that make truthtelling an undominated strategy of all agents. For single machine sequencing, Suijs (1996) shows that there exists no incentive compatible and individually rational mechanism that results in the total payment of zero. Nisan and Ronen (2007) propose payment schemes that guarantee a certain performance for a decentralized scheduling problem for which the payment schemes of VCG mechanisms are NP-hard to compute.
The decentralized subcontracting and outsourcing problems have also been addressed in a number of papers. Aydinliyim and Vairaktarakis (2010) study a cooperative game where coalitions of agents reschedule their reserved time intervals to obtain savings. They prove non-emptiness of the core and the convexity of the corresponding game. Cai and Vairaktarakis (2012) investigate a problem with overtime and tardiness costs where the subcontractor announces the prices of time intervals before agents book their most preferred time intervals in a first-come-first-book manner. They show the balancedness of the corresponding cooperative game and implement the VCG mechanisms to elicit the private information of agents. Bukchin and Hanany (2007) compare the costs of a scheduling system comprised of multiple capacitated agents and an uncapacitated subcontractor in decentralized and centralized systems. Qi (2012) investigates a subcontractor's pricing problem with a single agent having multiple jobs which can be subcontracted (though not partially) to reduce the tardiness costs.
The subcontracting problem related to the one addressed in this paper was first studied by Vairaktarakis and Aydinliyim (2007) where they compare the performance in decentralized and centralized settings. Building upon the same model, Vairaktarakis (2013) analyzes the outcomes of a decentralized subcontracting system under different protocols announced by the subcontractor. However, both papers assume complete information and neither provides coordinating pricing schemes for the problem. The model considered in this paper generalizes the model of Vairaktarakis and Aydinliyim (2007) by allowing an agent to use more than one interval on the subcontractor's machine. This generalization is critical for a coordinating pricing schemes which need to give the agents freedom in choosing how many intervals on the subcontractor's machine to buy-the Vairaktarakis and Aydinliyim (2007) model would a priori limit this choice to at most a single interval which does not make their model adequate for the study of pricing schemes.
It is worth noticing that the models in Vairaktarakis and Aydinliyim (2007) and Vairaktarakis (2013) borrow from the concept of divisible jobs introduced in the context of job shops by Anderson (1981), and in the context of distributed computer systems scheduling by Bharadwaj et al. (1996), see also Drozdowski (2009) for a more recent review.
The distributed computer systems provide another important application area for the results obtained in this paper, where agents carry out their computations on their private machines as well as buy computational time on shared CPUs with available capacity. p = ( p 1 , . . . , p n ) be the vector of processing times. We assume, except in Sect. 5, that p is given. An agent i has its own private machine to do its job in time p i , besides private machines a subcontractor is available that can process any portion of job i on its machine that can be shared by all agents. Thus, by subcontracting, agent i can reduce the completion time of its job to less than p i . Let T i = ∪ m i k=1 T k i be the total time allocated to agent i consisting of m i non-overlapping where t k i ≥ 0 andt k i > 0 are the start time and the duration of the kth subinterval, respectively. The subintervals of agent i are indexed by the order of their start times. An allocation T = {T i |i ∈ N } is a set of allocations T i on subcontractor's machine. Allocation T is feasible if and only if for any i, j, k, and k the subintervals Let T denote the set of all feasible allocations T for the agents in N .
Our model allows preemptions on subcontractor's machine, that is the portion of a job allocated to the subcontractor's machine (or the subcontracted part of a job) is allowed to be executed in more than one disjoint time interval on that machine. This renders our model to be more general and arguably closer to real-life than the one in Vairaktarakis and Aydinliyim (2007) where only at most one time interval on subcontractor's machine is allowed for any subcontracted part. Consequently two main decisions need to be made for each job in the model: one is the size of the subcontracted part of a job (this part can be executed on the subcontractor's machine simultaneously with the remaining part of the job executed on private machine-thus the term divisible jobs), the other as to how to execute the subcontracted part (this part can possibly be executed in several disjoint time intervalsthus the term preemptions on the subcontractor's machine).
The saving obtained by agent i from an allocation T i is calculated recursively as follows. Assume that initially, agent i uses its private machine only in the interval [0, p i ], i ∈ N . Take the earliest interval allocated to i, T 1 i . If the start time t 1 i < p i , then a portion of the remainder of job i done after t 1 i , i.e., p i − t 1 i , on i's private machine can be transferred to the subcontractor. The most efficient way to do this is for agent i to split the remainder equally between its private and subcontractor's machines, unless the duration of the interval is too short (see Fig. 1). If the duration of the interval is too short, i.e.,t 1 i < (p i − t 1 i )/2, then T 1 i is fully utilized by i on the subcontractor's machine. Therefore, by utilizing the allocated interval T 1 i , agent i can reduce the finish time of its job by an amount equal to Clearly, the allocation T i cannot be utilized at all by agent i if t 1 i ≥ p i . The saving obtained by the next interval can be calculated in the same manner considering that the new total saving due to the allocation T i is calculated by summing up the savings obtained by all of its subintervals: The total saving of a feasible allocation T is the sum of savings of all agents, that is υ(T ) = i∈N υ i (T i ).

Characterization of efficient (centralized) allocations
The objective of the centralized problem is to find efficient allocations on the subcontractor machine for N . An efficient allocation T is a feasible allocation that maximizes the total saving, that is Let T = {T i |i ∈ N } be an efficient allocation. We have the following two simple observations that hold for any efficient allocation.
Observation 1 For i ∈ N , job i does not finish on the subcontractor's machine later than on agent's i private machine.

Observation 2 The subcontractor's machine is never idle when some agent's private machine is busy.
We now prove that all efficient allocations are nonpreemptive.

Lemma 1 No efficient allocation on subcontractor's machine is preemptive.
Proof By contradiction. Let T be an efficient and preemptive allocation and let n ≤ n be the number of agents with allocations on the subcontractor's machine. We show that then there exists another feasible allocation with higher total saving. Suppose that m i > 1 for some i ∈ N . Without loss of generality we take the largest such i. Let T i /2 k−i+2 ≥t k then k will no longer be executed on the subcontractor's machine) and min t m i −1 i /2 k−i+2 ,t k later on agent k private machine. The resulting allocation is feasible. Furthermore, jobs in N \ { j, i, . . . , n } complete as before Step 2, and for the jobs in { j, i, . . . , n } the total saving increases bȳ Hence, the alternative allocation has a higher total saving which contradicts the efficiency of T .
The lemma excludes allocations with preemptions on subcontractor's machine from the set of efficient allocations. This result is key for our coordinating pricing scheme in Sect. 4 since the efficient allocations with preemptions on subcontractor's machine could make the existence of coordinating pricing scheme questionable or possibly more difficult to prove.
By Lemma 1, m i = 1 for i ∈ N in any efficient allocation Vairaktarakis and Aydinliyim (2007) observe that, for any efficient allocation T with m i = 1, i ∈ N , each job finishes simultaneously on its own private and subcontractor's machines, that is (4) They also show that for m i = 1, i ∈ N , the agents' efficient allocations T i are ordered in non-decreasing order of p i . Thus, we assume hereafter in this section and in Sect. 4 that N is arranged in the non-decreasing order of processing times. In this manner, job i would be sequenced in ith position on subcontractor's machine. Finally, by Observation 2, there is no idle time on the subcontractor machine in efficient allocations, thus we have The unique solution of the recursive equations (4) and (5) is given in the following theorem.
Though multiple efficient allocations exist as long as there are jobs with equal processing times, in each one of them the jobs in the same position on subcontractor's machine start at the same time and have the same efficient durations. This observation is key to the coordinating pricing scheme developed in the next section.
depends on a mechanism used in the collective decision making. In this section we design such a mechanism based on a pricing scheme. A pricing scheme is a function q, defined on t ≥ 0, which determines a price q(t) ≥ 0 for acquiring the time t on the subcontractor's machine by any agent. The mechanism based on a pricing scheme q works as follows. The subcontractor announces its pricing scheme, and subsequently agent i buys T i in a first-come-first-serve manner. The agent makes its decision so as to maximize its utility, which for a given q, and assuming quasilinear utilities, equals where is the agent i's payment for T i made to the subcontractor. We require q to be a locally integrable function so that (9) always exists.
Though each agent maximizes its utility with respect to q, the choice of q must ensure coordination in the decentralized system. That is q must guarantee that the agents choose their subcontracting intervals in the exact same manner as in some efficient allocation T . We call such pricing schemes coordinating. Let E be the set of all efficient allocations. We formally define.
Definition 1 (Coordinating pricing scheme) The pricing scheme q is coordinating if for any T = (T 1 , . . . , T n ), T ∈ E, and any T = (T 1 , . . . , T n ), T ∈ T \ E, for each i ∈ N . The pricing scheme q is strongly coordinating if (10) holds strictly for each i ∈ N .
A coordinating pricing scheme results in the situation where no agent would be worse off by choosing an efficient allocation. However, the implementation of a coordinating pricing scheme may not necessarily result in the efficiency of the system. This is due to the possibility that an agent chooses an interval which is not a part of any efficient allocation. Such a choice could hinder forthcoming agents to select their efficient allocations. Therefore, the strong coordination requires all agents to exclusively choose efficient allocations. A natural class of pricing schemes to consider for scheduling consists of those with non-increasing q where agents have to pay a higher price for earlier intervals. When the choice of agent i consists of single interval only, i.e., T i = [t i , t i +t i ), we let π q (T i ) = π q (t i , t i +t i ). We now show that the class of non-increasing pricing schemes contain coordinating pricing schemes.
The individual rationality requires that for 0 ≤ t < t n+1 , q(t) must be less than 1, otherwise jobs would be either better off by not selecting the time with subcontracting price exceeding one or indifferent if the price equals one. Since q is non-increasing, the individual rationality holds if q(0) < 1.
For q to be a coordinating pricing scheme, it must be that no agent can deviate from an efficient allocation and improve its utility. The first-come-first-booked order breaks ties between jobs with equal processing times, if any, and picks a unique efficient allocation T from E. In T agent i has the utility υ i (T i ) − q(T i ). The fact that t i + 2t i = p i and q is non-increasing, implies that agent i cannot choose another interval to increase its valuation and, at the same time, reduce its payment. In order to improve its utility, the agent i may be able to choose another interval to: (a) increase its valuation as well as payment such that the added valuation is greater than the additional payment, or (b) decrease its valuation as well as payment such that the saving in payment is greater than the reduction in valuation. We enforce conditions on q such that neither (a) nor (b) could possibly happen for any job.
(a) Suppose that the agent i chooses T i in a way that υ i (T i ) − υ i (T i ) = , for some > 0. Note that this is not an option for i = 1. As q is non-increasing, T i has the cheapest payment if it starts as late as possible. Therefore, is the cheapest alternative interval for agent i which results in improvement in its valuation. Note that i cannot have negative start time, thus ≤ t i /2. From Definition 1 it follows that for the pricing scheme q to be coordinating, it must hold for any i = 2, . . . , n and for every 0 By the definition of π q in (9), the last inequality can be rewritten as (11) (see Fig. 2). We use induction and show that the latter would be the case if for any i = 2, . . . , n, (11) Fig. 2 Non-increasing pricing schemes holds for every 0 < ≤t i−1 /2, i.e., the condition stated in C1. This holds trivially for i = 2 as t 2 =t 1 . Fix i = 3, . . . , n and suppose that for j, 1 ≤ j < i, (11) holds for every such that We show that (11) holds as well for every such that, Observe that this would be the case if for every such that 0 < ≤t i− j−1 /2 we have, As q is non-increasing, we have Thus, (13) would be the case if for every such that 0 < ≤t i− j−1 /2 we have, Condition C1 for the job i − j ensures that the latter holds. Therefore, if for any i = 2, . . . , n, (11) holds (strictly) for every 0 < ≤t i−1 /2, then (11) holds (strictly) for every 0 < ≤ t i /2.
(b) It is straightforward to see that the interval which reduces the valuation of the agent i by > 0, while having the largest decrease in its payment, is T i = (t i + 2 , t i+1 + ), as long as ≤t i . Therefore, for q to be coordinating it must hold for every i = 1, . . . , n and for every such that 0 < ≤t i that, By the definition of π q in (9), the last inequality can be rewritten as (12). We use induction to show that for i = 1, . . . , n − 1 the latter would be the case if (11) holds for every 0 < ≤t i /2, i.e., the condition stated in C2. Fix i = 1, . . . , n − 1 and suppose that for j, 1 ≤ j < i, (12) holds for every such that, We show that (12) holds as well for every such that, In case j k=1t i+k−1 /2 <t i , observe that the latter would hold if for every 0 < ≤ min t i+ j /2,t i we have, As q is non-increasing, we have Thus, (14) would be the case if for every such that 0 < ≤ min t i+ j /2,t i we have π q t i+ j , t i+ j + 2 − π q t i+ j+1 , t i+ j+1 + ≤ .
The conditions in Theorem 2 are designed to make the deviations from t = (t 1 , . . . , t n ) undesirable for all agents in the sense that the agent's utilities would be reduced if they choose any intervals other than those defined by t. Clearly with quasilinear utilities any agent can increase its utility either by choosing an interval that either increases its valuation (saving due to reduction in completion time) or reduces its payment (see Fig. 2). With a non-increasing pricing scheme attaining both of these at the same time is impossible. Therefore, a deviation which increases (decreases) an agent's valuation, simultaneously increases (decreases) its payment.
Only strongly coordinating pricing schemes can guarantee efficient schedules in the decentralized system. In order to introduce a family of strongly coordinating pricing schemes, we need the following technical lemma which states that the efficient duration of any job on subcontractor's machine is not longer than twice the efficient duration of the job proceeding it.
Proof From (6) we get The agents in N are sequence according to non-decreasing order of processing times, thus we have p i ≤ p i+1 which obtainst i ≤ 2t i+1 .
Note that in Lemma 2, the equality holds for jobs with equal processing times. More precisely, p i = p i+1 if and only ift i = 2t i+1 .
We are now ready to give a family of non-increasing pricing schemes that are strongly coordinating, that is, any deviation from efficient allocation by any agent results in utility loss for that agent.
Given that q O is non-increasing, to verify (c) we must check the non-negativity of q O (t) at t ≥ t n +t n . Note that from (17) we get Hence, for (c) to hold we need δ ≤ 3/2 n+1 . We now check the conditions in Theorem 2. Observe that q O is piecewise linear and has a constant slope in between any consecutive points of possible discontinuity.
With regard to condition C1, note that for 0 < ≤ t i−1 /2 both π q O (t i − 2 , t i ) and π q O (t i+1 − , t i+1 ) can be obtained by calculating the areas of the corresponding trapezoids. Let t − = lim →0 + (t − ). For any i = 2, . . . , n we have From Lemma 2 we know thatt i−1 ≤ 2t i and consequently 1 − 2 /t i−1 ≤ 1 − /t i . By assumption we have 2κ i−1 < κ i which leads to the observation that for every 0 < <t i−1 /2, with regard to =t i−1 /2 we consider two cases. Ift i−1 /2 = t i then at =t i−1 /2, (19) holds strictly as well which implies that (19) holds strictly for every 0 < ≤ t i . Otherwise, if t i−1 /2 =t i , then at =t i−1 /2, (19) holds as equality. However, this requires that p i−1 = p i which corresponds to an alternative efficient allocation wherein job i is allocated with the interval allocated to job i − 1. Hence, the choice of any earlier intervals for a given agent i which is not part of an efficient allocation results in loss of utility for that agent. Also, for jobs with equal processing times the choice of an earlier alternative efficient intervals does not alter the utility to the corresponding agents. With regard to condition C2, note that for 0 < ≤t i /2 both π q O (t i , t i + 2 ) and π q O (t i+1 , t i+1 + ) can also be obtained by calculating the areas of the corresponding trapezoids. for any i = 1, . . . , n − 1 we have From Lemma 2 we know thatt i ≤ 2t i+1 and consequently 1−2 /t i ≤ 1− /t i+1 . By assumption we have κ i < κ i+1 /2. Therefore, for 0 < <t i−1 /2 we would have Ift i /2 =t i+1 then the latter also holds for =t i /2. In case oft i /2 =t i+1 , (20) would hold as equality for = t i /2. However, this requires p i = p i+1 which implies the existence of an alternative efficient allocation. Hence, the choice of any later intervals for a given agent i which is not part of an efficient allocation results in the loss of utility for that agent. Also, for jobs with equal processing times the choice of a later alternative efficient intervals does not alter the utility to the corresponding agents.
Considering the above, we conclude that q O is a coordinating pricing scheme where for any T ∈ E and every T ∈ T\E, it holds for all To see how the pricing scheme introduced in Theorem 3 can coordinate the subcontractor scheduling problem first note that for all agents with unequal processing times, corresponding efficient allocations are exclusively the best choices of subcontracting intervals. For agents with equal processing time jobs, however, the best choices are multiple. Nevertheless, q O would result in the situation where the number of best choices for the jobs with equal processing times are exactly the same as the number of those jobs. Therefore, a first-come-first-serve rule would result in strict coordination of individual choices.

Subcontractor's revenue with coordinating pricing schemes
Let Π q = i∈N π q (T i ) be the total payment from agents to the subcontractor under the pricing schemes q. We call Π q the subcontractor's revenue under q. In this section we characterize the range of Π q with q being a coordinating pricing scheme. The coordinating pricing schemes introduced in Theorem 3 can extract (almost) all of the total saving υ(T ) from the agents by selecting δ small enough which is shown in the following theorem.
Proof For every i ∈ N we have, Hence, the total payments can be made arbitrary close to the maximum possible which is the total saving υ(T ).
We now provide a lower bound for the total subcontractor's revenue attainable under any coordinating pricing scheme. We show in Corollary 1 that this bound is an upper bound on the subcontractor's revenue attainable by any coordinating mechanism with private information.
Theorem 5 (Lower bound) For any coordinating pricing scheme q, we have Π q ≥ i∈Nt i 1 − 1/2 n−i .
Proof Let T ∈ E be an efficient allocation. If q is coordinating, then for all i ∈ N there is no T i which results in higher utility than T i . In particular, for any agent i = 2, . . . , n, the following deviation from efficient allocation should not be profitable: construct T i by removing the last > 0 interval at the end of T i and add instead another interval with duration 2 starting at time t i − 2 (to have feasible allocations it must be that ≤ t i /2). With the new allocation, i finishes units of time earlier, i.e., υ i (T i ) − υ i (T i ) = − . To make this deviation unprofitable, the condition in (10) requires that We construct a pricing scheme q L which satisfies the above condition for every i = 2, . . . , n and every 0 < ≤ t i /2, and has the lowest possible total revenue.
Let q L (t) = 0 for t ≥ t n . Observe that in the latter range q L has the lowest possible prices, so under q L the agent n pays 0 for its efficient allocation. The condition in (21) for i = n and any 0 < ≤ t n /2 requires that To obtain the cheapest pricing scheme we require q L to yield π q L (t n − 2 , t n ) = for every 0 < ≤t n−1 /2. In particular for =t n−1 /2 we get π q L (t n−1 , t n ) =t n−1 /2. This means that under q L the agent i = n − 1 payst n−1 /2.
The latter implies that agent i = n − 2 under q L pays t n−2 (3/4) to the subcontractor. By induction on i it is easily verifiable that under the pricing scheme that satisfies the condition (21) and has the lowest possible price, every agent i ∈ N pays an amount equal tot i (1 − 1/2 n−i ) to the subcontractor. Thus for every coordinating pricing scheme q, it must be the case that Π q ≥ i∈Nt i 1 − 1/2 n−i .

Private processing times
Section 4 shows how to coordinate a set of self-interested agents through a coordinating pricing scheme under the assumption that the vector of true processing times p is given and known to the subcontractor. In this section, we relax this assumption by allowing true processing times to be private information of agents. Thus reporting an untruthful processing time by an agent can deceive the subcontractor who consequently moves the agent's job in the sequence of jobs in efficient allocations which can potentially increase the agent's time saving or reduce his payment. This section presents a mechanism that guarantees that the agents are always better off by reporting their true processing times, and that they are also better off by participating in the subcontracting-such mechanism is refereed to as the coordinating mechanism for the subcontractor scheduling problem under private information. Finally, the section calculates the amount the subcontractor forfeits to the agents to extract the true processing times from them.
We draw upon mechanism design theory (Nisan 2007;Jackson 2000) and introduce a payment scheme that motivates agents to report true processing times knowing the subcontractor's intention to maximize the total savings.
A pricing scheme in Sect. 4 determines payments made by agents to the subcontractor for time intervals that they choose to utilize on the subcontractor's machine. In this section the payments are made for reporting particular processing times by the agents to the subcontractor. Formally, each agent reports a processing time r i from its individual processing time space P i ⊂ R + . We use p i to denote the true processing time of agent i. Let P = P 1 × · · · × P n be the processing time space of all agents.
Definition 2 A mechanism M is defined by a (n + 1)-tuple ( f M , π M 1 , . . . , π M n ) consisting of an allocation function f M : P → T , and a payment scheme π M : P → R n .
Given a vector of reported processing times r and the sequence in which the agents report them (to break ties in the allocation), the payment scheme of a mechanism determines the monetary amount π M i (r ) that i ∈ N pays in return for receiving the allocation prescribed for i by f M .
With quasilinear utilities, a mechanism M would result in the utility for i ∈ N . The subcontractor is seeking to allocate the subcontracting intervals efficiently, thus we focus on mechanisms whose allocation functions yield efficient allocations, i.e., f M ≡ T . We call such mechanisms efficient.
We concentrate on incentive compatible mechanism since they have the potential to motivate the agents to report their true processing times.
Definition 3 A mechanism M is incentive compatible if for every reported processing time vector r = (r 1 , . . . , r n ) and for every agent where r −i is the vector r without its ith coordinate.
Although incentive compatibility implies that agents are not better off by lying about their true processing times, it does not generally imply that the agents are better off by reporting their true processing times-there could generally exist untruthful agent reports that result in the same utility as the truthful ones. Therefore, unfortunately, agents may generally choose to be untruthful after all even with the incentive compatible mechanisms. This is generally the case for VCG mechanisms, in particular the pivotal mechanism, which characterize the class of efficient and incentive compatible mechanisms for quasilinear utilities (Green and Laffont 1977). However, we show later in Theorem 6 that for the subcontractor scheduling problem studied in this paper the pivotal mechanism makes the agents always better off by reporting their true processing times.

Payment scheme
We draw upon the VCG mechanisms to obtain a desirable payment scheme for the subcontractor scheduling problem. The payment scheme for VCG mechanisms is defined as follows where h i is a function independent of agent i's reported processing time r i . Among the class of VCG mechanisms, the pivotal mechanism with guarantees that all payments from the agents to the mechanism are non-negative. Here T (r −i ) is an efficient allocation for the set of jobs excluding job i and for processing time vector r . Thus, the payment by pivotal mechanism for i ∈ N equals wheret j (r ) is the duration of subcontracting time allocated to j by the efficient (optimal) allocation for the reported r and t j (r −i ) is the duration of subcontracting time allocated to j by the efficient allocation for the reported r −i that excludes i. By (30) the payment π P M i (r ) charged by the pivotal mechanism to agent i is the total subcontracting time that could have been allocated to all other agents had not i asked for subcontracting and reported r i . It follows from the characterization of efficient solutions that the exclusion of an agent i reporting r i would only affect the agents that follow i in T (r ). Let σ be the permutation of jobs in T (r ) and let [i], for i ∈ N , be the position of i in T (r ).

Lemma 3 For all i ∈ N , we have
Proof We start by showing that for any i, j ∈ N , we havē , then the exclusion of i affects the duration of allocated time to jobs j without altering the relative position of other jobs. By (4) and (5), we havē Based on the above observation, the total payment in (30) becomes

Coordinating meachanism
Lemma 3 provides a closed-form formula for the pivotal mechanism payments. With these payments, each agent pays an amount directly proportional to the duration of its allocation on subcontractor's machine and inversely proportional to its order in the sequence of jobs on subcontractor's machine. Therefore if an agent announces a shorter than true processing time, which could possibly precipitate its position in the sequence and thus result in the agent's higher time saving, then the agent pays more. We show that as a result of this misrepresentation, the agent's utility decreases. At the same time, we show that reporting longer than true processing time reduces agent's utility as well, unless the agent comes in the last position in the sequence. This position is special since it neither incurs any payment by (31) nor it affects any other agent. Therefore, whether the agent in this position lies or not is irrelevant. Alternatively, one can assume that the longest job always belongs to the subcontractor-this dummy job could represent the continuation of subcontractor's operations. Consequently, the mechanism enforces agents to report their actual processing time which we now formally prove.
Theorem 6 Let r = (r 1 , . . . , r n ) be the reported processing times and let p i be true processing time of agent i. Then u P M i (T ( p i , r −i )) > u P M i (T (r )), provided that p i = r i and i is not in the last position of T (r ).
The last simplifies to Using (36), the last inequality remains valid if t i ( p) is replaced with p i − p i /2 h−l + t i (r )/2 h−l . The inequality then simplifies to r i ≥ p i which is a contradiction. Thus Finally, to ensure agents' participation in subcontracting, the efficient mechanism M must satisfy the strict individual rationality condition requiring that for all agents, truth-telling results in positive utility, irrespective of the reported processing times of other agents. That is, for every r = (r 1 , . . . , r i = p i , . . . , r n ) and all i ∈ N , u M i (T (r )) > 0. The efficient mechanism (T , π P M ) satisfies the strict individual rationality condition since, by (27), (31) and (7), we have u P M i (T (r )) =t i (r )/2 n−[i] > 0, for r i = p i . Thus we showed the mechanism (T , π P M ) guarantees, by Theorem 6, that the agents are always better off by reporting their true processing times, and that, by strict individual rationality, they are better off by participating in the subcontracting. Therefore the mechanism coordinates the subcontractor scheduling problem under private information.
One possible disadvantage of coordination based on mechanism design, the VCG mechanisms in particular, is that this coordination is implicitly centralized-the efficient schedule is computed by the subcontractor and then reported to the agents. Although distributed implementations of the pivotal mechanism where the schedule is determined by the self-interested agents themselves are beyond the scope of this paper, we refer the reader to Parkes and Shneidman (2004) where guidelines for the distributed implementations of the VCG mechanisms are proposed.

Subcontractor's revenue with coordinating mechanisms
The payment scheme π P M provides the subcontractor with a positive revenue for any given r . Let us define Π P M (r ) = i∈N π P M i (r ) as the total payment from agents to the subcontractor in pivotal mechanism. By Theorem 6 all agents except the last in T (r ) report their true processing times while the last one pays nothing to the subcontractor regardless of his report. Therefore, we focus on the subcontractor's revenue for the true processing times p.
Although the subcontractor's services result in the total savings of υ(T ( p)) for all agents, it follows from Lemma 3 that the mechanism (T , π P M ) can only achieve revenue Π P M ( p) for the subcontractor which is always less than v(T ( p)). In fact, instances can be found for which the ratio of subcontractor's revenue to total savings obtained via subcontracting, i.e., Π P M ( p)/υ(T ( p)), is arbitrarily close to zero. For example, consider a set of two jobs with p 1 = 2 and p 2 = 101. Despite having a total saving of 51, we have π P M 1 = 0.5 and π P M 2 = 0 resulting in the ratio υ(T ( p))/Π P M ( p) < 0.01.
Nevertheless, Moulin (1986) shows that if for all agents it holds that min T υ i (T ) = 0-which is the case in subcontractor's subcontracting problem with divisible jobs-then among all efficient, incentive compatible, and individually rational mechanisms, the pivotal mechanism generates the highest total payment. Therefore, the subcontractor cannot gain a higher revenue from any other efficient, incentive compatible, and individually rational mechanisms than it does from (T , π P M ). Thus, by the juxtaposition of Lemma 3 and Theorem 5 we get the following observation.
Corollary 1 Subcontractor's revenue with any efficient, incentive compatible, and individually rational mechanisms under private information never exceeds that with a coordinating pricing scheme under complete information.
However, the construction of a coordinating pricing scheme q requires the knowledge of true processing times p, thus the difference Π q ( p) − Π P M ( p) may be considered as the amount the subcontractor forfeit to the agents to extract the true processing times from them.

Asymmetric valuations
We now relax the assumption of symmetric valuations and assume that the value of a unit time saving for agent i is w i . Let w = (w i |i ∈ N ). The saving to agent i resulting from the allocation T thus equals The total saving for all agents is defined as the sum of individual savings, that is υ w (T ) = i∈N υ w i (T ). The efficient allocation is T = arg max T υ w (T ). Unlike the symmetric case where each job in N is allocated a non-empty interval on subcontractor's machine, in asymmetric case efficient allocations may exclude some jobs from the subcontractor's schedule. Let I = {i ∈ N |t i > 0} be the set of jobs that receive non-empty allocations, and O = {i ∈ N |t i = 0} the set of jobs that receive no such allocations. We denote the cardinality of I with l.
In the remainder of this section, we focus on coordinating pricing schemes in situations with asymmetric valuations. In these situations, any coordinating pricing scheme q meets the following conditions: for t i ≤ t < t i+1 it holds that q(t) < w i , that is, it is required that subcontracting price across the allocation of job i do not exceed its unit saving from subcontracting.
We show by a counterexample that it is generally impossible to construct coordinating pricing schemes in the asymmetric case. Without loss of generality we assume I = {1, . . . , l} and that the jobs are sequenced in efficient solutions by their index order.
Theorem 7 There exists no coordinating pricing scheme in the asymmetric valuation case.
Proof To construct coordinating pricing schemes, we must ensure that agents would not benefit by deviating from the efficient allocations. In particular, deviations of the similar type as in Theorem 5 must be unprofitable for any agent who receives non-zero allocations on the subcontractor's machine. That is for every i = 2, . . . , l and every 0 < < t i it must hold that, Consider the following example. There are four jobs p = ( p 1 = 6, p 2 = 18, p 3 = 19, p 4 = 25) with w = (w 1 = 9, w 2 = 2, w 3 = 12, w 4 = 11). The unique efficient allocation is I = {1, 3, 4} with T 1 = [0, 3), T 3 = [3, 11), T 4 = [11, 18), and O = {2}. For any coordinating pricing scheme, we must have q(t) > 2 for 0 ≤ t < 18 so that job 2 would not be able to choose any interval on subcontractor's machine.
We already know that q (10.5, 11) > 3.25 thus it must be that q (2, 3) > 9.25. This implies that in the cheapest coordinating pricing scheme, agent 1 must pay 9.25 for acquiring the time interval [2, 3) on subcontractor's machine. However, since the valuation of agent 1 is only 9, this means that he would be better off by not accepting that interval. This contradicts the fact that q is coordinating. Therefore, in situations with asymmetric valuations, coordinating pricing schemes may be impossible to find. transportation costs for transportation from and to manufacturers. Finally, the divisibility of jobs can be altered by requesting that only certain parts of jobs with fixed durations can be subcontracted. We leave these issues for future research.