Operations Research Letters 42 (2014) 76–81

Contents lists available at ScienceDirect

Operations Research Letters

journal homepage: www.elsevier.com/locate/orl

The complexity of egalitarian mechanisms for linearprogramming gamesNelson A. UhanMathematics Department, United States Naval Academy, Annapolis, MD 21402, USA

a r t i c l e i n f o

Article history:Received 30 October 2012Received in revised form2 August 2013Accepted 6 December 2013Available online 14 December 2013

Keywords:Cost sharing mechanismsCooperative gamesComputational complexity

a b s t r a c t

We show that the most cost-efficient subset problem for linear programming games is NP-hard, and infact inapproximable within a constant factor in polynomial time, unless P = NP. This in turn implies thatcomputing the prices output by an egalitarian mechanism and computing a cost allocation in the equalsplit-off set for linear programming games is NP-hard.

Published by Elsevier B.V.

1. Introduction

In a cost sharing problem, there is a set of players and a provider.Each player would like to receive service from the provider, andhas its own private valuation for receiving this service. In orderto determine which players to serve, the provider solicits bidsfrom the players. Considering both the players’ bids and the costsof serving the players, the provider determines which players toserve, and the price it charges each player for service. In otherwords, the service provider determines how the cost of serviceis shared between the players. Based on this determination, eachplayer receives some utility. The algorithm that the provider usesto determine the set of players served and the prices to chargethese players is called a cost sharing mechanism.

There has been a considerable amount of research on costsharing mechanisms, focused primarily on those that satisfy orapproximately satisfy various desirable properties. These include(i) truthfulness, the idea that individual players or groups ofplayers are incentivized to truthfully bid their private valuations,(ii) budget balance, the notion that the prices recover the cost ofproviding service, and (iii) economic efficiency, the idea that thewelfare of the players is maximized. In addition, computationalcomplexity is also often considered in the design of a cost sharingmechanism: it is usually desirable to design amechanism that runsquickly (e.g. in polynomial time).

Various notions of truthfulness have been used in cost sharingmechanism design. One such notion is strategyproofness: a mech-anism is strategyproof if no single player can improve its utilityby bidding a value other than its own valuation. Some stronger

E-mail address: uhan@usna.edu.

0167-6377/$ – see front matter. Published by Elsevier B.V.http://dx.doi.org/10.1016/j.orl.2013.12.003

notions that consider bidding by groups of players have alsobeen used, such as group strategyproofness, group strategyproofnessagainst service-aware players, andweak group strategyproofness (thelast being weaker than the first two).

In lieu of measuring economic efficiency using the traditionalsocial welfare objective, much recent work has adopted thesocial cost objective [21]. In light of existing impossibility resultsinvolving the social welfare objective [11,9], Roughgarden andSundararajan [21] demonstrated that studying the approximabilityof social cost instead allows for a finer distinctionwhen comparingmechanisms on the basis of economic efficiency.

Researchers have introduced and studied various frameworksfor cost sharing mechanisms with differing trade-offs betweenbudget balance, economic efficiency, and truthfulness. Moulin[18] and Moulin and Shenker [19] proposed a class of costsharing mechanisms, now known as Moulin mechanisms, thatuse cross-monotonic cost sharing methods to simulate an iterativeascending auction among the players. These mechanisms areapproximately budget balanced, depending on the underlying costsharing method used, and group strategyproof. Roughgarden andSundararajan [21] introduced the notion of summable cost sharingmethods, and proved that summability characterizes efficiencywith respect to social cost for Moulin mechanisms. Mehta et al.[17] proposed a generalization of Moulin mechanisms calledacyclic mechanisms and showed that thesemechanisms are weaklygroup strategyproof. Bleischwitz et al. [2] introduced egalitarianmechanisms, inspired by thework of Dutta and Ray [8], and showedthat these mechanisms are budget balanced, approximatelyefficient, and group strategyproof against service-aware players.

