Computational aspects of stability in weighted voting games Edith Elkind (NTU, Singapore) Based on joint work with Leslie Ann Goldberg, Paul W. Goldberg, Michael Wooldridge, and Dmitrii Pasechnik

Cooperative vs. non-cooperative games Non-cooperative games: – each player can choose an action – payoffs are determined by the action profile Cooperative (coalitional) games: – players can form groups (coalitions) – payoff to a group determined by its composition – players have to share group payoff

Coalitional games: formal model G = (N, v) N={1,..., n}: set of players v: 2 N → R: characteristic function – v(S): payoff available to S, has to be shared among members of S p=(p 1,..., p n ) is an imputation if – p i ≥ 0 for i =1,..., n – p(N) :=  i in N p i = v(N)

Coalitional games with compact representations Weighted voting games (subject of this talk): – G = (w 1,..., w n ; T) – each player i has a weight w i – threshold T – v(S)=1 if w(S) ≥ T, v(S)=0 otherwise Network flow games: – players are edges of a network – value of a coalition = size of the flow it can carry Minimum spanning tree games, matching games, etc.

Coalitional games: stability Which imputations are stable? – no subset of players should want to deviate Core: set of all stable imputations (p 1,..., p n ) is in the core if p(S) ≥ v(S) for all S  N Problem: core may be empty weighted voting game G=(1, 1, 1; 2) suppose wlog p 1 > 0 then p({2, 3}) < 1 v({2, 3}) = 1 recall: p(S) =  i  S p i

When is the core non-empty? Def: G=(N, v) is simple if v(S)  {0, 1} for all S – WVGs are simple games Def: in a simple game, i is a veto player if v(S) = 0 for any S  N \ { i } Claim: a simple game has a non-empty core iff there is a veto player. Also, (p 1,..., p n ) is in the core iff p i = 0 for all non-veto players p i > 0 N S

 -core and least core Need to relax the notion of the core: core: p(S) ≥ v(S) for all S  N  -core: p(S) ≥ v(S) -  for all S  N least core: smallest non-empty  -core – minimizing the worst deficit v(S) - p(S) G=(1, 1, 1; 2): – 1/3-core is non-empty: (1/3, 1/3, 1/3)  1/3-core –  -core is empty for any  < 1/3 – least core = 1/3-core

Can we compute the core,  -core and the least core of weighted voting games?

Computational issues Our Results (E., Goldberg, Goldberg, Wooldridge, AAAI’07) Is the core non-empty? – poly-time: use the lemma For a given , is the  -core non-empty? For a given , is a given imputation p in the  -core? Is a given imputation p in the least core? Construct an imputation in the least core. – p Given a WVG G = (w 1,..., w n ; T) reductions from Partition

Computational issues Is the core non-empty? – poly-time: use the lemma For a given , is the  -core non-empty? – coNP-hard For a given , is a given imputation p in the  -core? – coNP-hard Is a given imputation p in the least core? – NP-hard Construct an imputation in the least core. – NP-hard Given a WVG G = (w 1,..., w n ; T) reductions from Partition

A pseudopolynomial algorithm? Hardness reduction from Partition assumes large weights – recall: w i are given in binary, – poly-time algorithm runs in time poly (n, log w max ) What if weights are small? – e.g., at most poly(n)? – we are happy with algorithms that run in time poly (n, w max )

min c p 1 +…+ p n = 1 p i ≥ 0 for all i = 1, …, n  i  J p i ≥ 1 - c for any J s.t. w(J) ≥ T linear program exponentially many ineqs  Claim: least core = c-core LP for the least core

LPs and separation oracles Separation oracle: – input: (p, c) – output: “yes” if (p, c) satisfies the LP, violated constraint otherwise Fact: LPs with poly-time separation oracles can be solved in poly-time. Our case: given (p, c), is there a J with w(J) ≥ T, p(J) < 1-c? – reduces to Knapsack => solvable in time poly (n, w max ) Works for other problems listed above

An approximation algorithm Back to large weights… Theorem: suppose least core value =  Then for any  we can compute  ’ s.t.  ≤  ’  ≤  and  ’-core is non-empty in time poly (n, log w max, 1/  ) (FPTAS) Proof idea: use FPTAS for Knapsack inside the separation oracle

min c p 1 +…+ p n = 1 p i ≥ 0 for all i = 1, …, n  i  J p i ≥ 1-c for any J s.t. w(J) ≥ T p 1 +…+ p n = 1 p i ≥ 0 for all i = 1, …, n  i  J p i ≥ k  for any J s.t. w(J) ≥ T Approximating the least core LP k, k=1,..., 1/ 

LP k and the least core value p 1 +…+ p n = 1 p i ≥ 0 for all i = 1, …, n  i  J p i ≥ k  for any J s.t. w(J) ≥ T Claim: let k* be the largest value of k such that LP k has a feasible solution. Then the value  of the least core satisfies 1 –  -  ≤ k*  ≤ 1-  Can we find k*? – maybe not, but we can find k’  {k*, k*-1} LP k

An “almost” separation oracle Claim: for each k =1, …, 1/ , there is a procedure SO k that runs in time poly (n, 1/  ) and either correctly implements a separation oracle for LP k or stops and produces a feasible solution to LP k-1 Try to solve LP 1, LP 2, …, LP 1/  using SO 1, SO 2, …, SO 1/  – k’: the largest value of k for which we find a feasible solution (reported by SO k’ or SO k’+1 ) Claim: k’  {k*, k*-1}  ≤ 1 – k*  ≤  +  implies  ≤ 1 – k’  ≤  +2 

