Manipulation, Control, and Beyond: Computational Issues in

Weighted Voting Games

Edith Elkind (U. of Southampton)Based on joint work with:

Y.Bachrach, G. Chalkiadakis, P. Faliszewski,

N. R. Jennings, L. A. Goldberg, P. W. Goldberg,

M. Wooldridge, M. Zuckerman

Power of Coalitions

• Parties: A (45%), B (45%), C (10%)

• Need 50% to pass a bill

• Winning coalitions: AB, AC, BC, ABC

• A, B, and C have equal power

• Given a budget K, what is the right way to distribute it between A, B, and C?– by weight: 0.45K, 0.45K, 0.1K – by power: K/3, K/3, K/3

Applications

• Systems of self-interested agents working together to achieve a goal

• Agent’s contribution = weight

• Suppose the goal is achieved– agents have generated a surplus– how should they divide it?– one possible answer:

according to voting power

Weighted Voting Games: A Formal Model

• n agents: I = {1, …, n}

• vector of weights w = ( w1, …, wn ): integers in binary (unless stated otherwise)

• threshold T

• a coalition J is winning if ∑ iJ wi ≥ T

• value of a coalition: v(J)=1 if J wins, else v(J)=0 • imputation:

p = (p1, …, pn) s.t. pi ≥ 0, p1 + … + pn = 1

• notation: w(J) = ∑iJ wi , p(J) = ∑iJ pi

The “most fair” imputation: Shapley value

Shapley value of agent i: i = a fraction of all permutations of n agents for which i is pivotal

….. i …..

< T

≥ T

Axioms:• efficiency: i i = 1• symmetry• dummy• additivity

monotonicity: wi ≥ wj implies i ≥ j

Plan of the talk

• Manipulation of Shapley value– by voters: weight-splitting– by center: changing the threshold

• Stability in weighted voting games– -core, least core, nucleolus

• Vector voting games

Plan of the talk

• Manipulation of Shapley value– by voters: weight-splitting– by center: changing the threshold

• Stability in weighted voting games– -core, least core, nucleolus

• Vector voting games

Dishonest voters (Bachrach, E., AAMAS’08)

• Can an agent increase his power by splitting his weight between two identities?

• Example: – [2, 2; 4]: 2 = 1/2 [2,1,1; 4]: 2 = 3 = 1/3

2/3 > 1/2 !

• Another example:– [2, 2; 3]: 2 = 1/2 [2,1,1; 3]: 2 = 3 = 1/6

2/6 < 1/2 …

Effects of manipulation: bad guys gain

• Theorem: an agent can increase his power by a factor of 2n/(n+1), and this bound is tight

• Proof:– lower bound: [2, …, 2; 2n] → [2, …, 1, 1; 2n]: 1/n → 2/(n+1)– upper bound: careful bookkeeping of permutations

Effects of manipulation: bad guys lose

• Theorem: an agent can decrease his power by a factor of (n+1)/2, and this bound is tight

• Proof:– l.b.: [2, …, 2; 2n-1] → [2, …, 1, 1; 2n-1]:

1/n → 2(n-1)!/(n+1)!

– u.b.: careful bookkeeping of permutations:

…. i ….… i’ i’’ … … i’’ i’ …

Computational aspects

• Is computational hardness a barrier to manipulation?

• Theorem: it is NP-hard to check if a beneficial split exists

• computing Shapley value is #P-hard anyway…– central authority may have more

computational resources than a single agent– an agent may want to increase his power

even if he cannot compute it

Plan of the talk

• Manipulation of Shapley value– by voters: weight-splitting– by center: changing the threshold

• Stability in weighted voting games– -core, least core, nucleolus

• Vector voting games

Single-winner elections vs. weighted voting

Single-winner elections:• n voters, m candidates

each voter has a preference order

• manipulation– cheating by voters

• control– cheating by center

• bribery

Weighted voting:• n weighted voters,

threshold T

• manipulation– weight splitting/merging

• control– changing the threshold

• bribery ???

Choosing the threshold: bounds on ratio

• Theorem: assume w1≤ … ≤ wn. Changing T– can change n’s power by a factor of n,

and this bound is tight– for players 1, …, n-1, the power can go

from 0 to > 0 (no bound on ratio)

• Proof: – upper bound: 1/n ≤ n ≤ 1– lower bound: (1, …, 1, n)

• T=1: everyone is equal• T=n: 1 =…= n-1 = 0, n = 1

Choosing the threshold: bounds on difference

• Theorem: assume w1≤ … ≤ wn. Changing T