As one might expect, the efficacy of a cost sharing mechanismstrongly depends on the cost of serving the players. In particular,

N.A. Uhan / Operations Research Letters 42 (2014) 76–81 77

the provider must consider, either implicitly or explicitly, the costto serve every subset of players. These costs can be representedas a cooperative game. Many researchers have focused on usingthe frameworks above to design cost sharing mechanisms forcooperative games arising from specific optimization problems(e.g. [16,12,4,25]). Georgiou and Swamy [10] showed how todesign cost sharing mechanisms for a class of cooperative gameswhose costs can be well-approximated by linear programmingrelaxations of a certain form. The resulting mechanisms arestrategyproof, approximately efficient, and charge prices thatrecover the service cost incurred.

In this work, we focus on a particular class of cooperativegames: linear programming games [20]. A linear programminggame is a cooperative game in which the cost for each subset ofplayers is given implicitly as the optimal value of an underlying lin-ear program whose constraints depend in a structured way on thesubset of players. Several authors have shown that various coop-erative games, especially those arising from network optimizationproblems, can be seen as linear programming games. These includeassignment games [22], maximum flow games [15,14], locationgames [24], and network synthesis games [23], which includemin-imum cost spanning tree games [5] as a special case.

In particular, we examine the computational complexity ofegalitarian mechanisms for linear programming games. Althoughit turns out that egalitarian mechanisms are essentially bestpossible for linear programming games among strategyproofcost sharing mechanisms with respect to budget balance andeconomic efficiency, we show that egalitarianmechanisms are NP-hard to compute. In particular, we show that a key subroutinein egalitarian mechanisms is inapproximable within a constantfactor, unless P = NP. The construction used in the proof of thisresult implies that computing the prices output by egalitarianmechanisms is NP-hard. This construction also has implications onthe computational complexity of the equal split-off set [3] of linearprogramming games.

2. Preliminaries

2.1. Linear programming games

A transferable utility cooperative game is a pair (N, c), whereN = 1, . . . , n represents a finite set of players, and c : 2N

→ Rdefines the cost associatedwith each coalition, or subset of players.A linear programming game [20] is a cooperative game (N, c) inwhich the cost c(S) associated with coalition S ∈ 2N is the optimalvalue of the following linear program:

LPS : minx

fx

s.t. Ax ≥i∈S

di,

x ≥ 0,

with objective function vector f ∈ Rs, constraint matrix A ∈ Rr×s,and requirement vectors di ∈ Rr for each player i ∈ N . We assumethat f , A, and di for all i ∈ N are given so that c is nondecreasing,and LPS has a finite optimal value for every coalition S ∈ 2N . Forexample, these assumptions are satisfied when f ≥ 0, A ≥ 0, anddi ≥ 0 for all i ∈ N (however, note that this is not a necessarycondition). Note that linear programming games are subadditive:that is, for any linear programming game (N, c), we have thatc(S ∪ T ) ≤ c(S)+ c(T ) for all S, T ∈ 2N such that S ∩ T = ∅.

2.2. Cost sharing mechanisms

Mathematically speaking, a cost sharing problem can bedescribed as follows. There is a set of players N = 1, . . . , n

interested in receiving a service, and a cost function c that definesthe cost of providing service to every subset of players. In otherwords, (N, c) is a cooperative game. Note that service is binary: aplayer either receives or does not receive service. Each player i ∈ Nhas a private valuation vi for receiving service; that is, vi is themostthat player i iswilling to pay for the service. In addition, each playeri ∈ N announces a bid bi, a public broadcast of the amount it iswilling to pay for the service, which may or may not be differentfrom its true valuation vi. A cost sharing mechanism is an algorithmthat takes the cooperative game (N, c) and the players’ bids bi forall i ∈ N as input, and outputs (i) a set of players S to be served,and (ii) prices pi that each player i ∈ N will pay. The pair (S, p) iscalled an outcome of a cost sharing mechanism. Note that strictlyspeaking, S and p are functions of the cooperative game (N, c) andbids bi for all i ∈ N .

