CPSC Project paper Complexity and Representation of Coalitional Games

(1)

CPSC 502 - Project paper

Complexity and Representation of Coalitional Games

James Wright

Department of Computer Science University of British Columbia Vancouver, B.C., Canada, V6T 1Z4

Abstract

Coalitional game theory is a sub-area of game theory that models situations where agents can benefit from cooperation.

Its representations and solution concepts are NP-hard in the general case. I describe some of the major solution concepts and survey two papers that deal with this general-case intractability. The first studies a specific well-motivated coalitional game and finds that two solution concepts (the core and nucleolus) are tractable in that special case. The second paper provides a gracefully-degrading general representation and algorithms for computing some solution concepts (the Shapley value and the core) from that representation.

Introduction

This paper surveys some current results in the analysis of the complexity and representation of coalitional games, a sub- area of game theory that models situations in which groups of agents can benefit by cooperating. Formally, a coalitional game is represented by a set N of agents and a characteristic functionv : P(N ) → R that maps sets of agents (coalitions) to the payoff that the coalition can guarantee for itself. Since payoffs are evaluated in terms of coalitions rather than individual agents, the main concern becomes to determine equi- table and stable divisions of a group’s payoff.

Representing a coalitional game of n agents requires O(2ⁿ) space in the general case, since each of the 2ⁿcoali- tions can have an arbitrary payoff. This implies that all of the solution concepts require O(2ⁿ) time in the general case. I review two papers that take different approaches to dealing with this intractability.

The first paper (Elkind et al. 2007) analyzes the complexity of a specific class of coalitional games. The second paper (Ieong & Shoham 2005) presents a general representation scheme for coalitional games and algorithms for computing some important solution concepts using that scheme.

In the next section I discuss the solution concepts that are relevant to the two surveyed papers. I then review Elkind et al.(2007) and Ieong & Shoham (2005) in the following two sections, and present conclusions in the final section.

Solution Concepts

In individual games, solution concepts generally relate to finding an equilibrium between the actions of the agents participating in the game. For example, a Nash equilibrium is

one in which no agent has an incentive to unilaterally change its actions given the actions of the other agents.

By contrast, the solution concepts for coalitional games are concerned with finding divisions of the group’s payoff that are stable (in the sense that no sub-coalition has an incentive to defect), or fair (in the sense that agents that con- tribute more to the value of the coalition receive a larger portion of the payoff). A division of payoffs is referred to as an imputation. An imputation is a vector #»p contain- ing one element pi for each agent in the game, such that P

i∈Npi = v(N ). Thus an imputation is a vector that di- vides the payoff of the grand coalition (i.e. the coalition con- taining all of the agents in the game) among all of the agents.

We write p(S) to denoteP

i∈Sp_i.

The next four subsections describe four solution concepts for coalitional games: the core, the Shapley value, the least core, and the nucleolus.

The Core

The core is the best known solution concept for coalitional games. The core is a set of imputations such that no sub- coalition has an incentive to defect from the grand coalition.

An imputation #»p is in the core when

∀S ⊂ N v(S) ≤ p(S) (1)

In other words, the core is the set of imputations for which there is no blocking coalition. A coalition S ⊂ N is a blocking coalition when p(S) < v(S). Intuitively, a blocking coalition is a coalition that receives less benefit from participating in the grand coalition than it could guarantee on its own.

The core for some coalitional games can be empty. Put another way, for some coalitional games, every imputation has at least one blocking coalition. The core is an extremely important solution concept, since any imputation in the core will be automatically stable, whereas any imputation out- side the core requires additional argument to show why the blocking coalition(s) would accept it.

The Shapley Value

Although the core characterizes imputations that are stable, it does not guarantee that the imputation is fair. For example, consider the coalitional game for agents N = {a, b, c}

with the characteristic function of Figure 1. It is easy to ver-

(2)

v({a}) = 3 v({a, b}) = 2 v({a, b, c}) = 9 v({b}) = 1 v({a, c}) = 8

v({c}) = 4 v({b, c}) = 5

Figure 1: An example coalitional game specified by its characteristic function

ify that the imputation [4, 1, 4] has no blocking coalition and is therefore in the core. However, it seems unfair. Agents a and c get the same share of the payoff, even though c can get more by itself than a can. Furthermore, removing c from the grand coalition would drop the payoff from 9 to 2, whereas removing a from the grand coalition would only reduce the coalition’s payoff from 9 to 5. It seems that c ought to receive a larger share than a.

