Docstoc

Computing nucleolus of weighted voting games

Document Sample
Computing nucleolus of weighted voting games Powered By Docstoc
					 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: 2N→R: characteristic function
   – v(S): payoff available to S,
           has to be shared among members of S
• p=(p1, ..., pn) is an imputation if
   – pi ≥ 0 for i =1, ..., n
   – p(N) := S i in N pi = v(N)
          Coalitional games
    with compact representations
• Weighted voting games (subject of this talk):
  –   G = (w1, ..., wn; T)
  –   each player i has a weight wi
  –   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
  (p1, ..., pn) is in the core if p(S) ≥ v(S) for all S  N
• Problem: core may be empty                 recall: p(S) = S iS pi

  weighted voting game G=(1, 1, 1; 2)
       suppose wlog p1 > 0
       then p({2, 3}) < 1
            v({2, 3}) = 1
    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,                                 S      pi > 0
  (p1, ..., pn) is in the core iff
  pi = 0 for all non-veto players              N
           e-core and least core
  Need to relax the notion of the core:
   core: p(S) ≥ v(S)       for all S  N
   e-core: p(S) ≥ v(S) - e for all S  N
least core: smallest non-empty e-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
   – e-core is empty for any e < 1/3
   – least core = 1/3-core
Can we compute the core,
 e-core and the least core
 of weighted voting
 games?
              Computational issues
   Our Results (E., Goldberg, Goldberg, Wooldridge, AAAI’07)

Given a WVG G = (w1, ..., wn; T)
• Is the core non-empty?
   – poly-time: use the lemma
• For a given e, is the e-core non-empty?

• For a given e, is a given imputation p in the e-core?

• Is a given imputation p in the least core?

• Construct an imputation in the least core.
   –p
                           reductions from Partition
               Computational issues

Given a WVG G = (w1, ..., wn; T)
• Is the core non-empty?
   – poly-time: use the lemma
• For a given e, is the e-core non-empty?
   – coNP-hard
• For a given e, is a given imputation p in the e-core?
   – coNP-hard
• Is a given imputation p in the least core?
   – NP-hard
• Construct an imputation in the least core.
   – NP-hard
                          reductions from Partition
  A pseudopolynomial algorithm?
• Hardness reduction from Partition
  assumes large weights
  – recall: wi are given in binary,
  – poly-time algorithm <=>
    runs in time poly (n, log wmax)
• What if weights are small?
  – e.g., at most poly(n)?
  – we are happy with algorithms
    that run in time poly (n, wmax)
            LP for the least core
               min c
p1+…+ pn = 1
pi ≥ 0 for all i = 1, …, n
S iJ pi ≥ 1 - c for any J s.t. w(J) ≥ T
          linear program 
       exponentially many ineqs 

Claim: least core = c-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, wmax)
• Works for other problems listed above
     An approximation algorithm
• Back to large weights…
• Theorem: suppose least core value = e
  Then for any d we can compute e’ s.t.
  e ≤ e’ ≤ e(1+d) and e’-core is non-empty
  in time poly (n, log wmax, 1/d)
     (FPTAS)
• Proof idea: use FPTAS for Knapsack inside the
  separation oracle
     Approximating the least core
               min c
p1+…+ pn = 1
pi ≥ 0 for all i = 1, …, n
S iJ pi ≥ 1-c for any J s.t. w(J) ≥ T

p1+…+ pn = 1
pi ≥ 0 for all i = 1, …, n               LPk, k=1, ..., 1/d
S iJ pi ≥ kd for any J s.t. w(J) ≥ T
     LPk and the least core value
p1+…+ pn = 1
pi ≥ 0 for all i = 1, …, n                LPk
S iJ pi ≥ kd for any J s.t. w(J) ≥ T
Claim: let k* be the largest value of k such that
   LPk has a feasible solution.
   Then the value e of the least core satisfies
           1 – e - d ≤ k*d ≤ 1- e
Can we find k*?
  – maybe not, but we can find k’ {k*, k*-1}
  An “almost” separation oracle
• Claim: for each k =1, …, 1/d, there is a procedure SOk
  that runs in time poly (n, 1/d) and either
  correctly implements a separation oracle for LPk or
  stops and produces a feasible solution to LPk-1