Cost sharing mechanisms are typically designed to satisfy thefollowing standard assumptions: (i) individual rationality, that is,for any outcome (S, p), pi ≤ bi for all i ∈ S, and pi = 0 for alli ∈ N \ S; and (ii) no positive transfers, that is, for any outcome(S, p), pi ≥ 0 for all i ∈ N . In addition, we make the commonassumption that players maximize quasilinear utilities: that is, theutility ui(S, p) of player i with outcome (S, p) is viδi − pi, whereδi = 1 if i ∈ S and δi = 0 if i ∈ N \ S.

One goal in designing a cost sharing mechanism is to ensurethat it is truthful: that is, to make sure that both individualplayers as well as groups of players are incentivized to bid theirtrue valuations. There are various notions of truthfulness. Themost basic is strategyproofness: a mechanism is strategyproof ifno single player can increase its utility by false bidding (biddinga value other than its valuation), when all other bids are keptfixed. Group strategyproofness takes this idea one step further: amechanism is group strategyproof if false bidding by any coalitionthat increases the utility of one of its members also decreasesthe utility of another one of its members, when all other bidsare fixed. A mechanism is group strategyproof against service-aware players [2] if it is group strategyproof with respect tomodified utility functions in which a player strictly prefers beingserved at a price equal to its valuation over not being served atall. Other notions of truthfulness that have been studied in theliterature include weak group strategyproofness [6], and weakgroup strategyproofness against service-aware players [2].

One important property of a cost sharingmechanism iswhetherit recovers or approximately recovers the cost of service. For anyβ ∈ [0, 1], we say that a cost sharing mechanism is β-budget-balanced if

βc(S) ≤i∈S

pi ≤ c(S)

for any outcome (S, p) of the mechanism.

In other words, the cost sharing mechanism always recovers atleast a fraction β of the cost of service. We sometimes refer to β

as a mechanism’s budget balance guarantee.Another important property of a cost sharing mechanism is

whether it outputs an outcome that is economically efficient.Muchof the recent literature on cost sharing mechanisms uses socialcost [21] as a measure of economic efficiency. The social cost ofan outcome (S, p) of a cost sharingmechanism is defined as c(S)+

i∈N\S vi. For any α ≥ 1, a cost sharing mechanism is α-efficient if

c(S)+i∈N\S

vi ≤ α minT⊆N

c(T )+

i∈N\T

vi

for any outcome (S, p) of the mechanism. We sometimes refer toα as a mechanism’s efficiency guarantee.

78 N.A. Uhan / Operations Research Letters 42 (2014) 76–81

3. Egalitarian mechanisms for linear programming games

Egalitarian mechanisms [2] were inspired by an algorithmic ideafor egalitarian allocations in convex cooperative games originallyproposed by Dutta and Ray [8]. Roughly speaking, at everyiteration, an egalitarian mechanism finds the most ‘‘cost efficient’’subset of players that have not yet been assigned a price, andassigns each of these players their collective average marginal costas its price.

Formally, we can describe an egalitarian mechanism as follows.For a cooperative game (N, c) and coalition S ∈ 2N , we define thefunction

gS(T ) =c(S ∪ T )− c(S)

|T |for all T ⊆ N \ S such that T = ∅.