The Shapley value is a solution concept that addresses this fairness issue. It specifies how much of the payoff from the grand coalition should be provided to each agent. Formally, the Shapley value φi(v) for agent i over characteristic function v is defined as follows, where s = |S| and n = |N |:

φ_i(v) = X

S⊆(N \{i})

s!(n − s − 1)!

n! (v(S ∪ {i}) − v(S)) (2)

The Shapley value allocates to each agent the marginal contribution of the agent to the grand coalition, averaged over all possible orderings of the agent’s joining.

To gain an intuition about the Shapley value, imagine building the grand coalition up one agent at a time. Ini- tially, the grand coalition is empty and has value 0. Then the first agent (say a1) joins, and the value of the coalition is v({a1}); agent a1claims this value for itself. Then agent a₂joins, changing the value of the coalition from v({a1}) to v({a1, a2}). Agent a2accepts v({a1, a2}) − v({a1}) as its payment, and so forth.¹

Clearly there are n! orders in which agents can join the grand coalition. There are s! ways in which the agents in set S can join ahead of a given agent i, and (n − s − 1)! ways that the remaining agents can be added to the coalition after i joins after the members of S. So there are s!(n − s − 1)!

orderings out of the total of n! orderings in which agent i will add value v(S ∪ {i}) − v(S) to the grand coalition.

The Shapley value has several desirable properties:

Efficiency A total of v(N ) is distributed to the agents, i.e.

P

i∈Nφi(v) = v(N ).

Symmetry If agents i and j are interchangeable (i.e. v(S ∪ {i}) = v(S ∪ {j}) for any coalition S where i /∈ S and j /∈ S), then φi(v) = φ_j(v).

Dummy If agent i is a dummy player, i.e. its marginal contribution to each group S is the same, then φ_i(v) = v({i}).

1This presentation owes much to the relevant Wikipedia article at http://en.wikipedia.org/wiki/Shapley_value.

Additivity For any two coalitional games v and w over the same set of agents N , φi(v + w) = φi(v) + φi(w) for all i ∈ N .

The imputation that allocates the Shapley value to each agent is not always in the core. For example, the imputation that assigns the Shapley value to each agent for the game of Figure 1 is [3¹₆,²₃, 5¹₆], but {b} is a blocking coalition for that imputation, since it can obtain a payoff of 1 > ²₃ on its own.

The Least Core

The core characterizes the stability of the grand coalition under the assumption that there is no cost to a sub-coalition to defect. The least core generalizes that notion to situations in which it is possible to charge a “defection penalty” to de- fecting sub-coalitions, and allows us to answer the question of how large a defection penalty would need to be charged in order to make the grand coalition stable.

The -core is the set of all imputations that have no blocking coalition when a defection penalty of is charged. In other words, it is the set of imputations #»p such that

∀S ⊂ N v(S) − ≤ p(S) (3)

The -core is the least core if it is non-empty and the ⁰- core is empty for all ⁰ < . Although the -core is usually of interest when is positive (i.e. when the core is empty), it is also possible for to be negative or 0.

For example, the least core of the game in Figure 1 has

= 0. Clearly must be either 0 or negative for this game, because its core (i.e. its 0-core) is non-empty. v({a, c}) = 8 whereas v({a}) + v({c}) = 7, so the entire 1-unit surplus of the grand coalition must be divided between a and c, so any imputation x in the 0-core must satisfy v({b}) = x({b}).

That means cannot be negative, since that would make {b}

a blocking coalition.

The Nucleolus

The nucleolus is a special imputation that spreads the excess most evenly among all the sub-coalitions of the game. The nucleolus is primarily interesting because it is a specific imputation that is guaranteed to be in the core if the core is non-empty.