Implementing SO k Input to SO k : p 1, …, p n Need to check:  i  J p i ≥ k  for any J s.t. w(J) ≥ T – p’ i = max { j  /n : j  /n ≤ p i } – |p’ i - p i | <  /n – check if there is a J with p’(J) < (k-1) , w(J) ≥ T (DP for Knapsack) if not, p 1, …, p n is a feasible solution for LP k-1 if yes, p(J) ≤ p’(J)+ , so p(J) < k , and hence J is a violated constraint for LP k

Additive => multiplicative We have shown: can compute  ’ s.t.  ≤  ’  ≤  Need:  ’ s.t.  ≤  ’ ≤  Claim: if  > 0 then  ≥ 1/n – proof: some player i is paid at least 1/n N \ { i } is a winning coalition Given , run our algorithm with  ’ =  /n:  ≤  ’ ≤  /n ≤ 

Most stable point? Least core may contain more than one point, not all of them equally good G = (3, 3, 2, 2, 2; 6) p = ( 1/4, 1/4, 1/6, 1/6, 1/6); q = (1/3, 1/6, 1/6, 1/6, 1/6); – p and q are both in the least core = 1/2-core – under p, only 2 coalitions have deficit 1/2 – under q, 5 coalitions have deficit 1/2

Nucleolus: definition deficit: d(p, S) = v(S) - p(S) least core: minimizes worst deficit nucleolus: – minimize worst deficit; – given this, minimize 2 nd worst deficit, etc. deficit vector: d(p) = (d(p, S 1 ),..., d(p, S 2 n )), ordered from largest to smallest Def: nucleolus is an imputation p with lex-minimal deficit vector d(p)

Nucleolus: properties Introduced by Schmeidler (1969) Nucleolus is unique Always in the least core “Most stable” imputation

Can we compute the nucleolus of weighted voting games?

Small vs. large weights Binary weights: NP-hard to compute – reduction from Partition (E., Goldberg, Goldberg, Wooldridge, AAAI’07) Unary weights? – pseudopolynomial algorithm (E., Pasechnik, SODA’09)

Computing nucleolus: general scheme Sequence of linear programs: LP 1 : min (p,  )  p(S) ≥ v(S) –  for all S  2 N (p 1,  1 ): interior optimizer for LP 1  1 : set of tight constraints for (p 1,  1 ) LP 2 : min (p,  )   p(S) = v(S) –  1 for all S   1 p(S) ≥ v(S) –  for all S  2 N \  1 LP 3, LP 4, etc. – till there is a unique solution

Solving LP 1 : weighted voting games Solving LP 1 = finding the least core LP 1 : min (p,  )   p 1 +…+ p n = 1 p i ≥ 0 for all i = 1, …, n p(S) ≥ v(S) –  for all S  2 N Can find (p,  ) in poly-time.  1 ? cannot list explicitly...

How to solve LP 2 ? LP 2 : min (p,  )   p(S) = v(S) –  1 for all S   1  p(S) ≥ v(S) –  for all S  2 N \  1 Is there a poly-time separation oracle for LP 2 ? – input: p 1,..., p n,  ; can assume  <  1 – suppose we have found S with w(S) ≥ T, p(S) < 1-  – this is only useful if S is not in  1 – difficulty:  1 can be exponentially large

How to solve LP j ? LP j : min (p,  )   p(S) = v(S) –  1 for all S   1 ...  p(S) = v(S) –  j-1 for all S   j-1 p(S) ≥ v(S) –  for all S  2 N \(  1 U... U  j-1 )  1,...,  j-1 can be exponentially large

Idea: listing → counting We know  1,...,  j-1 Can assume that we know s 1 =|  1 |,..., s j-1 =|  j-1 | Given a candidate solution (p,  ), suppose we can compute in poly-time – top j distinct deficits m 1,..., m j – n j = number of coalitions with deficit m j Check if – m t =  t, n t = s t for t=1,..., j-1 – m j ≤  Thm: answer is “yes” iff (p,  ) is feasible for LP j

Missing pieces How to implement the counting? – WVGs with unary weights: dynamic programming If the answer is “no”, need to identify a violated constraint – WVGs with unary weights: more dynamic programming

General recipe? Meta-theorem: given a coalitional game G, suppose that we can, for any p and j=1,..., n, identify top j deficits under p and count how many coalitions have those deficits in poly-time. Then we can compute the nucleolus of G in poly-time. Question: for which classes of games can we do this?

Conclusions Stability in weighted voting games – core: poly-time computable –  -core, least-core weakly NP-hard pseudopolynomial algorithm FPTAS – nucleolus weakly NP-hard pseudopolynomial algorithm approximation???

An “almost” separation oracle k’: max {k : SO k has a feasible solution} k’’: max {k : our procedure finds a feasible solution} Claim: k’’  {k’, k’-1} – for k = 1, …, k’: if SO k works, it produces a feasible solution for k if SO k fails, it produces a feasible solution for k-1 – for k = k’+1 if SO k works, it tells us there is no feasible solution for k if SO k fails, it produces a feasible solution for k-1 – for k > k’+1 SO k works and tells us there is no feasible solution for k