• Try to solve LP1, LP2, … , LP1/d using SO1, SO2, … , SO1/d
   – k’: the largest value of k for which we find a feasible
     solution (reported by SOk’ or SOk’+1)
• Claim: k’ {k*, k*-1}
  e ≤ 1 – k*d ≤ e+d implies e ≤ 1 – k’d ≤ e+2d
              Implementing SOk

Input to SOk: p1, …, pn
Need to check: S iJ pi ≥ kd for any J s.t. w(J) ≥ T
   – p’i = max { jd/n : jd/n ≤ pi }
   – |p’i - pi| < d/n
   – check if there is a J with p’(J) < (k-1)d, w(J) ≥ T
     (DP for Knapsack)
      • if not, p1, …, pn is a feasible solution for LPk-1
      • if yes, p(J) ≤ p’(J)+d, so p(J) < kd, and hence
           J is a violated constraint for LPk
      Additive => multiplicative
• We have shown: can compute e’ s.t.
                   e ≤ e’ ≤ e+d
• Need: e’ s.t. e ≤ e’ ≤ e(1+d)
• Claim: if e > 0 then e ≥ 1/n
  – proof:
     • some player i is paid at least 1/n
     • N \ { i } is a winning coalition
• Given d, run our algorithm with d’ = d/n:
  e ≤ e’ ≤ e + d/n ≤ e + de = e(1+d)
            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 2nd worst deficit, etc.
• deficit vector: d(p) = (d(p, S1), ..., d(p, S2n)),
    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:
• LP1: min (p, e) e
       p(S) ≥ v(S) – e for all S  2N
    (p1, e1): interior optimizer for LP1
     S1: set of tight constraints for (p1, e1)
• LP2: min (p, e) e
        p(S) = v(S) – e1 for all S  S1
        p(S) ≥ v(S) – e for all S  2N \ S1
• LP3, LP4, etc. – till there is a unique solution
Solving LP1: weighted voting games
Solving LP1 = finding the least core
  LP1: min (p, e) e
       p1+…+ pn = 1
       pi ≥ 0 for all i = 1, …, n
       p(S) ≥ v(S) – e for all S  2N
• Can find (p, e) in poly-time.
• S1? cannot list explicitly...
            How to solve LP2?
LP 2: min (p, e) e
       p(S) = v(S) – e1 for all S  S1
       p(S) ≥ v(S) – e for all S  2N \ S1
  Is there a poly-time separation oracle for LP2?
  – input: p1, ..., pn, e; can assume e < e1
  – suppose we have found S with w(S) ≥ T, p(S) < 1-e
  – this is only useful if S is not in S1
  – difficulty: S1 can be exponentially large
              How to solve LPj?
LP j: min (p, e) e
       p(S) = v(S) – e1 for all S  S1
        ...
       p(S) = v(S) – e j-1 for all S  S j-1
       p(S) ≥ v(S) – e for all S  2N \(S1 U ... U S j-1)

 S1 ,..., S j-1 can be exponentially large
          Idea: listing → counting
• We know e1, ..., e j-1
• Can assume that we know s1=|S1|, ..., s j-1=|S j-1|
• Given a candidate solution (p, e),
  suppose we can compute in poly-time
   – top j distinct deficits m1, ..., mj
   – nj = number of coalitions with deficit mj
• Check if
   – mt = et, nt = st for t=1, ..., j-1
   – mj ≤ e
• Thm: answer is “yes” iff (p, e) is feasible for LPj
               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
  – e-core, least-core
     • weakly NP-hard
     • pseudopolynomial algorithm
     • FPTAS
  – nucleolus
     • weakly NP-hard
     • pseudopolynomial algorithm
     • approximation???
  An “almost” separation oracle
• k’: max {k : SOk has a feasible solution}
• k’’: max {k : our procedure finds a feasible solution}
• Claim: k’’ {k’, k’-1}
   – for k = 1, …, k’:
       • if SOk works, it produces a feasible solution for k
       • if SOk fails, it produces a feasible solution for k-1
   – for k = k’+1
       • if SOk works, it tells us there is no feasible solution for k
       • if SOk fails, it produces a feasible solution for k-1
   – for k > k’+1
       • SOk works and tells us there is no feasible solution for k

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:2
posted:2/21/2013
language:English
pages:33