The excess e( #»p , S) for a coalition S under imputation #»p is

e( #»p , S) = p(S) − v(S) (4) Informally, the excess expresses how much extra benefit the members of S receive by participating in the grand coalition.

This can be related back to the core by noting that a blocking coalition is a coalition whose excess is negative.

The excess vector of an imputation #»p is the vector [e( #»p , S1), e( #»p , S2), . . . , e( #»p , S2ⁿ)], where S1, . . . , S2ⁿis a list of all the subsets of N ordered such that e( #»p , S1) ≤ e( #»p , S₂) ≤ · · · ≤ e( #»p , S₂n). The nucleolus is the imputation #»x = [x1, . . . , xn] that has the lexicographically-largest excess vector. In other words, for all imputations #»p with excess vector [e( #»p , T1), . . . , e( #»p , T2ⁿ)], either e( #»x , S1) >

e( #»p , T₁), or e( #»x , S₁) = e( #»p , T₁) ∧ e( #»x , S₂) > e( #»p , T₂), etc.

(3)

When the core is non-empty, there is at least one imputation such that every coalition has a non-negative excess, and therefore whose least-excess coalition has a non-negative excess. Since the nucleolus’s least-excess coalition has an excess no smaller than the excess of the least-excess coalition of any other imputation, the nucleolus must also be in the core whenever the core is non-empty. This fact makes the nucleolus important, since any algorithm to compute the nucleolus will also compute an imputation in the core if the core is non-empty.

Weighted Threshold Games

Elkind et al. (2007) analyze the complexity of weighted threshold games. A weighted threshold game is a coalitional game in which each player has a weight, which represents its voting power, and a coalition receives a payoff if the total weight of all its members exceeds a constant threshold.

Formally, a weighted threshold game is specified by giv- ing a set of agents N ,² the non-negative weights #»w = [w1, . . . , wn] (where wi is the weight for agent i), and a threshold T . Every coalition S ⊆ N receives a payoff v(S) = 1 ifP

i∈Swi≥ T . Otherwise v(S) = 0.

Elkind et al. (2007) prove several theorems relating to the complexity of the core, least core, and nucleolus of weighted threshold games. I will first present the positive results and algorithms for the core and nucleolus, followed by the hardness results for the least core and the nucleolus. I will then present their approximation algorithms for the least-core and nucleolus.

Positive Results

The first result of Elkind et al. (2007) is the following:

Theorem 1. The core of a weighted threshold game (N, #»w, T ) is non-empty if and only if there is at least one agent i that is present in all winning coalitions, i.e. i ∈

∩v(S)=1S.

This suggests a linear-time algorithm for determining whether the core is empty for a given weighted threshold game: Total up all the weights in the game. For each agent i, compute the total minus wi. If this difference is lower than the threshold, then agent i is indispensable and the core is non-empty. If this difference is at least as large as the threshold for all agents, then no agent is indispensable and the core is empty.

Although it is very valuable to know whether a given game has a non-empty core, it would be even more valuable to construct an imputation that is in the core. The other positive result is a description of the nucleolus for weighted threshold games that have a non-empty core:

Theorem 2. If the core of a weighted threshold game G = (N, #»w, T ) is non-empty, then the nucleolus of G is given by xi = 1/k if i ∈ ∩_v(S)=1S, and xi = 0 otherwise, where k = |{i : i ∈ ∩_v(S)=1S}|.

2Elkind et al. (2007) use I to refer to the set of agents instead of N . For the sake of consistency I refer to the set of agents as N throughout this survey.

Since the nucleolus is guaranteed to be part of the core when the core is non-empty, this gives us an algorithm for constructing an imputation in the core in time linear in the number of agents, whenever any such imputation exists.

Hardness Results

Elkind et al. (2007) prove several hardness results for the least core by reducing from the PARTITION problem. An instance of PARTITIONconsists of a set of positive integers a1, . . . , an such thatPn

i=1ai = 2K. It is a “yes” instance if there is a subset of indices J such thatP

i∈Jai = K, and a “no”-instance otherwise. Determining whether an instance of PARTITIONis a “yes”-instance or a “no”-instance is known to be NP-complete (Garey & Johnson 1990).

Any instance of PARTITION can be converted into a weighted threshold game of n + 1 agents (where the PARTI-

TIONinstance contains n values). The ith agent has weight wi= ai, and the n + 1st agent has weight K. The threshold is set to K. They prove the following lemmas:

1. For any game constructed from a “yes”-instance of PAR-

TITION, the least core is the 2/3-core.

2. For any game constructed from a “yes”-instance of PAR-

TITION, any imputation #»q in the least core satisfies q_n+1= 1/3.

3. For any game constructed from a “no”-instance of PAR-

TITION, the least core is the -core for some < 2/3.

4. For any game constructed from a “no”-instance of PARTI-

TION, any imputation #»q in the least core satisfies qn+1>

1/3.

From these 4 results, Elkind et al. (2007) show that the problems of determining the least core, determining whether a given imputation is in the least core, and constructing an imputation in the least core, are all NP-hard, because 1. If we can determine the value of for the least core, then

we can solve PARTITIONby comparing that value to 2/3.

2. The imputation #»p where pi = _3K^wⁱ is in the least core if and only if the game was constructed from a “yes”- instance of PARTITION, so if we can determine whether an arbitrary imputation is in the least core, then we can solve PARTITIONby checking whether #»p is in the least core.

3. If we can construct an imputation #»q that is in the least core, then we can solve PARTITIONby comparing qn+1

to 1/3.

Note that these results do not contradict the original positive results for the core, because the core (i.e. the 0-core) may not be the least core, even if it is non-empty.³

By a similar reduction from the PARTITION problem, Elkind et al. (2007) show that it is NP-hard to determine whether the nucleolus payoff of a specific agent is 0, and therefore it is also NP-hard to determine what the nucleolus payoff of a specific agent is at all.

3Since in some coalitional games the grand coalition might be stable even for negative , i.e. when a “defection bonus” is paid.

(4)

Approximations

Elkind et al. (2007) describe a pseudopolynomial algorithm⁴ for answering least-core related questions. They also show how to convert that algorithm into a fully-polynomial approximation scheme. This polynomial algorithm can output an ⁰that satisfies ≤ ⁰ ≤ + 2δ, where the least core is the -core and δ is a tunable parameter.

Finally, they show that although the imputation pi =

w_i P

j∈Nwj is a good approximation to the nucleolus for some coalitional games, it is not guaranteed to be within a constant factor of the individual nucleolus payoff in a general coalitional game. They close by proving that this vector is a good approximation for the sum of nucleolus payoffs to coalitions (rather than just individuals), although the impli- cations of that result are unclear.

Marginal Contribution Networks

Ieong & Shoham (2005) describe a general representation scheme for coalitional games called marginal contribution networks. They then describe an algorithm for computing the Shapley value for a game represented as a marginal contribution network in time linear in the size of the representation. Finally, they give an algorithm for determining whether the core is non-empty and whether a specific imputation is in the core based on a tree decomposition of the representation.

In this section I will describe the representation and the Shapley value algorithm in detail.

Representation

A marginal contribution network represents a coalitional game as a series of rules, of the form

pattern → value

A pattern is a conjunction of literals representing agents.

Each literal can be positive, representing that the rule applies only to coalitions that contain the specified agent, or negative, representing that the rule applies only to coalitions that do not contain the specified agent. The value of a coalition is the sum of the values of all the rules that apply to it.

{a} → 5 {c} → 1 {a ∧ d} → 8

{b} → 0 {d} → 2 {a ∧ ¬b} → 3

Figure 2: An example marginal contribution net

For example, in the coalitional game specified by the marginal contribution network of Figure 2, v({a, c}) = 5 + 1 + 3.

This representation is fully expressive in the sense that any coalitional game can be represented by it: For each coalition, create a single rule whose pattern contains a positive literal for each agent in the coalition, and a negative

4i.e. an algorithm that is polynomial for games where each weight is at most polynomially large in the number of players

literal for each agent not in the coalition. The value of the rule is the value of the coalition.

The one-rule-per-coalition, one-coalition-per-rule scheme just described clearly requires space exponential in the number of agents. However, for many games the marginal contribution net representation can do much better. For example, a weighted threshold game of n agents can be represented in n rules, with a rule of the form {i} → wifor each agent i.

Two previously-existing general representations for coalitional games are multi-issue representation (Conitzer &

Sandholm 2004) and graphical form (Deng & Papadimitriou 1994). Ieong & Shoham (2005) prove that marginal contribution nets can represent any game in graphical form in the same amount of space. They also show that a marginal contribution net can represent any game in at most a linear factor more than multi-issue representation. However, it is exponentially smaller than multi-issue representation for some games.

There exist coalitional games that cannot be represented in graphical form. Since marginal contribution nets can represent any graphical form game in the same amount of space, and can also represent games that cannot be represented in graphical form at all, marginal contribution nets are a strict improvement over graphical form games in terms of expres- siveness.

Since a marginal contribution net is at most linearly larger than the same game in multi-issue representation, and for some games is exponentially smaller, marginal contribution nets are a qualified improvement over multi-issue representation as a general representation. They may sometimes require slightly more space than an equivalent multi-issue representation would have, but they will sometimes require far less space.

Computing the Shapley Value

Ieong & Shoham (2005) first prove that the Shapley value of an agent in a marginal contribution network is equal to the sum of the Shapley values of that agent over all rules. They base this on the additivity property of the Shapely value described above.

Having proven this, they give formulae for computing the Shapley value of an agent for a specific rule. If the rule contains m literals, all of which are positive, then the Shapley value for each agent that has a literal is v/m (where v is the value of the rule). This is because the last agent joining the coalition tips it over from having a value of 0 to a value of v, and each agent is the last to join in an equal number of the m! possible joining orders.

If the rule contains p ≥ 0 positive literals and n > 0 negative literals, then every agent i that has a positive literal in the rule has value φi, and every agent j that has a negative literal in the rule has value φj, as defined in equations () and () respectively.

φ_i =(p − 1)!n!

(p + n)! v (5)

φj =p!(n − 1)!

(p + n)! (−v) (6)

(5)

Equation () follows from the fact that the value of a coalition is changed by an agent i with a positive literal only when that agent joins after all the other positive-literal agents, but before any of the negative-literal agents; in that event, i adds v to the value of the coalition. There are (p − 1)! orders in which the other positive-literal agents can join before i, and n! orders in which the n negative-literal agents can join after i. The value of these orders where i adds v to the coalition’s value are averaged over the (p+n)! possible orders in which the p + n agents can join the coalition.

Similarly, equation () follows from the fact that an agent j with a negative literal only changes the value of a coalition (from v to 0) when it joins after all of the positive-literal agents, but before any of the other negative-literal agents.

There are p!(n − 1)! orders that satisfy this constraint, again averaged over the (p + n)! possible orders of joining.

The algorithm for computing the Shapley value of an agent is to apply these formulae to each rule in the marginal contribution net and sum the results. This corresponds to finding the agent’s Shapley value in the sub-game specified by each rule. From the Additivity property of Shapely values, the sum of these values is the Shapley value in the game specified by the sum of the sub-games.

Clearly this algorithm is linear in the size of the marginal contribution net, although recall that in the worst case the net may contain exponentially-many rules in the number of agents.

Conclusions

In this paper, I have described some important solution concepts in coalitional game theory. Representing coalitional games and computing its solution concepts is NP-hard in general. I surveyed two papers representing two different approaches to addressing this intractability.

The first approach is the efficient game-specific algorithms and representation of Elkind et al. (2007). They analyze the special case of weighted threshold games and find tractable algorithms for computing whether the core is empty for a game and for computing the nucleolus for games with a non-empty core. They also prove that the least core is NP-hard in these games but can be approximated.

The second approach is the general algorithms and representation of Ieong & Shoham (2005). They describe a representation (marginal contribution networks) that is very con- cise in the best case, and degrades gracefully as the complexity of the interactions among agents increases. They also provide a general algorithm for finding the Shapley value of an agent given a marginal contribution net that is linear in the size of the input representation.

References

Conitzer, V., and Sandholm, T. 2004. Computing Shapley values, manipulating value division schemes, and checking core membership in multi-issue domains. In Proc. 19th Nat. Conf. on Artificial Intelligence (AAAI), 219–225.

Deng, X., and Papadimitriou, C. 1994. On the complexity of cooperative solution concepts. Math. Oper. Res.

19(2):257–266.

Elkind, E.; Goldberg, L. A.; Goldberg, P. W.; and Wooldridge, M. 2007. Computational complexity of weighted threshold games. In Proc. 22nd Nat. Conf. on Artificial Intelligence (AAAI), 718–723. AAAI Press.

Garey, M., and Johnson, D. 1990. Computers and intractability; a guide to the theory of NP-completeness. WH Freeman & Co. New York, NY, USA716710455:338.

Ieong, S., and Shoham, Y. 2005. Marginal contribution nets: a compact representation scheme for coalitional games. In EC ’05: Proceedings of the 6th ACM conference on Electronic commerce, 193–202. ACM Press.