– for n: can change the power by ≤ 1-1/n, and this bound is tight

– for i < n: can change the power by ≤ 1/(n-i+1), and this bound is tight

• Proof: – upper bound: 1/n ≤ i ≤ 1, 0 ≤ i ≤ 1/(n-i+1)

– lower bound: (1, 2, 4, …, 2n-1)• T=2i: 1 =…= i = 0, i =…= n = 1/(n-i+1)

Separating the players

• Suppose wi < wj

• We have i ≤ j

• Can we ensure i < j ?

– yes: set T = wj

• Can we ensure i = j?

– yes: set T = wi

Making a given player a dummy

• w, w1≤ … ≤ wn

• Claim: player 0 is never a dummy iff

i < t wi + w ≥ wt for any t = 1, …, n

• Proof:

=>: if i < t wi + w < wt for some t, set T = wt

<=: w1 w1+ w2 w1+… + wn

T

Computational complexity

• Given T1, T2 and a player i, is T1 better for i than T2?

• NP-hard (reduction from “is i a dummy?”)

• PP-complete – L is in PP if there exists an NP-machine M s.t.

x L iff M accepts w.p. ≥ ½

• Barrier to manipulation

• Pinpointed the exact complexity

Plan of the talk

• Manipulation of Shapley value– by voters: weight-splitting– by center: changing the threshold

• Stability in weighted voting games– -core, least core, nucleolus

• Vector voting games

Good imputations: other criteria

• Fairness: Shapley value, Banzhaf power index

• Stability: core– p is in the core if for any J we have p(J) ≥ v(J)– core can be empty

Lemma: the core is empty <=> no player belongs to all winning coalitions pj > 0

p(J) < 1J

Relaxing the Notion of the Core

• - core: p is in the - core iff for any J p(J) ≥ v(J) - – each winning coalition gets at least 1- – nonempty for large enough (e.g., = 1)

• least core: smallest non-empty -core• if least core = - core

– there is a p s.t. p(J) ≥ 1 - for any winning J– for any ’ there is no p

s.t. p(J) ≥ 1 - ’ for any winning J

Computational Issues:Our Results (E., Goldberg, Goldberg, Wooldridge, AAAI’07)

• Is the core non-empty? – poly-time: use the lemma

• Is the -core non-empty?

• 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 weighted voting game (I; w; T)

reductions from Partition

Computational Issues:Our Results (E., Goldberg, Goldberg, Wooldridge, AAAI’07)

• Is the core non-empty? – poly-time: use the lemma

• Is the -core non-empty? – coNP-hard

• 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 weighted voting game (I; w; T)

reductions from Partition

Pseudopolynomial Algorithms

• Hardness reduction from Partition assumes large weights– recall: wi are given in binary,

– poly-time algorithm <=> runs in time poly (n, log max wi)

• What if weights are small?– formally, the weights are given in unary– we are happy with algorithms

that run in time poly (n, max wi)

max C

p1+…+ pn = 1

pi ≥ 0 for all i = 1, …, n

∑ iJ pi ≥ C for any J s.t. w(J) ≥ T

linear program exponentially many ineqs

Claim: least core = (1 - C)-core

Algorithm For the Least Core

LPs and Separation Oracles

• Separation oracle: – input: (p, C)– output: “yes” if (p, C) satisfies the LP,

violated constraint otherwise

• Claim: 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) < C?– reduces to Knapsack => solvable in pseudopoly time

• Works for other problems listed above

Approximation Algorithms

• Back to large weights…• Theorem: suppose least core = -core.

Then for any we can compute ’ s.t. ’ and ’-core is non-empty in time poly (n, log max wi, 1/)

(FPTAS) • Proof idea: use FPTAS for Knapsack inside

the separation oracle

Refining the Notion of Least Core

I = {a, b, c, d, e}, w = {3, 3, 2, 2, 2}, T = 6– 2 disjoint winning coalitions => ≥ ½– ½-core not empty (hence least core = ½-core):

• p1 = (1/4, 1/4, 1/6, 1/6, 1/6)

p1(ab) = ½, p1(cde) = ½ ,

p1(J) > ½ for other winning coalitions

• p2 = (1/3, 1/6, 1/6, 1/6, 1/6)

p2(ab) = ½, p2(cde) = ½ , p2(bcd) = … = p2(bde) = ½

p2(J) > ½ for other winning coalitionsSome imputations in the least core are better than others…

Nucleolus

• Given an imputation p, order all coalitions by p(J) v(J) (min to max)

p(J1) -v(J1), p(J2) -v(J2), …, p(J2n) - v(J2n) 2n numbers

