Vignette for version 0.2.2 of CoopGame

This is the place to emphasize once again that this vignette accompanies version 0.2.2 of the R package CoopGame. Future releases of CoopGame might incorporate additional functionality and will be accompanied by an update of this vignette.

Specifying a TU game

Let us look at an introductory example of a three-player TU game. Let N = {1, 2, 3} and v : 𝒫(N) → ℝ be specified as
$$ \begin{aligned} v(\emptyset) & = 0, \\ v(\{ 1 \}) & = 0, \\ v(\{ 2 \}) & = 0, \\ v(\{ 3 \}) & = 0, \\ v(\{ 1,2 \}) & = 100, \\ v(\{ 1,3 \}) & = 115, \\ v(\{ 2,3 \}) & = 125, \\ v(\{ 1,2,3 \}) & = 220. \end{aligned} $$ We may interpret the values of the individual coalitions in various ways, e.g. as the worth of a coalition or the cost-savings of a coalition. In our above example the singleton coalitions have worth zero whereas the grand coalition N = {1, 2, 3} makes a total of 220 (monetary units). In brief, the basic question in coalitional games with transferable utility is how we can share the worth of 220 among our three players. In R we can simply specify the above game as a vector v of lenght 7, i.e.

library(CoopGame)
## Loading required package: geometry
## Loading required package: rcdd
## If you want correct answers, use rational arithmetic.
## See the Warnings sections in help pages for
##     functions that do computational geometry.
(v <- c(0,0,0,100,115,125,220))
## [1]   0   0   0 100 115 125 220

Sometimes it is convenient to use the shorthand notations v_i = v({i})  for  i = 1, …, n, for the singleton coalitions.

A popular example: The Maschler game