Themost cost-efficient subset problem for a cooperative game (N, c)with respect to R ⊆ N and S ( R is

minT⊆R\S:T=∅

gS(T ).

Algorithm 3.1 describes the egalitarian mechanism for a coopera-tive game (N, c).

Algorithm 3.1. (Egalitarian mechanism).

Input: cooperative game (N, c); bid vector b ∈ Rn

Output: set of served players S ∈ 2N ; prices p ∈ Rn≥0

1 R← N; S ← ∅; pi ← 0 for all i ∈ N2 while R = S do3 T ∗ ← argminT⊆R\S:T=∅gS(T ) (break ties arbitrarily)4 a← gS(T ∗)5 if bi ≥ a for all i ∈ T ∗ then6 pi ← a for all i ∈ T ∗7 S ← S ∪ T ∗8 else9 R← R \ i ∈ T ∗ : bi < a

10 end if11 end while

Bleischwitz et al. [2] showed that egalitarian mechanismsare group strategyproof against service-aware players, 1-budget-balanced, and if the cost function c is nonnegative and subad-ditive, 2Hn-efficient. This result holds for linear programminggames, since these games are nonnegative and subadditive. It turnsout that these are essentially best possible budget balance andefficiency guarantees for linear programming games: Dobzinskiet al. [7] showed that any O(1)-budget-balanced strategyproofcost sharing mechanism for publicly excludable games is Ω(log n)-efficient. A publicly excludable game is a cooperative game (N, c)with c(S) = 1 for all S ∈ 2N

\ ∅, and c(∅) = 0. It is straightfor-ward to see that linear programming games include publicly ex-cludable games.

Lemma 3.2. A publicly excludable game is a special case of a linearprogramming game.

Proof. Consider the following linear programming game (N, c)with n = r and s = 1. The objective function vector, constraintmatrix and requirement vectors are

f = 1, A = 1n, di = 1n(i) for all i ∈ N,

where 1n∈ Rn is a vector of ones, and 1n(i)

∈ Rn is the ithelementary unit vector in Rn. It follows that c(∅) = 0 and c(S) = 1for any coalition S ∈ 2N

\ ∅.

On the other hand, we show that egalitarian mechanisms forlinear programming games have high computational complexity:unfortunately, it turns out that the most cost-efficient subsetproblem for linear programming games is NP-hard, and in factinapproximablewithin a constant factor in polynomial time, unlessP = NP. The proof of this result also implies that computing theprices output by egalitarian mechanisms for linear programminggames is NP-hard.

Remarks. Bleischwitz et al. [2] actually defined egalitarian mech-anisms as a class of cost sharing mechanisms that includes the onedescribed in Algorithm 3.1. In particular, they allowed for a moregeneralway of computing the subset T ∗ in line 3 and the associatedprice a in line 4. However, the budget balance and efficiency guar-antees mentioned above were shown specifically for the mecha-nism described in Algorithm 3.1.

Georgiou and Swamy [10] gave a different cost sharing mech-anism that is strategyproof, O(log n)-efficient, and charges pricesthat recover the cost incurred, for any cooperative game (N, c)with nondecreasing cost function c . This mechanism is not neces-sarily 1-budget-balanced, because the total prices charged are notbounded above.

Theorem 3.3. The most cost-efficient subset problem for linear pro-gramming games is NP-hard. In addition, there is no ρ-approximationalgorithm for the most cost-efficient subset problem for linear pro-gramming games, for any ρ ∈ O(n1/2−ε) and ε > 0, unless P = NP.

Proof. We show that any instance of the maximum cardinality setpacking problem can be reduced to an instance of the most cost-efficient subset problem for linear programming games. Roughlyspeaking, we construct a linear programming game in which theplayers are divided into two sets: ‘‘real’’ players who correspondto the family of subsets given in the set packing problem, and‘‘dummy’’ players. The underlying linear programs are constructedso that the difference between the cost for a coalition that consistsof both ‘‘real’’ and ‘‘dummy’’ players and the cost for a coalition thatconsists of only ‘‘dummy’’ players is small when the ‘‘real’’ playerscorrespond to a set packing, and large otherwise. As a consequence,an approximation algorithm for the most cost-efficient subsetproblem can take advantage of this gap to find an approximatelymaximum cardinality set packing.

Consider an arbitrary instance of the maximum cardinality setpacking problem, with a collection C = C1, . . . , Cm of nonemptysubsets of 1, . . . , q. Recall that the objective of this problem is tofind a packing —a subset T ⊆ 1, . . . ,m such thatmaxj=1,...,q |i ∈T : j ∈ Ci| ≤ 1 — of maximum cardinality. Without loss ofgenerality, we assume thatm ≥ 2.

From this instance of the maximum cardinality set packingproblem, we construct the following linear programming gamewith n = m + ℓ + 1 players, for some ℓ ∈ Z>0. For any k ∈ Z>0,let 1k

∈ Rk denote a vector of ones, 0k∈ Rk denote a vector of

zeros, and 1k(i)∈ Rk denote the ith elementary unit vector in Rk. In

addition, for each i = 1, . . . ,m, let 1Ci ∈ Rq denote the indicatorvector for Ci. The dimensions of f , A and di for each i ∈ N are givenby r = q + m + ℓ + 1 and s = 3. We define f , A, and di for eachi ∈ N as follows:

f = (m2 1 1), A =

1q 0q 0q

0m 1m 0m

0ℓ 1ℓ 0ℓ

0 0 1

,

di =

1Ci

1m(i)

−m2· 1ℓ

0

for i = 1, . . . ,m,

N.A. Uhan / Operations Research Letters 42 (2014) 76–81 79

dm+i =

0q

0m

m2· 1ℓ(i)

0

for i = 1, . . . , ℓ,

dm+ℓ+1=

−1q

0m

−m2· 1ℓ

m2

.

Note that

i∈T 1Cij = |i ∈ T : j ∈ Ci| for j = 1, . . . , q. For all

T ⊆ 1, . . . ,m, let π(T ) = maxj=1,...,q |i ∈ T : j ∈ Ci|. Bydefinition, π(T ) ≤ 1 if and only if T is a packing. Since C1, . . . , Cmare nonempty, π(T ) ≥ 1 for any T = ∅.

We evaluate c for different coalitions. First, note that c(∅) = 0.For all T ⊆ 1, . . . ,m such that T = ∅, we have that

c(T ) =

min

xm2x1 + x2 + x3

s.t. x1 ≥ |i ∈ T : j ∈ Ci| for j = 1, . . . , q,x2 ≥ 1, x2 ≥ 0,x2 ≥ −m2

|T |,x3 ≥ 0,x1, x2, x3 ≥ 0

= m2π(T )+ 1,

c(T ∪ m+ ℓ+ 1)

=

min

xm2x1 + x2 + x3

s.t. x1 ≥ |i ∈ T : j ∈ Ci| − 1 for j = 1, . . . , q,x2 ≥ 1, x2 ≥ 0,x2 ≥ −m2

|T | −m2,

x3 ≥ m2,x1, x2, x3 ≥ 0

= m2π(T )+ 1.

For all S ⊆ m+ 1, . . . ,m+ ℓ such that S = ∅, we have that

c(S) =

minx

m2x1 + x2 + x3

s.t. x1 ≥ 0,

x2 ≥ 0,

x2 ≥ m2, x2 ≥ 0,

x3 ≥ 0,

x1, x2, x3 ≥ 0

= m2,

c(S ∪ m+ ℓ+ 1) =

minx

m2x1 + x2 + x3

s.t. x1 ≥ −1

x2 ≥ 0,

x2 ≥ 0, x2 ≥ −m2,

x3 ≥ m2,

x1, x2, x3 ≥ 0

= m2.

Finally, for all T ⊆ 1, . . . ,m and S ⊆ m + 1, . . . ,m + ℓ suchthat S, T = ∅, we have that

c(T ∪ S) =

minx

m2x1 + x2 + x3

s.t. x1 ≥ |i ∈ T : j ∈ Ci| for j = 1, . . . , q,

x2 ≥ 1, x2 ≥ 0,

x2 ≥ −m2|T | +m2, x2 ≥ −m2

|T |,

x3 ≥ 0,

x1, x2, x3 ≥ 0

= m2π(T )+ 1,

c(T ∪ S ∪ m+ ℓ+ 1)

=

minx

m2x1 + x2 + x3

s.t. x1 ≥ |i ∈ T : j ∈ Ci| − 1 for j = 1, . . . , q,

x2 ≥ 1, x2 ≥ 0,

x2 ≥ −m2|T |, x2 ≥ −m2

|T | −m2,

x3 ≥ m2,

x1, x2, x3 ≥ 0

= m2π(T )+ 1.

Since π(T ) ≥ 1 for all T = ∅ and π is nondecreasing, it followsthat c is nondecreasing.

Note that the objective function of the most cost-efficientsubset problem for (N, c) with respect to R = N and S = m +1, . . . ,m+ ℓ+ 1 is

gS(T ) =m2π(T )+ 1−m2

|T |

=

1|T |

if T is a packing,

1+m2(π(T )− 1)|T |

otherwise

for all T ⊆ R \ S = 1, . . . ,m such that T = ∅. It follows that forany T = ∅,

gS(T ) ≤ 1 if T is a packing, and

gS(T ) ≥ m+1m

if T is not a packing,(3.1)

since 1 ≤ |T | ≤ m, and π(T ) ≥ 2 if T is not a packing. Note thatgS(T ) is minimized when T is a maximum cardinality packing.

Let ℓ = 1, so that n = m + 2. Suppose there exists a ρ-approximation algorithm for the most cost-efficient subset prob-lem for some ρ ∈ O(n1/2−ε) = O(m1/2−ε) and ε > 0. Let T be theoutput of this algorithm when applied to the most cost-efficientsubset problem for the linear programming game (N, c) con-structed above with R = N and S = m + 1,m + 2. By (3.1),T must be a packing whose cardinality is within a factor ρ of themaximumcardinality of a packing. However, this is a contradiction,since there is noρ-approximation algorithm for themaximumcar-dinality set packing problem for any ρ ∈ O(m1/2−ε) and ε > 0unless P = NP [1,13].

Bleischwitz et al. [2, Lemma 4.7] showed that the prices com-puted in Step 4 of Algorithm 3.1 are nondecreasing throughout theexecution of the algorithm.Using this fact, alongwith the construc-tion in the proof of Theorem 3.3, we can show that computing theprices output by egalitarian mechanisms is NP-hard.

Corollary 3.4. Computing the prices output by egalitarian mecha-nisms for linear programming games is NP-hard.

Proof. Consider the linear programming game (N, c) in the proofof Theorem 3.3 with ℓ = m3. Fix some ε > 0. Suppose we runthe egalitarian mechanism with input (N, c) and bids bi = 1 + εfor all i ∈ N . In the first iteration, the mechanism computesminT⊆N:T=∅ g∅(T ). Recall that g∅(T ) = c(T )/|T |. For any T ⊆1, . . . ,m such that T = ∅, we have that

c(T )

|T |=

m2π(T )+ 1|T |

≥m2+ 1m

.

In addition, for any T ⊆ m+1, . . . ,m+m3+1 such that T = ∅,

we have that

c(T )

|T |=

m2

|T |≥

m2

m3 + 1,

80 N.A. Uhan / Operations Research Letters 42 (2014) 76–81

and this holds with equality only when T = m+1, . . . ,m+m3+

1. Finally, for any T = T1 ∪ T2 such that T1 ⊆ 1, . . . ,m, T2 ⊆m+ 1, . . . ,m+m3

+ 1, and T1, T2 = ∅, we have that

c(T )

|T |=

m2π(T )+ 1|T |

≥m2+ 1

m+m3 + 1.

Since

m2+ 1m

>m2+ 1

m+m3 + 1>

m2

m3 + 1,

we have that

minT⊆N:T=∅

g∅(T ) =m2

m3 + 1,

arg minT⊆N:T=∅

g∅(T ) = m+ 1, . . . ,m+m3+ 1.

Let S = m+ 1, . . . ,m+m3+ 1. Since bi = 1+ ε for all i ∈ N ,

each player in S is assigned a pricem2/(m3+1), and in the next iter-

ation, themechanism computesminT⊆N\S:T=∅ gS(T ). By argumentsin the proof of Theorem 3.3, we have that minT⊆N\S:T=∅ gS(T ) ∈[1/m, 1]. Again, since bi = 1 + ε for all i ∈ N , each player inargminT⊆N\S:T=∅ gS(T ) is assigned a price of at least 1/m. Note thatm2/(m3

+ 1) < 1/m. Since prices throughout the execution ofthe egalitarian mechanism are nondecreasing, it follows that inany set of prices output by the egalitarian mechanism with input(N, c) and bids bi = 1 + ε for all i ∈ N , the second smallest non-zero price allocated to any player is equal to the optimal value ofminT⊆N\S:T=∅ gS(T ), whichwas shown to be NP-hard to compute inthe proof of Theorem 3.3.

The most cost-efficient subset problem has also been used todefine solution concepts in cooperative game theory. The equalsplit-off set [3] of a subadditive cooperative game (N, c) is theset of all cost allocations that can be computed by the followingalgorithm, again, inspired by the algorithm of Dutta and Ray [8].(Note that Branzei et al. [3] define the equal split-off set forsuperadditive reward cooperative games. Here, we look at thenatural equivalent for cost cooperative games.)

Algorithm 3.5. (Computing a cost allocation in the equal split-offset).

Input: subadditive cooperative game (N, c)Output: cost allocation χ ∈ RN

1 S ← ∅; χi ← 0 for all i ∈ N2 while S = N do3 T ∗ ← argminT⊆N\S:T=∅ gS(T ) (break ties arbitrarily)4 a← gS(T ∗)5 χi ← a for all i ∈ T ∗6 S ← S ∪ T ∗7 end while

Branzei et al. [3, Proposition 2] showed that the cost allocationscomputed in Step 4 of Algorithm3.5 are nondecreasing throughoutthe execution of the algorithm. Using this fact and an almostidentical proof to that of Corollary 3.4, we can show the following.

Corollary 3.6. Computing a cost allocation in the equal split-off set oflinear programming games is NP-hard.

4. Concluding remarks

One natural research direction extending from this work to in-vestigate whether a variant of an egalitarian mechanism for lin-ear programming games can be computed in polynomial time,

perhaps by relaxing its budget balance or efficiency guarantees.Bleischwitz et al. [2] proposed a framework for designing ap-proximately budget-balanced and economically efficient egalitar-ianmechanisms, and applied this framework to various schedulingand bin packing cooperative games. Their framework relies on anotion of size for each player, so that the players can be sequencedaccording to their size. This is natural in scheduling and bin pack-ing contexts, in which each player has a job or item of a particularlength. For linear programming games, however, it is not immedi-ately clear what might constitute a good sequence of players.

On a related note, the techniques of Georgiou and Swamy [10]can be adapted to construct a cost sharing mechanism for linearprogramming games with di ≥ 0 for all i ∈ N that is strategyproof,O(log n)-efficient, charges prices that recover the cost incurred,and runs in polynomial time.

Acknowledgments

The author thanks an anonymous referee for helpful comments,pointing out thework byGeorgiou and Swamy [10], and explaininghow it can be applied to linear programming games.

References

[1] G. Ausiello, A. D’Atri, M. Protasi, Structure preserving reductions amongconvex optimization problems, J. Comput. System Sci. 21 (1) (1980) 136–153.

[2] Y. Bleischwitz, B. Monien, F. Schoppmann, To be or not to be (served):cost sharing without indifferences, in: Preliminary version appeared inProceedings of the 3rd International Workshop On Internet and NetworkEconomics (WINE’07), 2010. Working paper.

[3] R. Branzei, D. Dimitrov, S. Tijs, The equal split-off set for cooperative games,in: Proceedings of the Game Theory andMathematical Economics Conference,Vol. 71, Banach Center Publications, 2006, pp. 39–46.

[4] J. Brenner, G. Schäfer, Group-strategyproof cost sharing mechanisms formakespan and other scheduling problems, Theoret. Comput. Sci. 401 (1–3)(2008) 96–106.

[5] A. Claus, D.J. Kleitman, Cost allocation for a spanning tree, Networks 3 (4)(1973) 289–304.

[6] N.R. Devanur,M.Mihail, V.V. Vazirani, Strategyproof cost-sharingmechanismsfor set cover and facility location games, Decis. Support Syst. 39 (1) (2005)11–22.

[7] S. Dobzinski, A. Mehta, T. Roughgarden, M. Sundararajan, Is Shapley costsharing optimal? in: B. Monien, U.-P. Schroeder (Eds.), Proceedings of the1st International Symposium on Algorithmic Game Theory, (SAGT 2008),in: Lecture Notes in Computer Science, vol. 4997, Springer, Berlin, 2008,pp. 327–336.

[8] B. Dutta, D. Ray, A concept of egalitarianism under participation constraints,Econometrica 57 (3) (1989) 615–635.

[9] J. Feigenbaum, A. Krishnamurthy, R. Sami, S. Shenker, Hardness results formulticast cost sharing, in: M. Agrawal, A. Seth (Eds.), 22nd Conferenceon Foundations of Software Technology and Theoretical Computer Science,FSTTCS 2002, in: Lecture Notes in Computer Science, vol. 2556, Springer, 2002,pp. 133–144.

[10] K. Georgiou, C. Swamy, Black-box reductions for cost-sharing mechanismdesign, in: Proceedings of the 23rd Annual ACM-SIAM Symposium on DiscreteAlgorithms, SODA, SIAM, 2012, pp. 896–913.

[11] J. Green, E. Kohlberg, J.J. Laffont, Partial equilibrium approach to the free riderproblem, J. Public Econ. 6 (4) (1976) 375–394.

[12] A. Gupta, A. Srinivasan, É. Tardos, Cost-sharing mechanisms for networkdesign, Algorithmica 50 (1) (2008) 98–119.

[13] J. Håstad, Clique is hard to approximate within n1−ε , ActaMath. 182 (1) (1999)105–142.

[14] E. Kalai, E. Zemel, Totally balanced games and games of flow, Math. Oper. Res.7 (3) (1982) 476–478.

[15] E. Kalai, E. Zemel, Generalized network problems yielding totally balancedgames, Oper. Res. 30 (5) (1982) 998–1008.

[16] J. Könemann, S. Leonardi, G. Schäfer, A group-strategyproof mechanism forSteiner forests, in: Proceedings of the 16th Annual ACM-SIAM Symposium onDiscrete Algorithms, SODA 2005, SIAM, 2005, pp. 612–619.

[17] A. Mehta, T. Roughgarden, M. Sundararajan, Beyond Moulin mechanisms,Games Econom. Behav. 67 (1) (2009) 125–155.

[18] H. Moulin, Incremental cost sharing: characterization by strategy-proofness,Soc. Choice Welf. 16 (2) (1999) 279–320.

[19] H. Moulin, S. Shenker, Strategyproof sharing of submodular costs: budgetbalance versus efficiency, Econom. Theory 18 (3) (2001) 511–533.

[20] G. Owen, On the core of linear production games, Math. Program. 9 (1) (1975)358–370.

[21] T. Roughgarden, M. Sundararajan, Quantifying inefficiency in cost-sharingmechanisms, J. ACM 56 (4) (2009) 23:1–23:33.

N.A. Uhan / Operations Research Letters 42 (2014) 76–81 81

[22] L.S. Shapley, M. Shubik, The assignment game I: the core, Internat. J. GameTheory 1 (1) (1971) 111–130.

[23] A. Tamir, On the core of network synthesis games, Math. Program. 50 (1–3)(1991) 123–135.

[24] A. Tamir, On the core of cost allocation games defined on location problems,Transp. Sci. 27 (1) (1993) 81–86.

[25] D. Xu, R. Yang, A cost-sharing method for an economic lot-sizing game, Oper.Res. Lett. 37 (2) (2009) 107–110.