• Nucleolus: the imputation x that corresponds to lexicographically maximal 2n-vector – always in the least core

winning coalitions:v(J) = 1, p(J) v(J) ≤ 0

losing coalitions:v(J) = 0, p(J) v(J) ≥ 0

Computing Nucleolus

• Can be computed by solving n sequential exp-size linear programs (similar to LP for the least core)

• Our result: NP-hard to compute– not clear if it is in NP

• Pseudopolynomial algorithm for the least core does not seem to generalize

• Approximation algorithm for the least core does not seem to generalize

Computing Nucleolus: Positive Results

• Can we approximate nucleolus payoffs by (normalized) weights?

• NO for individual players: x(i) / w(i) can be arbitrarily small or arbitrarily large.

• YES for coalitions: Theorem:

Suppose wi < T for all i, T ≥ ½. Then 1/2 ≤ x(J) / w(J) ≤ 2 for all coalitions J.

Also 1/2 ≤ x(J) / w(J) ≤ 3 for a larger class of games (see the paper)

Plan of the talk

• Manipulation of Shapley value– by voters: weight-splitting– by center: changing the threshold

• Stability in weighted voting games– -core, least core, nucleolus

• Vector voting games

k-vector weighted voting games

• EU: to pass a bill, need– a certain number of countries AND– a certain fraction of EU population

• Formal model:– voter i has a vector of weights (w1

i, …, wki)

– vector of thresholds T1, …, Tk

– J wins if w1(J) ≥ T1, …, wk(J) ≥ Tk

• Any simple game can be represented as a k-vector weighted voting game

k-vector weighted voting games vs weighted voting games

• 2-vector weighted voting game G– 4 players (9, 1), (1, 9), (5, 5), (5, 5)– T1=T2=10– {1, 2} and {3, 4} are winning coalitions– {1, 3} and {2, 4} are losing coalitions

• G not equivalent to any weighted voting game– w1+w2 ≥ T, w3+w4 ≥ T– w1+w3 < T, w2+w4 < T

contradiction!

Equivalence

• k1-vector weighted voting game G1

• k2-vector weighted voting game G2

• Question: are G1 and G2 equivalent (have the same set of winning coalitions)?

• NP-hard– even if k1 = k2 = 1, or

– even if all weights are in {0, 1}, but not both:

• pseudopolynomial algorithm for k < C

Minimality (1/2)

• k-vector weighted voting game G

• Question: is G minimal, i.e., are all coordinates necessary?

• NP-hard– even if k = 2, or

– even if all weights are in {0, 1}, but not both:

• pseudopolynomial algorithm for k < C

Minimality (2/2)

• k1-vector weighted voting game G1 • Question: is G1 minimum, i.e., is there

a k2-vector weighted voting game G2 with k2 < k1 that is equivalent to G1?

• NP-hard– even if k1 = 2

• pseudopolynomial algorithm for checking whether G1 is equivalent to a weighted voting game (LP with a separation oracle)

Coalition Structures in Weighted Voting Games

• The work so far assumed that the grand coalition will form– Shapley value: dividing a unit of profit– core: stability of the grand coalition

• What if several winning coalitions can form simultaneously?– plausible if T < w(I)/2

• Coalition structures: partitions of I

CS in WVGs: definitions

• coalition structire: CS = {C1, …, Ck}

• imputation for CS: p s.t. p(Ci) = 1 if w(Ci) ≥ T, p(Ci) = 0 if w(Ci) < T– can be p(I)>1

• outcome: pair (CS, p)

• CS-core: (CS, p) is in the CS-core if– p is an imputation for CS– for any S w(S) ≥ T implies p(S) ≥ 1

Results

• coNP-complete to check if an outcome is in the CS-core– pseudopolynomial algorithm:

reduction to KNAPSACK

• NP-hard to check if the CS-core is non-empty– pseudopolynomial algorithm to check if, for given CS,

there is a p s.t. (CS, p) is in the CS-core• linear program with KNAPSACK-based separation oracle

– can enumerate all coalitions, check if there is an appropriate imputation

• heuristics to speed up this process

Conclusions

• Weighted voting games: a model for multiagent systems

• Shapley value: well understood, but can be manipulated

• Other solution concepts (-core, least core, nucleolus): progress on understanding computational complexity

• k-vector weighted voting games– complexity of equivalence and minimality

Extensions and open problems

• False-name voting– split into more than two identities– Manipulation by merging

• how do you distribute gains from manipulation?

– Banzhaf power index

• Bribery in weighted voting games

• Computational complexity of the nucleolus