Throughout this vignette we will frequently employ the following three-player example $$ v(C) = \Bigg\{ \begin{aligned} 0, & \quad \vert C \vert = 1 \\ 60, & \quad \vert C \vert = 2 \\ 72, & \quad \vert C \vert = 3 \end{aligned} $$

It appears in the article [6] where the authors attribute it to the famous Israeli game theorist Michael Maschler. The above game has thus frequently been referred to as the Maschler game in the literature since.

library(CoopGame)
(Maschler <- c(0,0,0,60,60,60,72))
## [1]  0  0  0 60 60 60 72

Functionality and structure of the package CoopGame

The package CoopGame provides functions for

• generating TU games with special structure (see chapter 2 of this vignette), like e.g. bankruptcy games, cost games, weighted voting games and unanimity games
• checking game properties (see chapter 3 of this vignette), like e.g. superadditivity, convexity and balancedness
• computing a number of set-valued solution concepts for TU games (see chapter 4 of this vignette), including the core and various core catchers
• computing a large array of point-valued solution concepts for TU games (see chapter 5 of this vignette), including the Shapley value, the nucleolus as well as various nucleolus derivatives and numerous power indices
• drawing both set- and point-valued solution concepts for the 3- and 4-player cases (see chapter 6 of this vignette)
• some general functionality useful in the context of TU games (see section 1.2 of this vignette), like e.g. computing the unanimity coefficients for a given game vector

Models and questions beyond the scope of CoopGame

Coalitional games can be turned into more realistic models if, in addition one allows for partitions of the player set (see e.g. the original paper by Thrall and Lucas [7]) or for specifying an undirected graph connecting the players. The latter case is frequently referred to as a communication game (see e.g. the book by Slikker and van den Nouweland [8]). The authors are currently developing additional R packages for both games with partitions of the player set as well as communication games. These additional software packages will make use of CoopGame, but CoopGame itself will allow for neither partitions or communication structures.

Since CoopGame can neither handle partitions nor other more general coalition structures (see e.g. the paper by Aumann and Dreze [9] from 1974), the package neither provides methods for computing bargaining sets (see e.g. the original paper by Aumann and Maschler [10] from 1964) nor methods for computing the kernel (see e.g. the original article by Aumann, Peleg and Rabinowitz [11] from 1965).

Another feature this first release of CoopGame also lacks is functionality for general market games (see e.g. the original paper by Aumann [12] on markets with a continuum of traders from 1964).

Also, NTU games, i.e. cooperative games with non-transferable utility (see e.g. the article by Aumann and Maschler [13] from 1960), are beyond the scope of this R package.

This is not a book on cooperative game theory and these are not lecture notes

This text is a CRAN vignette only and it is supposed to give users of CoopGame a concise overview of the package. Users looking for an introduction to the fascinating field of cooperative game theory will be disappointed by this text. We strictly adhere to the CRAN policy that CRAN vignettes are not to be misused as lecture notes.

For excellent introductions to cooperative game theory we refer to the books by Peleg and Sudhölter [3], by Driessen [14], by Branzei, Dimitrov and Tijs [15], by Chakravarty, Mitra and Sarkar [16] and by Gilles [17].

Excellent introductions to cooperative game theory can also be found in the game theory books by Maschler, Solan and Zamir [18], by Peters [19] by Osborne and Rubinstein [20], the recent book by Narahari [21] and the classic textbook by Straffin [22].

We finally wish to acknowledge that beyond the aforementioned excellent books the development of CoopGame also benefitted greatly from two excellent German textbooks, i.e. the books by Wiese [23] and by Holler and Illing [24].

Zero-normalized and zero-one-normalized games

We call a cooperative game v zero-normalized if v_i = 0  for  i = 1, …, n, i.e. the values of all singleton coalitions are zero (see e.g. Peleg and Sudhölter [3], p. 11).

We can easily zero-normalize a given game vector v into a corresponding zero-normalized game vector w via w(C) = v(C) − ∑_i ∈ Cv_i for every coalition C ∈ 𝒫(N) (see e.g. Branzei, Dimitrov and Tijs [15], p. 9). In CoopGame we provide a corresponding function getZeroNormalizedGameVector:

library(CoopGame)
v <- c(30,40,50,90,100,110,180)
(w <- getZeroNormalizedGameVector(v))
## [1]  0  0  0 20 20 20 60

We call a cooperative game v zero-one-normalized if it is zero-normalized and for the grand coalition N there holds v(N) = 1. We can easily zero-one-normalize a given game vector v by dividing the zero-normalized game vector w by the value of the grand coalition v(N). In CoopGame we provide a corresponding function getZeroOneNormalizedGameVector:

library(CoopGame)
v <- c(30,40,50,90,100,110,180)
(w01 <- getZeroOneNormalizedGameVector(v))
## [1] 0.0000000 0.0000000 0.0000000 0.3333333 0.3333333
## [6] 0.3333333 1.0000000

For a detailed discussion on the importance of zero-one-normalized games and strategic equivalence we refer the reader to the book by Maschler, Solan and Zamir [18], p. 670.

Why bit matrices are helpful in cooperative game theory

We introduce the concept of a bit matrix as we find it extremely useful for working with cooperative games. Bit matrices unambigously map the values of coalitions to the players in that coalition. We again make use of the Maschler game for our example.

library(CoopGame)
(Maschler <- c(0,0,0,60,60,60,72))
## [1]  0  0  0 60 60 60 72
createBitMatrix(n=3,Maschler)
##            cVal
## [1,] 1 0 0    0
## [2,] 0 1 0    0
## [3,] 0 0 1    0
## [4,] 1 1 0   60
## [5,] 1 0 1   60
## [6,] 0 1 1   60
## [7,] 1 1 1   72

For a TU game with n players the function createBitMatrix creates a bit matrix with n + 1 columns and 2ⁿ − 1 rows which contains all possible coalitions of the players (apart from the null coalition). Each player is represented by a column which states if this player is participating in a coalition (value 1) or not (value 0). The last column (named cVal) contains the values of each coalition. Accordingly, each row of the bit matrix expresses a coalition as a subset of all players.

However, we need to admit that our usage of bit matrices in CoopGame also consumes plenty of storage space.

Marginal contributions

Let our TU game be specified by its characteristic function v. Then for every player j ∈ N and for every coalition C ∈ 𝒫(N) with j ∈ C we can define the so-called marginal contribution of player j to coalition C as v(C) − v(C ∖ {j}), see e.g. the book by Branzei, Dimitrov and Tijs [15], pp. 6, or the book by Peters [19], pp. 156. For some point- and set-valued solution concepts we need to know the marginal contributions of every player for every permutation of the set of players. Our function getMarginalContributions provides the user with a list of all combinations, i.e. permutations of the players, used and a corresponding matrix of marginal contributions:

library(CoopGame)
v <- c(3,4,5,9,10,11,18)
(MC <- getMarginalContributions(v))
## $A
## [1]  3  4  5  9 10 11 18
## 
## $combinations
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    1    3    2
## [3,]    2    1    3
## [4,]    2    3    1
## [5,]    3    1    2
## [6,]    3    2    1
## 
## $marginal_values
##      [,1] [,2] [,3]
## [1,]    3    6    9
## [2,]    3    8    7
## [3,]    5    4    9
## [4,]    7    4    7
## [5,]    5    8    5
## [6,]    7    6    5
# Look at all the permutations computed
MC$combinations
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    1    3    2
## [3,]    2    1    3
## [4,]    2    3    1
## [5,]    3    1    2
## [6,]    3    2    1
# Look at the matrix of marginal values 
# corresponding to these permutations
MC$marginal_values
##      [,1] [,2] [,3]
## [1,]    3    6    9
## [2,]    3    8    7
## [3,]    5    4    9
## [4,]    7    4    7
## [5,]    5    8    5
## [6,]    7    6    5

It appears worthwhile to interpret the second line of the marginal values we just computed

MC$marginal_values[2,]
## [1] 3 8 7

along the lines of the book by Peters [19], pp. 156. The above results corresponds to the permutation (1, 3, 2).

• Player 1 enters first and contributes 3.
• Player 3 enters second and contributes 11 − 3 = 8.
• Player 2 enters last and contributes 18 − 11 = 7.

The dual game

Let our TU game be specified by its characteristic function v. Then we can specify the so-called dual game v^* corresponding to v via v^*(C) = v(N) − v(N ∖ C) for every coalition C ∈ 𝒫(N) (see e.g. the book by Peleg and Sudhölter [3], p. 125, or the book by Branzei, Dimitrov and Tijs [15], p.7, for more details). The package CoopGame provides a function getDualGameVector:

library(CoopGame)
v <- c(3,4,5,9,10,11,18)
# Compute dual game vector
(vStar <- getDualGameVector(v))
## [1]  7  8  9 13 14 15 18

The utopia payoff vector

In cooperative game theory the so-called utopia payoff of player j is defined as M_j = v(N) − v(N ∖ {j})  for  j = 1, …, n, i.e. the utopia payoff M_j is the marginal contribution of player j to the grand coalition N (see e.g. the book by Branzei, Dimitrov and Tijs [15], p. 20). The package CoopGame provides a function getUtopiaPayoff for computing a vector of utopia payoffs for all players:

library(CoopGame)
v <- c(3,4,5,9,10,11,18)
# Compute utopia payoff vector for specified game v
(M <- getUtopiaPayoff(v))
## [1] 7 8 9

It is clear that player j can not ask for more than M_j in the grand coalition. The utopia payoff vector will lateron play a role in defining game properties as well as point- and set-valued solution concepts.

The minimal rights vector

The so-called remainder R(C, j) of player j in coalition C ∈ 𝒫(N) is the amount which remains for player j if the coalition C forms and the rest of the players in coalition C all obtain their individual utopia payoffs, i.e. R(C, j) = v(C) − ∑_{k ∈ C, k ≠ j}M_k. We can define a vector of minimal rights with components m_j = max_{C : j ∈ C}R(C, j),  for  j = 1, …, n, since player j has a justification to demand at least m_j in the grand coalition, see e.g. the book by Branzei, Dimitrov and Tijs [15], p. 20.
The package CoopGame provides a function getMinimalRights for computing a vector of minimal rights for every player:

library(CoopGame)
v <- c(2,3,4,8,9,10,13)
# Compute minimal rights vector for specified game v
(m <- getMinimalRights(v))
## [1] 4 5 6

The excess coefficients

The excess e(C, x) of a coalition C with respect to a vector x measures the gain or loss of the members of C in case they decide to abandon the grand coalition N in favour of their own coalition C, see e.g. the book by Driessen [14], p. 12:

e(C, x) = v(C) − ∑_j ∈ Cx_j = v(C) − x(C) In the above formula we use the shorthand notation x(C) = ∑_j ∈ Cx_j.

The package CoopGame provides a function getExcessCoefficients for computing a vector of excess coefficients for every coalition:

library(CoopGame)
A <-c(3,4,5,9,10,11,18)
x <-c(5,6,7)
# Compute vector of excess coefficients for specified game v
(ec <- getExcessCoefficients(A,x))
## [1] -2 -2 -2 -2 -2 -2  0

Note that the last component of a vector of excess coefficients is always 0 as long as x is efficient, i.e.  ∑_j ∈ Cx_j = v(N).

The concept of excesses is important in various solution concepts, like e.g. the nucleolus (see e.g. the original paper by Schmeidler [25] which appeared in 1969). Computing a vector of excesses comes in handy for checking the correctness of nucleolus or prenucleolus computations, see the article by Guajardo and Jörnsten [26].

The gap function

The gap function is the additive inverse of the vector of excesses with respect to the utopia payoff vector, see the book by Driessen [14], p. 57, for more details.

The package CoopGame provides a function getGapFunctionCoefficients for computing the vector of gap function coefficients for every coalition:

library(CoopGame)
A <-c(3,4,5,9,10,11,18)
# Compute vector of gap function coefficients for specified game v
(gap <- getGapFunctionCoefficients(A))
## [1] 4 4 4 6 6 6 6

The per capita excess coefficients

Per capita excess coefficients replace excess coefficients in the computation of the per capita nucleolus (see the original paper by Young [27]). The function getPerCapitaExcessCoefficients computes a vector of per capita excess coefficients for every coalition and a vector x, i.e. the excess coefficients are divided by the number of players in each coalition:

library(CoopGame)
A <-c(3,4,5,9,10,11,18)
x <-c(5,6,7)
# Compute vector of per capita excess coefficients for specified game v
(ecpc <- getPerCapitaExcessCoefficients(A,x))
## [1] -2 -2 -2 -1 -1 -1  0

Computing a vector of per capita excess coefficients comes in handy for checking the correctness of computations of the per capita nucleolus, see [26].

Propensities to disrupt

For a cooperative game v and a payoff vector x with $\sum_{j=1}^{n} x_{j} = v(N)$ player i’s propensity to disrupt (see e.g. the article by Littlechild and Vaidya [28]) is defined as
$$ d(i,x) = \frac{\sum_{j=1,j \neq i}^{n} x_{j} - v(N \backslash \{ i \})}{x_{i} - v_{i}} $$ The above expression quantifies the disruption caused if player i breaks away from the grand coalition. Within this expression the denominator stands for the loss incurred by player i for breaking away from the grand coalition, whereas the numerator stands for the joint loss of the rest of the players due to the breakup caused by player i. This concept is important in solution concepts like the Gately point (see e.g. the original paper by Gately [29] from 1974, the paper by Littlechild and Vaidya [28] or the recent article [30] by the authors) and the disruption nucleolus (see [28]).

The function getVectorOfPropensitiesToDisrupt computes a vector of propensities to disrupt for every coalition and a vector x:

library(CoopGame)
A <-c(3,4,5,9,10,11,18)
x <-c(5,6,7)
# Compute vector of propensities to disrupt for specified game v
(propVec <- getVectorOfPropensitiesToDisrupt(A,x))
## [1] 1 1 1 1 1 1 0

Note that the last component of a vector of propensities to disrupt is always set to 0. Computing a vector of coefficients of propensities to disrupt comes in handy for checking the correctness of computations of the disruption nucleolus, see [26].

The equal propensity to disrupt

CoopGame also provides a function for computing the so-called equal propensity to disrupt. This concept originates from the paper [29] by Gately for three-person games and was generalized to n-person games by Littlechild and Vaidya (see [28], p. 152). The goal is to find an imputation x with minimal propensity to disrupt. It can be shown that this minimal propensity to disrupt can be found by equating the propensity to disrupt over all players, i.e. d(i, x) = d^*  for  i = 1, …, n. As pointed out by Littlechild and Vaidya (see [28], p. 153) using the above approach one can easily find the following closed-form expression $$d^{*} = \frac{(n-1) v(N) - \sum_{j=1}^{n} v(N \backslash \{ j \})}{v(N) - \sum_{j=1}^{n} v_{j}} = \frac{\sum_{j=1}^{n} M_{j} - v(N)}{v(N) - \sum_{j=1}^{n} v_{j}}$$ for the equal propensity to disrupt d^* of a TU game with n players. Our recent paper [30] provides some insight and interpretation for the cases d^* = 0 and d^* < 0.

Minimum winning coalitions and real gaining coalitions

In a simple game v we call a player j critical for a coalition C if the departure of player j turns C from a winning coalition into a losing coalition, i.e. v(C) = 1 and v(C ∖ j) = 0. A minimum winning coalition in a simple game is a coalition where every member of the coalition is critical, see e.g.  the paper by Deegan and Packel [31], the paper by Holler [32] or the article by Bertini [33]. The function getMinimumWinningCoalitions identifies all minimal winning coalitions in a simple game v and returns a corresponding data frame. The function getCriticalCoalitionsOfPlayer identifies all coalitions for which a given player is critical.

library(CoopGame)
# Define a simple game
A <-c(0,0,0,1,1,0,1)
# Find the minimum winning coalitions
getMinimumWinningCoalitions(A)
##   V1 V2 V3 cVal
## 4  1  1  0    1
## 5  1  0  1    1
# Find the coalitions where player 2 is critical
getCriticalCoalitionsOfPlayer(2,A)
##   V1 V2 V3 cVal bmRow
## 4  1  1  0    1     4

The concept of minimum winning coalitions can be generalized to general cooperative games v via the concept of real gaining coalitions (see e.g. the original paper by Holler and Li [34] or the article by Bertini and Stach [35]). C is called a real gaining coalition (RGC) iff for any true subset T ⊂ C there holds v(C) − v(T) > 0. We provide a corresponding function getRealGainingCoalitions.

library(CoopGame)
A <-c(0,0,0,0.8,0.9,0,0.9)
# Find the real gaining coalitions
getRealGainingCoalitions(A)
##   V1 V2 V3 cVal
## 4  1  1  0  0.8
## 5  1  0  1  0.9

We provide corresponding functions getWinningCoalitions and getGainingCoalitions for computing the winning coalitions in simple games (see e.g. the original paper by Bertini, Gambarelli and Stach [36]) and the gaining coalitions in general TU games (see e.g. the original paper by Bertini and Stach [35] from 2015), respectively.

The unanimity coefficients

The unanimity coefficients represent a cooperative game in an alternative basis, the so-called unanimity basis. They were introduced in the seminal paper by Shapley [37] and are also called Harsanyi dividends (see also the books by Peleg and Sudhölter [3], p. 153, or by Gilles [17], pp. 15–17, for more details).

Our package provides a function getUnanimityCoefficients.

library(CoopGame)
# The Maschler game
Maschler <-c(0,0,0,60,60,60,72)
# Find the unanimity coefficients for the Maschler game
(unCoeff <- getUnanimityCoefficients(Maschler))
## [1]    0    0    0   60   60   60 -108

The k-cover

In [14], p. 173, Driessen defines an associated cover v_k that majorizes the original game v for a given integer k. $$ v_{k}(C) = \left\{ \begin{array}{rl} v(C) & \quad \text{if } \quad \vert C \vert < k,\\ v(N) - \sum_{j \in N \backslash C} M_{j} & \quad \text{else,} \end{array} \right. $$ with M denoting the utopia payoff vector. In case the gap function g of original game v satisfies 0 ≤ g(N) ≤ g(C) for all coalitions C ⊆ N with k or more elements, then v_k is called the k-cover of the game v. In CoopGame we provide a function getkCover computing v_k according to the previous formula. In case v does satisfy the above condition, getkCover will return NULL.

library(CoopGame)
# Example from book by T. Driessen, p. 75
A=c(0,0,0,9,9,15,18)
# Compute 1-cover of this 1-convex game
(A1 <- getkCover(A,k=1))
## [1]  0  6  6  9  9 15 18

Package maintainer

This is supposed to be the second R package on CRAN maintained by the first author after the publication of the significantly smaller package EvolutionaryGames [42] in November 2017. Please feel free to email questions regarding CoopGame to [email protected].

No formal maximum number of players

CoopGame does not enforce a maximum number of players. Still, realistically for most concepts provided in CoopGame users should limit their studies to at most 20 players if they expect quick answers on modern computers. The authors have employed CoopGame for up to n = 24 players, but R normally ran out of storage for n > 24.

Minimum: 2 Players

In CoopGame a minimum of two players is needed in order to define a TU game.

No null games allowed

In case the user specifies a null game, i.e. a trivial TU game with each coalition generating zero value, CoopGame will stop with an error message.

A problem from the Babylonian Talmud

This important example from the Babylonian Talmud deals with a man who married three women. In their marriage contracts the three women were promised the sums of 100, 200 and 300 units of money after the death of their husband. The man dies and his estate amounts to less than 600 units. In the following we will not study this important example in more detail, but simply focus on an estate E worth 300 units of money.

CoopGame allows us to create the corresponding bankruptcy game.

library(CoopGame)
bankruptcyGame(n=3,d=c(100,200,300),E=300)
## $n
## [1] 3
##
## $d
## [1] 100 200 300
##
## $E
## [1] 300
##
## $v
## [1]   0   0   0   0 100 200 300

As stated we provide the user with various ways to extract the corresponding game vector. One is to use bankruptcyGameVector, another to access the element $v from the bankruptcyGame object.

library(CoopGame)
# First approach
bankruptcyGameVector(n=3,d=c(100,200,300),E=300)
## [1]   0   0   0   0 100 200 300
#
# Alternative approach
bankruptcyGame(n=3,d=c(100,200,300),E=300)$v
## [1]   0   0   0   0 100 200 300

In addition, the user can also compute the value of any individual coalition using the function bankruptcyGameValue. For example, let us extract the value of the coalition of the second and third widow:

library(CoopGame)
bankruptcyGameValue(S=c(2,3),d=c(100,200,300),E=300)
## [1] 200

We will briefly revisit bankruptcy games in section 5.3.2 of this vignette. For more information on bankruptcy games and the contested-garment principle (as well as it physical interpretation via hydraulic rationing) we refer the reader to the book by Gura and Maschler [43], the paper by Aumann and Maschler [44] from 1985, the paper by Aumann [45] from 2002 and the original paper by O’Neill [46] from 1982.

The TVA problem

The TVA (Tennessee Valley Authority) problem is a classic example of a cost-sharing problem. We refer to the original article by Ransmeier [52] on the Tennessee Valley Authority from 1942 and the book by Driessen [14], pp. 1–3, for more details and the history of this problem.

The following code example shows how to specify the TVA problem in CoopGame:

library(CoopGame)
TVACosts=c(163520,140826,250096,301607,378821,367370,412584)
(tvaCostGame <- costSharingGame(n=3, TVACosts))
## $n
## [1] 3
##
## $Costs
## [1] 163520 140826 250096 301607 378821 367370 412584
##
## $v
## [1] 0 0 0 2739 34795 23552 141858
# 
# Alternatively, generate and output only the corresponding game vector
(v <- costSharingGameVector(n=3, TVACosts))
## [1] 0 0 0 2739 34795 23552 141858

We will revisit the TVA problem in section 5.3.3 of this vignette.

Nonnegative games

We call a game vector A nonnegative if all of its entries are nonnegative. This game property can be checked via the function isNonnegativeGame. We provide certain solution concepts for nonnegative games only.

Essential games

We call a TU game v essential, if the value of the grand coalition v(N) is greater than the sum of the values of the singleton coalitions v({i}), i.e.

$$v(N) > \sum_{i=1}^{n} v(\{i\}).$$

Our definition follows the books by Chakravarty, Mitra and Sarkar [16], p. 23, and by Gilles [17], p. 18. We find it very convenient that according to this definition the imputation set of an essential game is nonempty and consists of more than one point. This game property can be checked via the function isEssentialGame.

Degenerate games

We call a TU game v degenerate (or inessential), if the value of the grand coalition v(N) equals the sum of the values of the singleton coalitions v({i}), i.e.

$$v(N) = \sum_{i=1}^{n} v(\{i\}).$$ We find it very convenient that according to this definition the imputation set of a degenerate game consists of exactly one point (specified by the singleton coalitions). This game property can be checked via the function isDegenerateGame.

Monotonic games

According to the book by Peleg and Sudhölter [3], p. 12, we call a TU game v monotonic if

S ⊆ T ⊆ N ⇒ v(S) ≤ v(T). This game property can be checked via the function isMonotonicGame.

Simple games

Along the lines of the book by Peleg and Sudhölter [3], p. 16, we call a TU game v simple if v is monotonic and the values of all coalitions are 0 or 1. This game property can be checked via the function isSimpleGame.

Symmetric games

Following the book by Peleg and Sudhölter [3], p. 12, we call a TU game v symmetric if the values of all coalitions containing the same number of players are identical, i.e.

|S| = |T| ⇒ v(S) = v(T) for all coalitions S, T ⊆ N. This game property can be checked via the function isSymmetricGame.

Constant-sum games

In a constant-sum game v for any coalition S the sums of v(S) and its complement v(N ∖ S) equal v(N), i.e.  v(S) + v(N ∖ S) = v(N) for all S ⊆ N, see e.g.  the book by Peleg and Sudhölter [3], p. 11. This game property can be checked via the function isConstantSumGame.

Weakly constant-sum games

We call a TU game v with n players weakly constant-sum as long as the constant-sum condition holds for coalitions of sizes 1 and n − 1, i.e. v({i}) + v(N ∖ {i}) = v(N) for all players i = 1, …, n. In other words: For weakly constant-sum games the vector of singleton coalitions and the utopia payoff vector coincide. This game property comes in handy when checking uniqueness conditions for the Gately point, see the paper [30] by the authors of this vignette. Also note that any constant-sum game is weakly constant-sum, but not vice versa. This game property can be checked via the function isWeaklyConstantSumGame.

Superadditive games

We call a TU game v superadditive if

v(S ∪ T) ≥ v(S) + v(T) for all coalitions S, T ⊆ N with S ∩ T = ∅, see e.g. the book by Peleg and Sudhölter [3], p. 10, or the book by Maschler, Solan and Zamir [18], p. 671. The idea of superadditivity is that disjoint groups of players are never punished for cooperating. This game property can be checked via the function isSuperadditiveGame.

Additive games

We call a TU game v additive if

v(S ∪ T) = v(S) + v(T) for all coalitions S, T ⊆ N with S ∩ T = ∅, see e.g. the book by Peleg and Sudhölter [3], p. 11, or the book by Maschler, Solan and Zamir [18], p. 792. Note that an additive game is always superadditive, constant-sum, weakly constant-sum and degenerate whereas none of these four game properties guarantee additivity in return. This game property can be checked via the function isAdditiveGame.

Weakly superadditive games

We call a TU game v with n players weakly superadditive if

v(S ∪ {i}) ≥ v(S) + v({i}) for all coalitions S ⊆ N and all players i = 1, …, n with i ∉ S, see e.g. the book by Peleg and Sudhölter [3], p. 10. Note that weak superadditivity is equivalent to 0-monotonicity, i.e. the zero-normalization of the game is monotonic, see e.g. Maschler, Solan and Zamir [18], p. 789, or Peleg and Sudhölter [3], p. 12. This game property can be checked via the function isWeaklySuperadditiveGame.

Quasi-balanced games

Given a TU game v with n players let m denote the minimal rights vector and M the utopia payoff vector. We call the TU game v quasi-balanced if m(i) ≤ M(i) for all i = 1, …, n and $$ \sum_{i=1}^{n} m_{i} \leq v(N) \leq \sum_{i=1}^{n} M_{i}, $$ see e.g. the book by Branzei, Dimitrov and Tijs [15], p. 31. Quasi-balanced games can equivalently be characterized as the TU games with a non-empty core cover. Note also that the τ-value, an important solution concept, is only defined for quasi-balanced games, see e.g. the original paper by Tijs [55] from 1981. This game property can be checked via the function isQuasiBalancedGame.

Balanced games

A TU game v is called balanced if and only if the core of v is non-empty. For the sake of brevity we do not go into any details of the balancedness condition and the Bondareva-Shapley theorem in this vignette. Instead, we only refer to the original papers by Bondareva [56] and by Shapley [57] as well as to section 3.1 of the book by Peleg and Sudhölter [3] for further details. This game property can be checked via the function isBalancedGame.

Convex games

We call a TU game v convex if

v(S ∪ T) + v(S ∩ T) ≥ v(S) + v(T) for all S, T ⊆ N, see e.g. the book by Peleg and Sudhölter [3], p. 10, for more details. Convex games are always balanced, i.e. the core of a convex game is never empty, and they arise in various important application areas of cooperative game theory. This game property can be checked via the function isConvexGame.

Semiconvex games

A TU game v with n players is called semiconvex if for its gap function g there holds 0 ≤ g(i) ≤ g(S) for all players i = 1, …, n and all coalitions S ⊆ N with i ∈ S. Note that convex games are always semiconvex but not vice versa. We refer to the book by Driessen [14], p. 76, or the original paper by Driessen and Tijs [58] for more details. This game property can be checked via the function isSemiConvexGame.

1-convex games

A TU game v with n players is called 1-convex if for its gap function g there holds 0 ≤ g(N) ≤ g(S) for all coalitions S ⊆ N with S ≠ ∅. Note that the 1-cover v₁ of a 1-convex game v will always be convex. We refer to the book by Driessen [14], p. 73, for more details. This game property can be checked via the function is1ConvexGame.

k-convex games

k-convexity can be regarded as a generalization of 1-convexity. A TU game v with n players is called k-convex if and only if its k-cover (see 1.2.14 of this vignette) exists and is convex. We refer to section 7.1 of the book by Driessen [14] for more details on k-convex games. This game property can be checked via the function iskConvexGame by specifying both a game vector v and an integer k. We end this chapter with a small example inspired by the book by Driessen [14], p. 175:

# The following game is 2-convex
library(CoopGame)
alpha = 0.48
v=c(0,0,0,alpha,alpha,0,1)
iskConvexGame(v,2)
## [1] TRUE
# The following game is not 2-convex
library(CoopGame)
alpha = 0.52
v=c(0,0,0,alpha,alpha,0,1)
iskConvexGame(v,2)
## [1] FALSE

The imputation set

Given a TU game v with n players we call a vector x ∈ ℝⁿ efficient if $$ \sum_{i=1}^{n} x_{i} = v(N).$$ Frequently the set of efficient vectors is also called the set of preimputations, see e.g. the book by Peleg and Sudhölter [3], p. 20. In case x ∈ ℝⁿ is also individually rational (from the point of view of every player i), i.e. v({i}) ≤ x_i for all i = 1, …, n, then we call x an imputation. Formally, we can specify the so-called imputation set I(v) as $$I(v)= \{ x \in \mathbb{R}^{n} \vert \sum_{i=1}^{n} x_{i} = v(N) \land v(\{i\}) \leq x_{i} \}$$ According to our game property definitions from section 3 the imputation set is empty unless v is either essential or degenerate. In the latter case I(v) consists of a single point. For further details on imputations see e.g. the book by Peleg and Sudhölter [3], p.20, the book by Maschler, Solan and Zamir [18], p. 674–677, or the book by Osborne and Rubinstein [20], p. 278.

In order to computate the vertices of the imputation set we provide the function imputationsetVertices. The rows of the matrix returned are the vertices of the imputation set. In case the imputation set is empty an empty matrix is returned. In order to check whether an allocation x is an imputation there is the function belongsToImputationset.

library(CoopGame)
v <-c(0,0,0,1,1,0,1)
imputationsetVertices(v)
##      [,1] [,2] [,3]
## [1,]    0    0    1
## [2,]    0    1    0
## [3,]    1    0    0
belongsToImputationset(c(0.7,0.3,0),v)
## [1] TRUE

The core

Apart from the set of imputations the most prominent set solution concept is the core. The concept was established in the Ph.D. thesis by Gillies [59] from 1953 and a seminal article by Aumann [60] from 1961. The idea of the core is to consider only those imputations x which are also coalitionally rational, i.e. v(S) ≤ ∑_i ∈ Sx_i for all nonempty coalitions S ⊆ N. More information on the core can e.g. be found in
the book by Maschler, Solan and Zamir [18], pp. 686–747, the book by Osborne and Rubinstein [20], pp. 257–275, or the book by Peleg and Sudhölter [3], pp. 27–49.

The function coreVertices lists the vertices of the core as rows of a matrix. In case the core is empty an empty matrix is returned. The function belongsToCore checks whether an allocation x is contained in the core or not.

library(CoopGame)
v <-c(0,0,0,1,1,0,3)
coreVertices(v)
##      [,1] [,2] [,3]
## [1,]    3    0    0
## [2,]    1    0    2
## [3,]    0    1    2
## [4,]    0    2    1
## [5,]    1    2    0
belongsToCore(c(1.7,1.3,0),v)
## [1] TRUE

The core cover

The core cover was originally suggested by Tijs and Lipperts in [61] as a core catcher. Given a TU game v with n players let m denote the minimal rights vector and M the utopia payoff vector. The core cover of the game v consists of all imputations x satisfying m(i) ≤ x_i ≤ M(i) for all i = 1, …, n. One can show that the core is always a subset of the core cover, see e.g. the book by Branzei, Dimitrov and Tijs [15], p. 21, or the book by Chakravarty, Mitra and Sarkar [16], pp. 45–46, for more details. Also note that the core cover is nonempty iff the game v is quasi-balanced (see chapter 3 of this vignette).

We provide functions coreCoreVertices listing the vertices of the core cover as rows of a matrix and belongsToCoreCover for checking whether an allocation x is contained in the core cover or not.

The reasonable set

The reasonable set was originally suggested by Milnor in [62] as another core catcher. The reasonable set of a TU game v consists of all imputations x satisfying v({i}) ≤ x_i ≤ max_{i : i ∈ S}(v(S) − v(S ∖ {i}) for all i = 1, …, n. One can show that the core cover is always a subset of the reasonable set.
We refer to the book by Branzei, Dimitrov and Tijs [15], p. 21, the book by Chakravarty, Mitra and Sarkar [16], pp. 43–46, and the article by Gerard-Varet and Zamir [63] for more details concerning the reasonable set.

We provide functions reasonableSetVertices listing the vertices of the reasonable set as rows of a matrix and belongsToReasonableSet for checking whether an allocation x is contained in the reasonable set or not.

The Weber Set

The Weber Set was originally suggested by Weber in [64] as another core catcher. The Weber Set is the convex hull of the marginal vectors. Thus one can easily see that the Weber Set is contained in the imputation set for superadditive games. We provide the Weber Set only for game vectors v which are both nonnegative and monotonic. One can show that the core is always a subset of the Weber Set. We refer to the book by Peters [19], chapter 18, for further details regarding the Weber Set.

We provide functions weberSetVertices listing the vertices of the Weber Set as rows of a matrix and belongsToWeberSet for checking whether an allocation x is contained in the Weber Set or not.

Available point solution concepts for general cooperative games

The following 19 point solution concepts for general cooperative games are available in CoopGame:

• the centroid of the core provided by the function centroidCore
• the centroid of the core cover provided by the function centroidCoreCover
• the centroid of the imputation set provided by the function centroidImputationSet
• the centroid of the reasonable set provided by the function centroidReasonableSet
• the centroid of the Weber set provided by the function centroidWeberSet
• the disruption nucleolus (see the article by Littlechild and Vaidya [28]) provided by the function disruptionNucleolus
• the Gately point (see the original paper by Gately [29], our recent article [30] for implementation details, the article by Littlechild and Vaidya [28] or the book by Narahari [21], pp. 455–456) provided by the function gatelyValue
• the modiclus (aka modified nucleolus, see the one of the two original papers by Sudhölter [70], [71] or the book by Peleg and Sudhölter [3], pp. 147–182) provided by the function modiclus
• the normalized Banzhaf value (see e.g. one of the articles by Gambarelli [72] or by Stach [73]) provided by the function normalizedBanzhafValue
• the nucleolus (see the papers by Schmeidler [25], by Kohlberg [74], by Kopelowitz [75], by Megiddo [76] or the book by Peleg and Sudhölter [3], pp. 82–86) provided by the function nucleolus
• the per capita nucleolus (see the original paper by Young [27]) provided by the function perCapitaNucleolus
• the prenucleolus (see chapter 6 of the book by Peleg and Sudhölter [3]) provided by the function prenucleolus
• the proportional nucleolus (see the original paper by Young, Okada and Hashimoto [77]) provided by the function proportionalNucleolus
• the (normalized) Public Good value (see the original paper by Holler and Li [34]) provided by the function publicGoodValue
• the (normalized) Public Help value Chi (see the original paper by Bertini and Stach [35]) provided by the function publicHelpChiValue
• the (normalized) Public Help value Theta (see the original paper by Bertini and Stach [35]) provided by the function publicHelpValue
• the Shapley value (see the original paper by Shapley [37], the article by Bertini [78] or chapter 18 of the book by Maschler, Solan and Zamir [18]) provided by the function shapleyValue
• the simplified modiclus (see the original article by Tarashnina [79]) provided by the function simplifiedModiclus
• the tau-value (aka Tijs value, see the original paper by Tijs [55], the article by Stach [80] or the book by Branzei, Dimitrov and Tijs [15], p. 31) provided by the function tauValue

Note that the above 19 solution concepts are all efficient, i.e. the sum of the components of the solution equals the value of the grand coalition v(N).

In addition, CoopGame also provides five solution concepts for general cooperative games which are not efficient:

• the absolute Public Good value (see the original paper by Holler and Li [34]) provided by the function absolutePublicGoodValue
• the absolute Public Help value Chi (see the original paper by Bertini and Stach [35]) provided by the function absolutePublicHelpChiValue
• the absolute Public Help value Theta (see the original paper by Bertini and Stach [35]) provided by the function absolutePublicHelpValue
• the Banzhaf value (see the book by Peters [19], pp. 367–370) provided by the function banzhafValue
• the raw Banzhaf value (see the book by Chakravarty, Mitra and Sarkar [16], pp. 118–119) provided by the function rawBanzhafValue

Available power indices for simple games

The following seven power indices for simple games are available in CoopGame:

• the Deegan-Packel index (see the original article by Deegan and Packel [31] or the German book by Holler and Illing [24], pp. 323–324) provided by the function deeganPackelIndex
• the Johnston index (see the original paper by Johnston [81] or the book by Chakravarty, Mitra and Sarkar [16], p. 124) provided by the function johnstonIndex
• the normalized Banzhaf value (see the article by Stach [82] or the book by Chakravarty, Mitra and Sarkar [16], pp. 118–119) provided by the function normalizedBanzhafIndex
• the Public Good index (see the original papers by Holler [32], by Holler and Packel
  [83] or the later article by Holler [84]) provided by the function publicGoodIndex
• the Public Help index Chi (see the original papers by Bertini and Stach [35] and by Stach [85]) provided by the function publicHelpChiIndex
• the Public Help index Theta (see the original paper by Bertini, Gambarelli and Stach [36] or one of the later articles by Bertini and Stach [35] or Stach [85]) provided by the function publicHelpIndex
• the Shapley-Shubik index (see the original paper by Shapley and Shubik [86], the article by Stach [87] from 2011 or the book by Peters [19], pp. 156–159) provided by the function shapleyShubikIndex

Note that the above seven power indices are all efficient, i.e. the sum of the components of the solution equals 1.

In addition, CoopGame also provides nine power indices for simple games which are not efficient:

• the Barua Chakravarty Sarkar index (see the original paper by Barua, Chakravarty and Sarkar [88] or the book by Chakravarty, Mitra and Sarkar [16], pp. 120–123) provided by the function baruaChakravartySarkarIndex
• the Coleman Power index of a Collectivity to Act (see the original article by Coleman [89], the paper by Stach [90] or the survey article by de Keijzer [91], p. 18) provided by the function colemanCollectivityPowerIndex
• the Coleman Initiative Power index (see the original article by Coleman [89], the paper by Stach [90], the survey article by de Keijzer [91], p. 18, or the book by Chakravarty, Mitra and Sarkar [16], pp. 120–123) provided by the function colemanInitiativePowerIndex
• the Coleman Preventive Power index (see the original article by Coleman [89], the paper by Stach [90], the survey article by de Keijzer [91], p. 18, or the book by Chakravarty, Mitra and Sarkar [16], pp. 120–123) provided by the function colemanPreventivePowerIndex
• the König-Bräuninger index (see one of the original articles by König and Bräuninger [92] and by Nevison, Zicht and Schöpke [93] or the later paper by Bertini and Stach [35]) provided by the function koenigBraeuningerIndex
• the Nevison index (see the original paper by Nevison [94]) provided by the function nevisonIndex
• the non-normalized Banzhaf index (see the paper by Stach [82] from 2011 or the book by Chakravarty, Mitra and Sarkar [16], pp. 118–119) provided by the function nonNormalizedBanzhafIndex
• the Rae index (see the original article by Rae [95] or the book by Chakravarty, Mitra and Sarkar [16], p. 119–120) provided by the function raeIndex
• the raw Banzhaf index (see the book by Chakravarty, Mitra and Sarkar [16], p. 118–119) provided by the function rawBanzhafIndex

In the context of power indices this vignette is not the place to discuss any details concerning the concepts of I-Power and P-Power. Hence we simply wish to refer to the original paper by Felsenthal, Machover and Zwicker [96] and the book by Felsenthal and Machover [97] for details. The two small overview articles [98] and [99] by Felsenthal and Machover from 2011 may serve as a very first introduction to these concepts.

The Shapley value for the inheritance problem due to Ibn Ezra (1146)

Our first example is taken from a paper by Robert Aumann from 2010 on “Some non-superadditive games, and their Shapley values, in the Talmud” [103]. As the first in a series of problems, Aumann investigates the inheritance problem due to Ibn Ezra (1146) (see [104]), i.e. an inconsistent will, in that paper.

A man with four sons dies. He leaves an estate worth 120 units of money. He bequeathes 120 units of money to his first son, 60 units of money to his second son, 40 units of money to his third sum and 30 units of money to his youngest son. In order to analyze the problem of how to divide the estate, let us first introduce the estate E = 120 and the four claims c₁ = 120, c₂ = 60, c₃ = 40 and c₄ = 30. We can now define a TU game v as follows:

$$ v = \left\{ \begin{array}{rl} \min(E, \max_{i \in S}c_{i}) & \text{if } \vert S \vert < 4,\\ E & \text{else,} \end{array} \right. $$

library(CoopGame)
Aumann2010Example<-c(120,60,40,30,120,120,120,60,60,40,120,120,120,60,120)
shapleyValue(Aumann2010Example)
## [1] 80.83333 20.83333 10.83333  7.50000

We confirm that the Shapley value of v coincides with Ibn Ezra’s solution: The first son get $80 \frac{5}{6}$, the second son $20 \frac{5}{6}$, the third son $10 \frac{5}{6}$ and the youngest son $7 \frac{1}{2}$ units of money. For more details, we refer to the article by Aumann [103] and the 1982 paper by O’Neill [46].

The nucleolus for bankruptcy problems from the Babylonian Talmud

Our second set of examples revisits bankruptcy problems from the Babylonian Talmud from section 2.1, see the papers by Aumann and Maschler [44] and Aumann [45]. We solve the problem of the three widows from the Babylonian Talmud for E = 100, 200, and 300 using our function nucleolus:

library(CoopGame)
v100 = bankruptcyGameVector(n=3,d=c(100,200,300),E=100)
nucleolus(v100)
## [1] 33.33333 33.33333 33.33333
v200 = bankruptcyGameVector(n=3,d=c(100,200,300),E=200)
nucleolus(v200)
## [1] 50 75 75
v300 = bankruptcyGameVector(n=3,d=c(100,200,300),E=300)
nucleolus(v300)
## [1]  50 100 150

We confirm that the nucleolus coincides with the solutions from the Babylonian Talmud in all three cases. For more details, e.g. on the principle of equal division of the contested sum we refer to the article by Aumann and Maschler [44] and chapter 4 of the book by Gura and Maschler [43].

Solving the TVA problem

We investigate the classic TVA problem introduced in section 2 of this vignette (see the original article by Ransmeier [52] on the Tennessee Valley Authority from 1942 for the history of the problem and the article by Straffin and Heaney [51] and the book by Driessen [14], p. 98, for computational results).

library(CoopGame)
TVACosts=c(163520,140826,250096,301607,378821,367370,412584)
(v <- costSharingGameVector(n=3, TVACosts))
## [1]      0      0      0   2739  34795  23552 141858
TVACosts[1:3] - gatelyValue(v)
## [1] 117475.54  99157.29 195951.16
TVACosts[1:3] - shapleyValue(v)
## [1] 117829.0 100756.5 193998.5
TVACosts[1:3] - nucleolus(v)
## [1] 116234  93540 202810
TVACosts[1:3] - tauValue(v)
## [1] 117475.54  99157.29 195951.16

We confirm the results from the literature. Note that for the TVA problem the results for the tau-value and the Gately point need to coincide as the game is semiconvex, see [58].

Examples on the failure of the donation property

Bertini, Freixas, Gambarelli and Stach point out in their article [105] that the normalized Banzhaf index, the Deegan-Packel index, the Public Good index, the Johnston index and the Public Help index Theta lack the so-called donation property. We revisit the examples from table 1 on page 9 of that paper and along the way point out that the donation property also does not hold for the Public Help index Chi. We start with the 5-player game from the article by Bertini, Freixas, Gambarelli and Stach [105]:

library(CoopGame)
v<-weightedVotingGameVector(n=5, w=c(6,4,1,1,1), q=9)
normalizedBanzhafIndex(v)
## [1] 0.47368421 0.36842105 0.05263158 0.05263158 0.05263158
deeganPackelIndex(v)
## [1] 0.375 0.250 0.125 0.125 0.125
publicGoodIndex(v)
## [1] 0.3333333 0.1666667 0.1666667 0.1666667 0.1666667
johnstonIndex(v)
## [1] 0.52777778 0.38888889 0.02777778 0.02777778 0.02777778
publicHelpIndex(v)
## [1] 0.28125 0.25000 0.15625 0.15625 0.15625
publicHelpChiIndex(v)
## [1] 0.3234568 0.3003086 0.1254115 0.1254115 0.1254115
#
# Now player 1 donates one vote to player 2
v<-weightedVotingGameVector(n=5, w=c(5,5,1,1,1), q=9)
normalizedBanzhafIndex(v)
## [1] 0.5 0.5 0.0 0.0 0.0
deeganPackelIndex(v)
## [1] 0.5 0.5 0.0 0.0 0.0
publicGoodIndex(v)
## [1] 0.5 0.5 0.0 0.0 0.0
johnstonIndex(v)
## [1] 0.5 0.5 0.0 0.0 0.0
publicHelpIndex(v)
## [1] 0.2857143 0.2857143 0.1428571 0.1428571 0.1428571
publicHelpChiIndex(v)
## [1] 0.3309524 0.3309524 0.1126984 0.1126984 0.1126984

Now for the example with 10 players from the article by Bertini, Freixas, Gambarelli and Stach [105]:

library(CoopGame)
v<-weightedVotingGameVector(n=10, w=c(9,8,7,0,1,1,1,1,1,1), q=23)
normalizedBanzhafIndex(v)
## [1] 0.326633166 0.326633166 0.316582915 0.000000000 0.005025126
## [6] 0.005025126 0.005025126 0.005025126 0.005025126 0.005025126
deeganPackelIndex(v)
## [1] 0.2291667 0.2291667 0.1666667 0.0000000 0.0625000 0.0625000
## [7] 0.0625000 0.0625000 0.0625000 0.0625000
publicGoodIndex(v)
## [1] 0.18181818 0.18181818 0.09090909 0.00000000 0.09090909
## [6] 0.09090909 0.09090909 0.09090909 0.09090909 0.09090909
johnstonIndex(v)
## [1] 0.332692308 0.332692308 0.323076923 0.000000000 0.001923077
## [6] 0.001923077 0.001923077 0.001923077 0.001923077 0.001923077
publicHelpIndex(v)
## [1] 0.15312132 0.15312132 0.15076561 0.07656066 0.07773852
## [6] 0.07773852 0.07773852 0.07773852 0.07773852 0.07773852
publicHelpChiIndex(v)
## [1] 0.16914603 0.16914603 0.16780487 0.06991541 0.07066461
## [6] 0.07066461 0.07066461 0.07066461 0.07066461 0.07066461
#
# Now player 1 donates one vote to player 4
v<-weightedVotingGameVector(n=10, w=c(8,8,7,1,1,1,1,1,1,1), q=23)
normalizedBanzhafIndex(v)
## [1] 0.32908163 0.32908163 0.32397959 0.00255102 0.00255102
## [6] 0.00255102 0.00255102 0.00255102 0.00255102 0.00255102
deeganPackelIndex(v)
## [1] 0.22222222 0.22222222 0.16666667 0.05555556 0.05555556
## [6] 0.05555556 0.05555556 0.05555556 0.05555556 0.05555556
publicGoodIndex(v)
## [1] 0.16666667 0.16666667 0.08333333 0.08333333 0.08333333
## [6] 0.08333333 0.08333333 0.08333333 0.08333333 0.08333333
johnstonIndex(v)
## [1] 0.3329026701 0.3329026701 0.3281653747 0.0008613264 0.0008613264
## [6] 0.0008613264 0.0008613264 0.0008613264 0.0008613264 0.0008613264
publicHelpIndex(v)
## [1] 0.15338882 0.15338882 0.15219976 0.07728894 0.07728894 0.07728894
## [7] 0.07728894 0.07728894 0.07728894 0.07728894
publicHelpChiIndex(v)
## [1] 0.16941222 0.16941222 0.16881669 0.07033698 0.07033698 0.07033698
## [7] 0.07033698 0.07033698 0.07033698 0.07033698

Voting power in the European Parliament (2004 – 2009)

The article by Aguirre and Quintas [106] provides an example of voting power in the European Parliament as of the election of June 2004. In the following analysis the seats are allocated to eight supranational political groups. There were 732 members in that parliament, i.e. a majority of 367 votes was needed in order to pass a law. According to Aguirre and Quintas [106] the European Democrats (EPP-ED) had 277 members, the Party of European Socialists (PES) 198 members, the European Liberal Demcrat and Reform Party (ELDR) 68 members, the European Greens / European Free Alliance (Greens/EFA) 40 members, the European United Left / Nordic Green Left (EUL/NGL) 39 members, the Union for a Europe of Nations (UEN) 27 members, Europe of Democracies and Diversities (EDD) 15 members, whereas the rest of 68 parliamentary members were not part of any of the seven aforementioned supranational political groups.

In the following we confirm the results from table 3 of the paper by Aguirre and Quintas [106]:

library(CoopGame)
v<-weightedVotingGameVector(n=8, w=c(277,198,68,40,39,27,15,68), q=367)
shapleyShubikIndex(v)
## [1] 0.426190476 0.178571429 0.111904762 0.059523810 0.059523810
## [6] 0.045238095 0.007142857 0.111904762
normalizedBanzhafIndex(v)
## [1] 0.427272727 0.154545455 0.118181818 0.063636364 0.063636364
## [6] 0.045454545 0.009090909 0.118181818
johnstonIndex(v)
## [1] 0.621621622 0.129129129 0.077477477 0.033483483 0.033483483
## [6] 0.023273273 0.004054054 0.077477477
deeganPackelIndex(v)
## [1] 0.2222222 0.1066667 0.1488889 0.1211111 0.1211111 0.1011111
## [7] 0.0300000 0.1488889
publicGoodIndex(v)
## [1] 0.18518519 0.11111111 0.14814815 0.12962963 0.12962963 0.11111111
## [7] 0.03703704 0.14814815