Next Article in Journal
Emotion at Stake—The Role of Stake Size and Emotions in a Power-to-Take Game Experiment in China with a Comparison to Europe
Next Article in Special Issue
Structural Holes in Social Networks with Exogenous Cliques
Previous Article in Journal
On Information Aggregation and Interim Efficiency in Networks

Games 2017, 8(1), 16; https://doi.org/10.3390/g8010016

Article
The Integer Nucleolus of Directed Simple Games: A Characterization and an Algorithm
Department of Economics, University of Fribourg, 1700 Fribourg, Switzerland
Academic Editors: Luca Dall’Asta and Paolo Pin
Received: 16 November 2016 / Accepted: 7 February 2017 / Published: 28 February 2017

Abstract

:
We study the class of directed simple games, assuming that only integer solutions are admitted; i.e., the players share a resource that comes in discrete units. We show that the integer nucleolus—if nonempty—of such a game is composed of the images of a particular payoff vector under all symmetries of the game. This payoff vector belongs to the set of integer imputations that weakly preserve the desirability relation between the players. We propose an algorithm for finding the integer nucleolus of any directed simple game with a nonempty integer imputation set. The algorithm supports the parallel execution of multiple threads in a computer application. We also consider the integer prenucleolus and the class of directed generalized simple games.
Keywords:
integer nucleolus; integer prenucleolus; desirability relation; simple games
JEL Classification:
C63; C71; D72

1. Introduction

The nucleolus is a popular solution concept for cooperative transferable-utility (TU) games because it is a set of game outcomes that are in a sense most acceptable “...as a compromise between the players” (Schmeidler [1], p. 1163). A cooperative TU game is a pair ( N , v ) = : Γ , henceforth called a game, with a finite set N : = { 1 , , n } of n ( 2 ) players and a coalition function v : 2 N R , v ( ) = 0 . For every payoff vector x R n and coalition S N , let x ( S ) : = i S x i . If S N , S , we denote the excess of coalition S at x by e ( S , x ) : = v ( S ) x ( S ) . This way, we can associate with each x R n the vector θ ( x ) of all 2 n 2 excesses e ( S , x ) , arranged in nonincreasing magnitude. The nucleolus of Γ with respect to a set X of feasible payoff vectors is the set N ( Γ , X ) : = x X : θ ( x ) l e x θ ( z ) for   all z X of payoff vectors which minimize θ ( x ) lexicographically over X (cf. Schmeidler [1]), as if they were the outcome of an egalitarian arbitration among player coalitions (cf. Maschler [2], p. 611). Our choice for X will be the integer imputation set I ( Γ ) : = x Z n : x ( N ) = v ( N ) , x i v ( { i } ) for   all i N , under the condition that v ( N ) Z > 0 . Thus, we assume that the players face an integer resource allocation problem in that v ( N ) comes in discrete units that cannot be broken apart. We call ν ( Γ ) : = N Γ , I ( Γ ) the integer nucleolus of the game Γ.
A problem closely related to the integer nucleolus is that of finding minimum (or minimum-sum) integer representations of weighted majority games (cf. Peleg [3], Krohn and Sudhölter [4], Kurz et al. [5]). In Wolff and Karagök [6], the integer nucleolus is used to analyze the apportionment of ministries in the Swiss parliament. Fragnelli and Gastaldi [7] study the bankruptcy problem where the estate and the claims are integer, and compare integer versions of the Talmud solution to this problem with the integer nucleolus of the corresponding pessimistic bankruptcy game when there are two or three agents. It is interesting to note that Fragnelli et al. [8,9] suggest integer solutions to a bankruptcy setting that involves an integer estate, while the claims can be of any positive magnitude. An example is the assignment of emergency intervention units, when the claims are calculated in proportion to the size of the population or area to attend to, which, in turn, means that the characteristic function of an associated bankruptcy game may assume noninteger values. A bankruptcy-based model for the management of capacity-constrained integer resources in mobile radio networks is proposed in Lucas-Esta n ˜ et al. [10]. Further examples of integer resources are college places, housing opportunities, livestock, or organs for transplant. Finally, when a sum of money is to be divided among a set of players, each smallest relevant money unit also is a whole object.
Since I ( Γ ) lacks convexity, ν ( Γ ) may contain multiple elements. The question arises in such a case whether the payoff vectors in ν ( Γ ) possess some common attributes, beyond the property that they all minimize θ lexicographically. A complementary practical question is how to compute ν ( Γ ) . In general, ν ( Γ ) can be obtained by solving a sequence of integer linear programs, analogous to a suggestion by Maschler [2] (p. 615) that is implemented in most of the studies compiled by Leng and Parlar [11] (p. 669):
ILP k : min ϵ , x ϵ s . t . x ( S ) + ϵ v ( S ) for   all S 2 N \ { A 0 , , A k 1 } , x ( S ) + ϵ i = v ( S ) for   all S A i , i = 1 , , k 1 , x I ( Γ ) , k = 1 , 2 , ,
where A 0 : = { , N } , while A i , i 1 , is the set of coalitions with excess ϵ i < < ϵ 1 for each optimal solution ( ϵ i , x ) to I L P i (cf. Guajardo and Jörnsten [12] and Nguyen and Thomas [13]). For some k = κ , eventually 2 N \ { A 0 , , A κ } = , in which case I L P κ is solved by the set of pairs ( ϵ κ , x ) with x ν ( Γ ) . However, this is only a feasible procedure if n is small, since integer linear programs are usually much harder to solve than their continuous counterparts. The present article provides a characterization of ν ( Γ ) with respect to the class of directed simple games, and suggests an algorithm to compute ν ( Γ ) for this game class more efficiently, as long as I ( Γ ) is not too large. We focus on directed simple games because they have numerous applications—e.g., in economics, in political science, and in threshold logic (cf. Taylor and Zwicker [14] for literature references).
A simple game Γ t with t Z > 0 is a monotonic game Γ, whereby v ( S ) v ( T ) if S T N , that satisfies v ( S ) { 0 , t } for each S N , while v ( N ) = t . We denote by W ( Γ t ) : = { S N : v ( S ) = t } the set of winning coalitions of Γ t . A simple game Γ t is called an ordered (or complete or linear) simple game, if it exhibits a complete desirability relation D on the players in the set N. It is called a directed simple game, if in addition 1 D D n , without loss of generality. Given a game Γ, if i D j for two players i , j N , then player i is said to be more desirable than player j, in which case
v ( S { i } ) v ( S { j } ) for   all S N \ { i , j } .
Player i is said to be strictly more desirable than player j, denoted by i D j , if i D j , while not j D i . The players are called symmetric—denoted by i D j —if both i D j and j D i (cf. Maschler and Peleg [15], Sect. 9). The desirability relation may be hidden in the set of winning coalitions, and can then be computed with polynomial-time methods (cf. Aziz [16] and Aziz [17], Ch. 3). It may also be rooted naturally in the setup of the game. For example, consider a simple game Γ t that is a weighted majority game with a quota q R > 0 and the weights w 1 , , w n R 0 of the players, where q i N w i . Here, W ( Γ t ) : = S N : i S w i q . Hence, i D j for two players i , j N whenever w i w j . We shall represent such a game by the tuple [ q ; w 1 , , w n ; t ] , in brief [ q ; w ; t ] , where w : = ( w 1 , , w n ) . Note that the desirability relation of an ordered simple game Γ t is strictly preserved by the counting vector c : = ( c 1 , , c n ) , where c i : = | S W ( Γ t ) : i S | (cf. Lapidot [18,19]). Note also that the integer nucleolus ν ( Γ ) of any game Γ is nonempty and finite whenever I ( Γ ) . A characterization of ν ( Γ t ) will now be derived in Section 2. The algorithm and a performance analysis follow in Section 3 and Section 4. Section 5 provides an extension to the integer prenucleolus, and Section 6 concludes.

2. A Characterization of ν ( Γ t )

We begin with two general properties of the integer nucleolus:
Lemma 1.
Let Γ be a game. If i D j for two players i , j N , then x i x j for each x ν ( Γ ) .
Proof. 
Take any x ν ( Γ ) . Suppose x i x j 1 , noting that x i v ( { i } ) by definition of ν ( Γ ) . Assume i D j , so v ( S { i } ) v ( S { j } ) for every S N \ { i , j } by definition. In particular, v ( { i } ) v ( { j } ) , and thus x j 1 x i v ( { i } ) v ( { j } ) .
Observe that e ( S { i } , x ) e ( S { j } , x ) + 1 for each S N \ { i , j } . Since i D j by assumption, there exists a coalition T N \ { i , j } such that v ( T { i } ) > v ( T { j } ) , implying e ( T { i } , x ) e ( T { j } , x ) + 2 .
Hence, a reallocation at x of one unit of payoff from player j to player i will result in an integer imputation that improves θ, a contradiction (note that the excesses of all coalitions which contain neither or both of the players i and j are not affected). Therefore, if i D j and x ν ( Γ ) , then x i x j . ☐
Lemma 2.
Let Γ be a game. If i D j for two players i , j N , then | x i x j | { 0 , 1 } for each x ν ( Γ ) .
Proof. 
Take any x ν ( Γ ) . Without loss of generality, suppose x i x j 2 , noting again that x i v ( { i } ) by definition of ν ( Γ ) . Assume i D j , so v ( S { i } ) = v ( S { j } ) for every S N \ { i , j } by definition. In particular, v ( { i } ) = v ( { j } ) , and thus x j 2 x i v ( { i } ) = v ( { j } ) . At the same time, e ( S { i } , x ) e ( S { j } , x ) + 2 for each S N \ { i , j } . Consequently, a reallocation at x of one unit of payoff from player j to player i yields an integer imputation that improves θ, a contradiction. Therefore, if i D j and x ν ( Γ ) , then | x i x j | { 0 , 1 } . ☐
Remark 1.
Let Γ be a game, where i D j for two players i , j N . If x i x j for x ν ( Γ ) , and payoff vector z differs from x only in that the payoffs of players i and j are permuted, then z ν ( Γ ) by the anonymity (impartiality) of ν ( Γ ) .
The following lemma and a subsequent corollary are our main theoretical result:
Lemma 3.
The integer nucleolus ν ( Γ t ) of a directed simple game Γ t with I ( Γ t ) has a unique element, henceforth denoted by y , that weakly preserves D ; i.e., y 1 y n .
Proof. 
By definition of a directed game, 1 D D n . Then, because of Lemmas 1 and 2, Remark 1, and the nonemptiness of ν ( Γ t ) , a payoff vector like y exists. To prove its uniqueness, suppose for x I ( Γ t ) that x y and x 1 x n . Denote by i the largest index j for which x j y j . Hence, x j = y j for j > i . Without loss of generality, suppose x i > y i . Note that x ν ( Γ t ) if and only if θ ( x ) = θ ( y ) :
C a s e 1 : { i } W ( Γ t ) ; i.e., e ( { i } , y ) = y i . Assume y i = 0 . Then, x j = 0 if and only if j > i , in which case also y j = 0 . Now consider any coalition S N , S , with e ( S , x ) = 0 . If S W ( Γ t ) , then x ( S ) = t , and thus x l = 0 for every player l N \ S . Since y l = 0 for each such player, y ( S ) = t and hence e ( S , y ) = 0 . If S W ( Γ t ) , then x k = 0 , and thus y k = 0 , for every k S , whereby also e ( S , y ) = 0 . However, as e ( { i } , x ) = x i < 0 , we conclude that θ ( x ) θ ( y ) .
Next, assume y i > 0 . Observe for any coalition S N , S , with e ( S , x ) = y i that S { i + 1 , , n } . Hence, e ( S , y ) = y i . Consequently, as e ( { i } , x ) = x i < y i , again θ ( x ) θ ( y ) . In all, x ν ( Γ t ) .
C a s e 2 : { i } W ( Γ t ) , whereby y i = t since y I ( Γ t ) . In particular, i = 1 , as y 1 y n . Hence, y = ( t , 0 , , 0 ) , and therefore x I ( Γ t ) , a contradiction.
To summarize, it cannot be true that x ν ( Γ t ) , x y , and x 1 x n . ☐
Remark 2.
The proof of Lemma 3 does not depend on the assumed monotonicity of simple games, and the desirability relation D was not needed to show the uniqueness of y . We conclude from the latter observation—since we are free to renumber the players—that if Γ is a simple game, then ν ( Γ ) contains at most one payoff vector for every order of the payoffs x 1 , , x n .1
A permutation π of the player set N of a game Γ such that v ( π ( S ) ) = v ( S ) for each S N is called a symmetry of Γ. Because of Lemma 3 and Remark 1:
Corollary 1.
The integer nucleolus ν ( Γ t ) of a directed simple game Γ t with I ( Γ t ) is the set of images of y under all symmetries of Γ t .
We close this section with three examples and a remark:
Example 1.
Let Γ t be represented by [ 33 ; 15 , 15 , 10 , 10 , 4 , 4 , 4 , 2 , 1 ; 30 ] . Then, y = ( 7 , 7 , 4 , 4 , 3 , 2 , 2 , 1 , 0 ) . Additionally, c = ( 189 , 189 , 163 , 163 , 147 , 147 , 147 , 129 , 129 ) ; i.e., c 5 = c 6 = c 7 and c 8 = c 9 . Since y 5 > y 6 , y 7 , and y 8 > y 9 , we obtain a set ν ( Γ t ) of six payoff vectors. We provide them in anti-lexicographic order:
ν ( Γ t ) = { ( 7 , 7 , 4 , 4 , 3 , 2 , 2 , 1 , 0 ) , ( 7 , 7 , 4 , 4 , 3 , 2 , 2 , 0 , 1 ) , ( 7 , 7 , 4 , 4 , 2 , 3 , 2 , 1 , 0 ) ,
( 7 , 7 , 4 , 4 , 2 , 3 , 2 , 0 , 1 ) , ( 7 , 7 , 4 , 4 , 2 , 2 , 3 , 1 , 0 ) , ( 7 , 7 , 4 , 4 , 2 , 2 , 3 , 0 , 1 ) } .
Example 2.
Let (the non-proper game) Γ t be represented by [ 6 ; 4 , 4 , 2 , 2 , 2 , 1 ; 8 ] . Then, y = ( 2 , 2 , 1 , 1 , 1 , 1 ) , while c = ( 30 , 30 , 26 , 26 , 26 , 23 ) . Hence, ν ( Γ t ) = { ( 2 , 2 , 1 , 1 , 1 , 1 ) } .
Example 3.
Consider the game Γ where n = 3 and v ( { 1 } ) = v ( { 2 } ) = 1 , v ( { 3 } ) = 0 , v ( { 1 , 2 } ) = 2 , v ( { 1 , 3 } ) = v ( { 2 , 3 } ) = 1 , v ( { 1 , 2 , 3 } ) = 7 . Note that 1 2 3 , whereas ν ( Γ ) = ( 3 , 3 , 1 ) , ( 3 , 2 , 2 ) , ( 2 , 3 , 2 ) . Lemma 3 and Corollary 1 thus cannot be generalized to every directed game Γ.
Remark 3.
In Example 2, player 6 is a null player, yet y 6 = 1 . In general, let Γ be a game, and write as L ( Γ ) : = j N : v ( S ) = v ( S { j } ) f o r   a l l S N \ { j } the set of null players of Γ. Suppose x I ( Γ ) and x i 2 for i L ( Γ ) . Since v ( N ) > 0 , there exists a coalition T arg max S N e ( S , x ) , such that T L ( Γ ) = , whereby e ( Q , x ) e ( T , x ) 2 for all Q N , i Q . So, a reallocation at x of one unit of payoff from player i to a player k T improves θ. Hence, x i { 0 , 1 } for each i L ( Γ ) and every x ν ( Γ ) .

3. An Algorithm to Compute ν ( Γ t )

Given a directed simple game Γ t , denote by θ W the subvector of θ associated with the coalitions in W ( Γ t ) \ N , and by P ( Γ t ) : = x I ( Γ t ) : x 1 x n | x i x j | { 0 , 1 } for   all i j , i D j the subset of integer imputations in anti-lexicographic order that satisfy Lemmas 1 and 2. Let ν W ( Γ t ) : = x P ( Γ t ) : θ W ( x ) l e x θ W ( z ) for   all z P ( Γ t ) . Write as V ( Γ t ) : = i N : S W ( Γ t ) i S the set of veto players of Γ t , and let r : = | V ( Γ t ) | . If r > 0 , then V ( Γ t ) = { 1 , , r } , because Γ t is directed.
Lemma 4.
Let Γ t be a directed simple game with I ( Γ t ) . If W ( Γ t ) \ N , then ν W ( Γ t ) = { y } .
Proof. 
Assume W ( Γ t ) \ N , and note that P ( Γ t ) due to I ( Γ t ) . Hence, ν W ( Γ t ) . In particular, y ν W ( Γ t ) . Now suppose r > 0 , whereby x ( V ( Γ t ) ) = t for each x ν W ( Γ t ) . Since i D j for any two players i , j V ( Γ t ) , only one element of the set P ( Γ t ) assigns the payoff t to coalition V ( Γ t ) , this element being
y = ( y + 1 , , y + 1 s times , y , , y r s times , 0 , , 0 n r times ) ,
where y : = t r denotes the largest integer that does not exceed t r , and s : = t r y . Thus, ν W ( Γ t ) = { y } .
Next, suppose r = 0 ; i.e., V ( Γ t ) = . Take any x P ( Γ t ) , x y , and denote by i the largest index j such that x j y j . Accordingly, x j = y j for all j > i . Without loss of generality, assume x i > y i . As i V ( Γ t ) , there exists a coalition S W ( Γ t ) \ N , i S , and hence N \ { i } W ( Γ t ) by the monotonicity of Γ t . Consequently, e ( N \ { i } , y ) = y i . This excess may be obtained at x only by winning coalitions N \ T with T { i + 1 , , n } , but then also at y . Since e ( N \ { i } , x ) = x i > y i , we obtain θ W ( x ) θ W ( y ) , and so x ν W ( Γ t ) .2 ☐
The borderline case of a directed simple game Γ t with W ( Γ t ) \ N = implies that W ( Γ t ) = { N } = V ( Γ t ) , and thereby I ( Γ t ) , as well as ν ( Γ t ) = P ( Γ t ) = { y } because of the symmetry of all players. The associated payoff vector y is determined by (3) for r = n .
Thus, if Γ t is a directed simple game and I ( Γ t ) , we may search P ( Γ t ) for y without reference to the coalitions not contained in W ( Γ t ) . In view of this observation, we now suggest an algorithm to compute the integer nucleolus of any such game. Since the elements of P ( Γ t ) have independent excess vectors θ W , our algorithm can make the most of computing machinery that supports the parallel execution of multiple threads in an application program. Note for each x P ( Γ t ) with x k > 0 , x k + 1 = 0 , that x 1 + + x k is a partition of t into k ( min { t , n } ) parts in standard form. A fast generator of integer partitions in standard form and in anti-lexicographic order is procedure ZS1 by Zoghbi and Stojmenović [20] (pp. 325–326).
To proceed, define the incidence vector 1 S { 0 , 1 } n of any coalition S W ( Γ t ) \ N in that 1 S i = 1 if and only if i S , and consider the auxiliary vector a S : = ( a S 1 , , a S n ) , where
a S i : = j i 1 S j , i = 1 , , n .
Hence, if x P ( Γ t ) and x k > 0 , x k + 1 = 0 , then a S k players in coalition S receive a positive payoff. These players can be read off the auxiliary vector b S : = ( b S 1 , , b S | S | ) , where
b S i : = index   of   the   i th   positive   entry   of   1 S , i = 1 , , | S | .
The total payoff of coalition S at x thus amounts to i a S k x b S i . For example, if n = 7 and S = { 2 , 3 , 6 } , we obtain 1 S = ( 0 , 1 , 1 , 0 , 0 , 1 , 0 ) , a S = ( 0 , 1 , 2 , 2 , 2 , 3 , 3 ) , and b S = ( 2 , 3 , 6 ) . Thereby, if t = 6 and x = ( 2 , 2 , 1 , 1 , 0 , 0 , 0 ) —noting that x results from a partition of t into four parts— x ( { 2 , 3 , 6 } ) = i a S 4 x b S i = x 2 + x 3 .
For each x P ( Γ t ) , let D ( Γ t , x , h ) : = S W ( Γ t ) \ N : e ( S , x ) = h with h { 0 , , t } , and attach to x the auxiliary vector Θ ( x ) : = ( Θ 1 ( x ) , , Θ t + 1 ( x ) ) , where
Θ t h + 1 ( x ) : = | D ( Γ t , x , h ) | , h = t , , 0 .
This way, Θ ( x ) holds the number of occurrences of excesses of a size at x , top-down from the largest excess t to the smallest excess 0 of the coalitions in the set W ( Γ t ) \ N . Thereby, given any two payoff vectors x ˜ , x ^ P ( Γ t ) , x ˜ is preferred to x ^ if and only if Θ ( x ˜ ) < l e x Θ ( x ^ ) . While calculating and counting excesses hand in hand, we may be able to tell quite early how x P ( Γ t ) compares to a current best status quo, say x * . Let Θ * : = Θ ( x * ) , and suppose l is the first index i for which Θ i * > 0 . Then, payoff vector x can already be discarded if any of the first l 1 entries of Θ ( x ) has been detected to take a positive value or once Θ l ( x ) is known to exceed Θ l * .
This observation has been built into the computer pseudocode in Table 1. The code distributes most of the workload across a user-defined number p ( 1 ) of threads, in support of machines that can execute multiple threads in parallel (desktop applications will most often benefit from creating as many parallel threads as possible, unless | P ( Γ t ) | is small). On input, Γ t and p are passed to the main program LEXMIN that at first generates both n and t as well as the counting vector c , the set P ( Γ t ) , and the pairs ( a S , b S ) , S W ( Γ t ) \ N . Then, it allocates memory for an array x * ( 1 : p ) of p best status-quo payoff vectors, before invoking the thread functions LEXMIN 1 , , LEXMIN p . Each of them refers to a separate piece of code, such as the code for thread function LEXMIN i . This function initializes x * ( i ) , Θ * , and l, in terms of a most equal allocation of t across the players, and then enters into two nested loops. In an attempt to spread the computational burden evenly across the threads, the outer loop has been designed to pass over every pth element of the (ordered) set P ( Γ t ) , starting from element number i. For each resulting payoff vector x P ( Γ t ) and underlying number k of parts of t, the inner loop computes the excesses associated with x and populates Θ ( x ) . If in the course of these operations index t h + 1 comes out less than l, or Θ l * is exceeded, then x will be discarded by a subsequent exit instruction. In the remaining cases, whenever Θ ( x ) is lexicographically smaller than Θ * , the elements of the set { x * ( i ) , Θ * , l } are updated. Once all threads are completed, LEXMIN minimizes Θ lexicographically over the set of retained payoff vectors { x * ( 1 ) , , x * ( p ) } in order to obtain the unique argument y , and then the pair ( c , y ) is returned. Note that all relevant variables are considered as local to LEXMIN and its thread functions unless stated otherwise.
Remark 4.
A payoff vector x P ( Γ t ) can already be discarded if Θ l is seen to be no smaller than Θ l * , while Θ l + 1 is known to be greater than Θ l + 1 * , etc. This may serve to reject x more quickly, while the extra comparisons can have the opposite effect.
Remark 5.
If a reallocation of a unit of payoff between players i and j is unfavorable, another such reallocation can be rejected, everything else being equal. We then do not have to trace Θ over the full set P ( Γ t ) , at the cost of an extended bookkeeping.
Remark 6.
One may want to exploit the occurrence of special categories of players (e.g., null players or vetoers), which imposes a search cost (cf. Aziz [16] and Aziz [17], Ch. 3, for the complexity of detecting player types).
Remark 7.
The coalitions S W ( Γ t ) \ N have independent pairs ( a S , b S ) , which suggests a distributed execution of the second loop in LEXMIN.
Once y is known, we conduct a scan of the counting vector c for all subvectors ( c i , , c j ) , where c i = = c j and y i > y j , the range j i being as large as possible. If no such subvector exists, then ν ( Γ t ) = { y } , and we are done. Otherwise, given whichever pair ( i , j ) of matching indices, we retain all elements of ν ( Γ t ) obtained earlier, as well as every payoff vector that can be derived from these elements by permuting the payoffs of the players i , , j .
The pseudocode program COMPL in Table 2 generates a corresponding sequence of approximations { y 1 , , y m } to ν ( Γ t ) . On input, Γ t and the pair ( c , y ) are passed. To begin with, the program determines n and initializes ν ( Γ t ) . Then, starting from i = j = n , the program looks for the smallest i ( < j ) for which both c i = c j and y i > y j .3 Whenever a matching i is found, the program retrieves all permutations of the payoffs in ( y i , , y j ) from the respective permutation set, named B ( i , j ) , and updates ν ( Γ t ) . In the following iteration, j is set to i 1 , and so on. The search ends if i 2 , and then ν ( Γ t ) is returned. Note that for each matching pair ( i , j ) the respective subvector ( y i , , y j ) of y takes the form ( a , , a , b , , b ) , where b = a 1 . The set B ( i , j ) can thus be calculated with ACM Algorithm 152 (Nexcom) by Hopley [21], under the normalization a = 1 .
We end this section with a working example of our algorithm and a generalization. The example is primarily meant to illustrate the functioning of a thread in Table 1. Thus, we assume, for simplicity, that p = 1 :
Example 4.
Let Γ t be represented by [ 9 ; 5 , 4 , 3 , 2 , 1 ; 6 ] . In this game,
W ( Γ t ) \ N = { { 1 , 2 } , { 1 , 2 , 3 } , { 1 , 2 , 4 } , { 1 , 2 , 5 } , { 1 , 3 , 4 } , { 1 , 3 , 5 } , { 2 , 3 , 4 } , { 1 , 2 , 3 , 4 } ,
{ 1 , 2 , 3 , 5 } , { 1 , 2 , 4 , 5 } , { 1 , 3 , 4 , 5 } , { 2 , 3 , 4 , 5 } } .
Thereby, c = ( 11 , 10 , 9 , 8 , 7 ) ; i.e., the game exhibits the desirability relation 1 D 2 D 3 D 4 D 5 . Hence,
P ( Γ t ) = { ( 6 , 0 , 0 , 0 , 0 ) , ( 5 , 1 , 0 , 0 , 0 ) , ( 4 , 2 , 0 , 0 , 0 ) , ( 4 , 1 , 1 , 0 , 0 ) , ( 3 , 3 , 0 , 0 , 0 ) , ( 3 , 2 , 1 , 0 , 0 ) ,
( 3 , 1 , 1 , 1 , 0 ) , ( 2 , 2 , 2 , 0 , 0 ) , ( 2 , 2 , 1 , 1 , 0 ) , ( 2 , 1 , 1 , 1 , 1 ) } .
The sole thread L E X M I N 1 then proceeds as follows if the elements of W ( Γ t ) \ N arrive at the thread’s inner loop in the above order from coalition { 1 , 2 } to coalition { 2 , 3 , 4 , 5 } :
x last   Θ in inner   loop x * ( 1 ) Θ * l last   S in inner   loop
( 2 , 1 , 1 , 1 , 1 ) ( 0 , 0 , 0 , 2 , 6 , 4 , 0 ) 4
( 6 , 0 , 0 , 0 , 0 ) ( 1 , 0 , 0 , 0 , 0 , 0 , 6 ) ( 2 , 1 , 1 , 1 , 1 ) ( 0 , 0 , 0 , 2 , 6 , 4 , 0 ) 4 { 2 , 3 , 4 }
( 5 , 1 , 0 , 0 , 0 ) ( 0 , 1 , 0 , 0 , 0 , 2 , 4 ) ( 2 , 1 , 1 , 1 , 1 ) ( 0 , 0 , 0 , 2 , 6 , 4 , 0 ) 4 { 2 , 3 , 4 }
( 4 , 2 , 0 , 0 , 0 ) ( 0 , 0 , 1 , 0 , 2 , 0 , 4 ) ( 2 , 1 , 1 , 1 , 1 ) ( 0 , 0 , 0 , 2 , 6 , 4 , 0 ) 4 { 2 , 3 , 4 }
( 4 , 1 , 1 , 0 , 0 ) ( 0 , 0 , 1 , 0 , 0 , 5 , 1 ) ( 2 , 1 , 1 , 1 , 1 ) ( 0 , 0 , 0 , 2 , 6 , 4 , 0 ) 4 { 2 , 3 , 4 }
( 3 , 3 , 0 , 0 , 0 ) ( 0 , 0 , 0 , 3 , 0 , 0 , 4 ) ( 2 , 1 , 1 , 1 , 1 ) ( 0 , 0 , 0 , 2 , 6 , 4 , 0 ) 4 { 2 , 3 , 4 }
( 3 , 2 , 1 , 0 , 0 ) ( 0 , 0 , 0 , 2 , 3 , 4 , 3 ) ( 3 , 2 , 1 , 0 , 0 ) ( 0 , 0 , 0 , 2 , 3 , 4 , 3 ) 4 { 2 , 3 , 4 , 5 }
( 3 , 1 , 1 , 1 , 0 ) ( 0 , 0 , 0 , 2 , 3 , 6 , 1 ) ( 3 , 2 , 1 , 0 , 0 ) ( 0 , 0 , 0 , 2 , 3 , 4 , 3 ) 4 { 2 , 3 , 4 , 5 }
( 2 , 2 , 2 , 0 , 0 ) ( 0 , 0 , 0 , 0 , 9 , 0 , 3 ) ( 2 , 2 , 2 , 0 , 0 ) ( 0 , 0 , 0 , 0 , 9 , 0 , 3 ) 5 { 2 , 3 , 4 , 5 }
( 2 , 2 , 1 , 1 , 0 ) ( 0 , 0 , 0 , 1 , 3 , 2 , 0 ) ( 2 , 2 , 2 , 0 , 0 ) ( 0 , 0 , 0 , 0 , 9 , 0 , 3 ) 5 { 1 , 3 , 5 }
Upon initialization, x * ( 1 ) = ( 2 , 1 , 1 , 1 , 1 ) , whereby θ W = ( 3 , 3 , 2 , 2 , 2 , 2 , 2 , 2 , 1 , 1 , 1 , 1 ) , such that Θ * = ( 0 , 0 , 0 , 2 , 6 , 4 , 0 ) and l = 4 . The first payoff vector x = ( 6 , 0 , 0 , 0 , 0 ) in the (ordered) set P ( Γ t ) will be discarded as soon as L E X M I N 1 has calculated the excess of coalition { 2 , 3 , 4 } , since h = e ( { 2 , 3 , 4 } , x ) = 6 , and thus t h + 1 = 1 < 4 , etc. Eventually, Θ * can be improved at x = ( 3 , 2 , 1 , 0 , 0 ) , where Θ * = ( 0 , 0 , 0 , 2 , 3 , 4 , 3 ) , and again at x = ( 2 , 2 , 2 , 0 , 0 ) , where Θ * = ( 0 , 0 , 0 , 0 , 9 , 0 , 3 ) . The latter payoff vector is finally identified as y by the main program LEXMIN, and the pair ( c , y ) is returned. At last, routine COMPL finds in view of c = ( 11 , 10 , 9 , 8 , 7 ) that there is no matching pair ( i , j ) . Therefore, on output, ν ( Γ t ) = { ( 2 , 2 , 2 , 0 , 0 ) } .
For a generalized simple game Γ t , the monotonicity property is dropped, and it is not maintained that v ( ) = 0 and v ( N ) = t (cf. Carreras and Freixas [22], p. 153, and Taylor and Zwicker [14], p. 4). The desirability relation of a directed generalized simple game is also strictly preserved by the counting vector c . However, I ( Γ t ) may have to be redefined as denoting the set x Z n : x ( N ) = t , x i v ( { i } ) for   all i N . The proof of Lemma 3 then remains valid, and hence statements analogous to Lemma 3 and Corollary 1 apply. The following result replaces Lemma 4:
Lemma 5.
Let Γ t be a directed generalized simple game with I ( Γ t ) . Suppose x , x ˜ P ( Γ t ) , x x ˜ . Denote by i the largest index j for which x j x ˜ j , where x i > x ˜ i without loss of generality. Then θ W ( x ) = θ W ( x ˜ ) θ ( x ) < l e x θ ( x ˜ ) .
Proof. 
Assume { i } W ( Γ t ) , whereby i = 1 , since Γ t is directed and I ( Γ t ) . Hence, x j = x ˜ j for each player j 2 . Since x 1 > x ˜ 1 , it cannot be true that both x and x ˜ are contained in P ( Γ t ) . So, assume { i } W ( Γ t ) . Consider any nonempty coalition S N , S W ( Γ t ) . Observe that x j = x ˜ j whenever j > i . Consequently, if e ( S , x ) > x ˜ i or e ( S , x ˜ ) > x ˜ i , and thus S { i + 1 , , n } , then e ( S , x ) = e ( S , x ˜ ) . Furthermore, if e ( S , x ) = x ˜ i , and hence again S { i + 1 , , n } , then also e ( S , x ˜ ) = x ˜ i . Therefore, and since e ( { i } , x ) = x i < x ˜ i = e ( { i } , x ˜ ) , if θ W ( x ) = θ W ( x ˜ ) , then θ ( x ) < l e x θ ( x ˜ ) . ☐
Hence, if θ W ( x ) = θ W ( x ˜ ) for two payoff vectors x , x ˜ P ( Γ t ) , we can always discriminate between them by inspecting the smallest payoff components by which they differ. The required adjustment of the code in Table 1 is straightforward.

4. Performance Analysis

The computational workload of the algorithm in Section 3 is mostly determined by the cost of finding y . In a worst-case scenario, if n t while there are no symmetric players, then | P ( Γ t ) | 1 4 t 3 e π 2 t 3 = O ( 1 t e t ) (cf. Hall [23], p. 44) for the asymptotic total number of payoff vectors that have to be considered. In another worst-case scenario, every coalition S N , S , { 2 } , , { n } , is winning, and the inner loop of each thread function then executes | W ( Γ t ) \ N | = 2 n n 1 = O ( 2 n ) times altogether.
The algorithm has been applied on two personal computers to solve several samples of weighted majority games Γ t , where w : = i = 1 n w i is an odd sum of integer weights, and q = w + 1 2 . The weights have been drawn from the interval [ 1 , n ] at random, in terms of uniform deviates as supplied by a system routine. The chosen order of the coalitions S W ( Γ t ) \ N in the thread functions was from the smallest to the largest coalitions, with a lexicographic ordering of each group of coalitions of a size (cf. Example 4). One computer (machine 1) was equipped with a dual-core CPU (Intel(R) Core(TM) i7-2620M, 2.70 GHz) and the other (machine 2) with a quad-core CPU (Intel(R) Core(TM) i5-760, 2.80 GHz). Both CPUs possess four logical processors, whereby p = 4 . The algorithm’s run-times were measured as the elapsed time when computing the solution of a given game from the pair ( n , t ) and the set W ( Γ t ) \ N . Aiming at a performance improvement (albeit small), the main program LEXMIN in Table 1 was modified to take account of the suggestion in Remark 7.
Two samples of fifty games have been solved with machine 1. In the first sample, ( n , t ) = ( 7 , 300 ) , whereas ( n , t ) = ( 10 , 100 ) in the second. The average run-times per game were about four seconds (first sample) and about five seconds (second sample). Two samples of ten games have been solved with machine 2. In the first of these samples, ( n , t ) = ( 20 , 30 ) , while ( n , t ) = ( 20 , 40 ) in the second. The average run-times were about two seconds (first sample) and about ten seconds (second sample). In comparison, the Gurobi(TM) [24] linear-programming tool (version 6.5.0, with default settings) needed between about 4 and 35 min, with an average of about 20 1 2 min, to complete only the first linear program of procedure (1) on machine 2 for the ten games where ( n , t ) = ( 20 , 30 ) . At this stage, just one element of a single game’s integer nucleolus (of cardinality three) could be found. The tool used all available cores of the CPU.

5. Extension to the Integer Prenucleolus

If a simple game Γ t admits two or more winning single-player coalitions, then v ( Γ t ) = I ( Γ t ) = . In such a case—or when the individual rationality of the game solution is not an issue—we may refer to the integer prenucleolus ν * ( Γ t ) : = N Γ t , I * ( Γ t ) , where I * ( Γ t ) : = x Z n : x ( N ) = v ( N ) is the game’s integer preimputation set with v ( N ) = t Z > 0 . Note that ν * ( Γ t ) is nonempty and finite.
Lemma 6.
Let Γ t be a simple game. If x ν * ( Γ t ) , then 1 x i t for all i N .
Proof. 
Take any x ν * ( Γ t ) and let N : = j N : x j 1 . Observe that x I * ( Γ t ) , whereby N \ N . Then, consider an arbitrary player i N :
( a ) Assume x i 2 . Hence, i N . Let Q : = arg max S N e ( S , x ) and consider any coalition Q Q , whereby | Q | < n . Since Γ t is monotonic, N Q , and hence there must be a player k N \ N , k Q . Now take any coalition T arg max k S N \ { i } e ( S , x ) . Suppose T = N \ { i } , such that e ( T , x ) = v ( N \ { i } ) x ( N \ { i } ) t ( x ( N ) x i ) = x i 2 . Since e ( { i } , x ) 2 , a reallocation at x of one unit of payoff from player k to player i improves θ, and therefore x ν * ( Γ t ) . Next, suppose T N \ { i } . Observe that e ( T , x ) e ( T { i } , x ) + x i by the monotonicity of Γ t , and that e ( T { i } , x ) e ( Q , x ) by definition of the set Q . Consequently, e ( T , x ) e ( Q , x ) + x i e ( Q , x ) 2 . As i Q , we conclude that θ can still be improved at x by a reallocation of one unit of payoff from player k to player i. Thus again x ν * ( Γ t ) , a contradiction.
( b ) Assume x i t + 1 . Hence, N due to x I * ( Γ t ) . Take any player k N , and let ϵ : = max k S N \ { i } e ( S , x ) . Thereby, ϵ e ( N , x ) x ( N ) . Moreover, let γ : = max i T N \ { k } e ( T , x ) . Since none of the T-type coalitions can receive an aggregate payoff smaller than x ( N \ { k } ) + x i , we have γ t ( x ( N ) x k ) x i . So, ϵ γ x i t x k 1 x k 2 . Therefore, a reallocation at x of one unit of payoff from player i to player k improves θ, which means that x ν * ( Γ t ) , also a contradiction.
In all, it cannot be true that x ν * ( Γ t ) and x i < 1 or x i > t for some i N . ☐
Lemma 7.
Let Γ t be a generalized simple game. If x ν * ( Γ t ) , then t x i t for all i N .
Proof. 
Take any x ν * ( Γ t ) . Note that part (b) of the proof of Lemma 6 does not depend on the monotonicity of Γ t or on the convention that v ( ) = 0 . With I * ( Γ t ) being redefined as denoting the set x Z n : x ( N ) = t , the assumption that v ( N ) = t is also not needed. Hence, x i t . Now assume x i ( t + 1 ) . It then follows from x I * ( Γ t ) that there must be a player k N with x k 1 . Letting μ : = max i S N \ { k } e ( S , x ) and τ : = max k T N \ { i } e ( T , x ) , we conclude—analogous to part (b) of the proof of Lemma 6—that μ τ x k t x i 1 + x k 2 . Consequently, a reallocation at x of one unit of payoff from player k to player i improves θ, which contradicts the assumption that x ν * ( Γ t ) . Therefore, if x ν * ( Γ t ) , then x i t . ☐
The following statement can be proved with methods similar to those used in Section 2 (cf. the proofs of Lemmas 1 and 2). The proof is thus omitted:
Lemma 8.
Let Γ be a game, and suppose x ν * ( Γ ) . If i D j for two players i , j N , then x i x j . If i D j , then | x i x j | { 0 , 1 } .
Remark 8.
Let Γ be a game. If z is a payoff vector that differs from x ν * ( Γ ) only in that the payoffs of two symmetric players are permuted, then z ν * ( Γ ) , analogous to Remark 1.
We end our discussion of the integer prenucleolus with a few examples and clarifying remarks:
Example 5.
Let Γ t be represented by [ 4 ; 2 , 2 , 2 , 1 ; 4 ] . In this game, c = ( 6 , 6 , 6 , 4 ) . Its integer prenucleolus is composed of all integer preimputations—except for ( 1 , 1 , 1 , 1 ) —that satisfy Lemmas 6 and 8: ν * ( Γ t ) = ( 2 , 1 , 1 , 0 ) , ( 1 , 2 , 1 , 0 ) , ( 1 , 1 , 2 , 0 ) , ( 2 , 2 , 1 , 1 ) , ( 2 , 1 , 2 , 1 ) , ( 1 , 2 , 2 , 1 ) . Note that player 4 is a null player.
Example 6.
Let Γ t be represented by [ 7 ; 3 , 2 , 2 , 2 , 1 ; 7 ] . This is a game without null players, and c = ( 8 , 7 , 7 , 7 , 5 ) . We get ν * ( Γ t ) = { ( 2 , 2 , 2 , 2 , 1 ) } .
Example 7.
Let Γ t be the directed generalized simple game where ( n , t ) = ( 5 , 2 ) and W ( Γ t ) = { 1 } , { 2 } , { 3 } , { 4 } , { 1 , 2 } , { 1 , 3 } , { 1 , 4 } , { 2 , 3 } , { 2 , 4 } , { 3 , 4 } , { 1 , 2 , 3 } , { 1 , 2 , 4 } , { 1 , 2 , 5 } . In this game, 1 D 2 D 3 D 4 D 5 . At the same time, e.g., v ( { 1 } ) > v ( { 1 , 5 } ) , and hence the game is not monotonic. We find that c = ( 7 , 7 , 5 , 5 , 1 ) and ν * ( Γ t ) = { ( 1 , 1 , 1 , 1 , 2 ) } .
Remark 9.
Observe for the game in Example 5 that ν * ( Γ t ) has two elements that weakly preserve D . Hence, Lemma 3 and Corollary 1 do not carry over to the integer prenucleolus.
Remark 10.
Note for the game in Example 6 that ν ( Γ t ) = ( 2 , 2 , 2 , 1 , 0 ) , ( 2 , 2 , 1 , 2 , 0 ) , ( 2 , 1 , 2 , 2 , 0 ) . Thus, in contrast to the continuous case, ν * ( Γ t ) ν ( Γ t ) although { i } W ( Γ t ) for all i N .
If negative payoffs are infeasible for a simple game Γ t with I ( Γ t ) = , we may resort to the integer pseudo-nucleolus ν ( Γ t ) : = N Γ t , I ( Γ t ) as an auxiliary solution concept, where I ( Γ t ) : = x Z 0 n : x ( N ) = v ( N ) and v ( N ) = t Z > 0 . The set ν ( Γ t ) is nonempty and finite. We leave it to the reader to reconsider Case 2 in the proof of Lemma 3 in order to show that the results of Section 2 carry over to ν ( Γ t ) , noting that the players in the set F ( Γ t ) : = i N : { i } W ( Γ t ) are symmetric and that i D j for all i F ( Γ t ) , j N \ F ( Γ t ) , due to the monotonicity of Γ t . We also leave it to the reader to extend the algorithm in Section 3 to the computation of ν * ( Γ t ) for directed simple games Γ t . An extended algorithm will admit negative payoffs of some of the players and allow for multiple optimal payoff vectors that weakly preserve D .

6. Conclusions

We have been concerned with the class of directed simple games, under the assumption that only integer solutions are feasible. The players of such a game face an integer allocation problem, in that they share a resource that comes in discrete units. We showed as our main theoretical result that the integer nucleolus—if nonempty—of a directed simple game is composed of the images of a particular payoff vector under all symmetries of the game. The respective payoff vector is an integer imputation that weakly preserves the desirability relation between the players. In view of this result, we proposed an algorithm for finding the integer nucleolus of any directed simple game with a nonempty integer imputation set. The algorithm does not need to take account of coalitions that are not winning, and it provides support for computing machinery that can execute multiple threads in parallel. The integer nucleolus of a directed generalized simple game with a nonempty set of integer imputations can be computed in almost the same way. Test runs across samples of weighted voting games on two standard personal computers could be completed within acceptable average time spans. Finding the integer prenucleolus of a directed (generalized) simple game may be more demanding.
We close with a note on the well-known 12-player weighted majority game in Isbell [25] (p. 27). This game has two minimum-sum integer representations, where the quota is 99 and the weight vectors are w 1 = ( 38 , 31 , 31 , 28 , 23 , 12 , 11 , 8 , 6 , 5 , 3 , 1 ) and, respectively, w 2 = ( 37 , 31 , 31 , 28 , 23 , 12 , 11 , 8 , 7 , 5 , 3 , 1 ) . The weight vectors differ with respect to two non-symmetric players (i.e., players 1 and 9). Assume for this game that t amounts to 197, which is the game’s sum of weights. The resulting directed simple game Γ t has the two representations [ 99 ; w 1 ; 197 ] and [ 99 ; w 2 ; 197 ] . We obtain c = ( 1478 , 1388 , 1388 , 1350 , 1304 , 1136 , 1132 , 1104 , 1090 , 1072 , 1056 , 1034 ) , and ν ( Γ t ) = { w 1 } .

Acknowledgments

The author is indebted to J. Derks, University of Maastricht, for very helpful comments on earlier versions of this article. Thanks are, moreover, due for a stimulating anonymous communication with respect to the content in Section 5. The remarks and suggestions of two anonymous reviewers also led to an improvement of the article and are gratefully acknowledged.

Conflicts of Interest

The author declares no conflict of interest.

References

  1. Schmeidler, D. The Nucleolus of a Characteristic Function Game. SIAM J. Appl. Math. 1969, 17, 1163–1170. [Google Scholar] [CrossRef]
  2. Maschler, M. The Bargaining Set, Kernel, and Nucleolus. In Handbook of Game Theory with Economic Applications; Aumann, R.J., Hart, S., Eds.; North-Holland: Amsterdam, The Netherlands, 1992; Volume 1, pp. 591–667. [Google Scholar]
  3. Peleg, B. On Weights of Constant-Sum Majority Games. SIAM J. Appl. Math. 1968, 16, 527–532. [Google Scholar] [CrossRef]
  4. Krohn, I.; Sudhölter, P. Directed and Weighted Majority Games. Math. Methods Oper. Res. 1995, 42, 189–216. [Google Scholar] [CrossRef]
  5. Kurz, S.; Napel, S.; Nohn, A. The Nucleolus of Large Majority Games. Econ. Lett. 2014, 123, 139–143. [Google Scholar] [CrossRef]
  6. Wolff, R.; Karagök, Y. Consistent Allocation of Cabinet Seats: The Swiss Magic Formula. Public Choice 2012, 150, 547–559. [Google Scholar] [CrossRef]
  7. Fragnelli, V.; Gastaldi, F. Remarks on the Integer Talmud Solution for Integer Bankruptcy Problems. TOP 2016. [Google Scholar] [CrossRef]
  8. Fragnelli, V.; Gagliardo, S.; Gastaldi, F. Integer Solutions to Bankruptcy Problems with Non-Integer Claims. TOP 2014, 22, 892–933. [Google Scholar] [CrossRef]
  9. Fragnelli, V.; Gagliardo, S.; Gastaldi, F. Bankruptcy Problems with Non-Integer Claims: Definition and Characterizations of the ICEA Solution. TOP 2016, 24, 88–130. [Google Scholar] [CrossRef]
  10. Lucas-Estañ, M.C.; Gozalvez, J.; Sanchez-Soriano, J. Bankruptcy-Based Radio Resource Management for Multimedia Mobile Networks. Trans. Emerg. Telecommun. Technol. 2012, 23, 186–201. [Google Scholar]
  11. Leng, M.; Parlar, M. Analytic Solution for the Nucleolus of a Three-Player Cooperative Game. Naval Res. Logist. 2010, 57, 667–672. [Google Scholar] [CrossRef][Green Version]
  12. Guajardo, M.; Jörnsten, K. Common Mistakes in Computing the Nucleolus. Eur. J. Oper. Res. 2015, 241, 931–935. [Google Scholar] [CrossRef]
  13. Nguyen, T.-D.; Thomas, L. Finding the Nucleoli of Large Cooperative Games. Eur. J. Oper. Res. 2016, 248, 1078–1092. [Google Scholar] [CrossRef]
  14. Taylor, A.; Zwicker, W. Simple Games: Desirability Relations, Trading, Pseudoweightings; Princeton University Press: Princeton, NJ, USA, 1999. [Google Scholar]
  15. Maschler, M.; Peleg, B. A Characterization, Existence Proof and Dimension Bounds for the Kernel of a Game. Pac. J. Math. 1966, 18, 289–328. [Google Scholar] [CrossRef]
  16. Aziz, H. Complexity of Comparison of Influence of Players in Simple Games. In Proceedings of the 2nd International Workshop on Computational Social Choice (COMSOC-2008); Endriss, U., Goldberg, P.W., Eds.; Department of Computer Science, University of Liverpool: Liverpool, UK, 2008; pp. 61–72. [Google Scholar]
  17. Aziz, H. Algorithmic and Complexity Aspects of Simple Coalitional Games. Ph.D. Thesis, University of Warwick, Warwick, UK, 2009. [Google Scholar]
  18. Lapidot, E. On Symmetry-Groups of Games. In Proceedings of the 3rd Annual Israel Conference on Operations Research, Developments in Operations Research; Avi-Itzhak, B., Passy, U., Joffe, R., Eds.; Gordon and Breach: New York, NY, USA, 1971; Volume 2, pp. 571–583. [Google Scholar]
  19. Lapidot, E. The Counting Vector of a Simple Game. Proc. Am. Math. Soc. 1972, 31, 228–231. [Google Scholar] [CrossRef]
  20. Zoghbi, A.; Stojmenović, I. Fast Algorithms for Generating Integer Partitions. Int. J. Comput. Math. 1998, 70, 319–332. [Google Scholar]
  21. Hopley, J. Algorithm 152: Nexcom. Commun. ACM 1963, 6, 68. [Google Scholar] [CrossRef]
  22. Carreras, F.; Freixas, J. Complete Simple Games. Math. Soc. Sci. 1996, 32, 139–155. [Google Scholar] [CrossRef]
  23. Hall, M., Jr. Combinatorial Theory, 2nd ed.; Wiley: New York, NY, USA, 1986. [Google Scholar]
  24. Gurobi Optimization, Inc. Gurobi(TM) Optimizer, Version 6.5.0; Gurobi Optimization, Inc.: Houston, TX, USA, 2015. [Google Scholar]
  25. Isbell, J.R. On the Enumeration of Majority Games. Math. Tables Other Aids Comput. 1959, 13, 21–28. [Google Scholar] [CrossRef]
  • 1This conclusion was brought to the author’s attention through a valuable comment by J. Derks.
  • 2The author thankfully acknowledges a helpful conversation with J. Derks who pointed out to him that, given a simple game Γ t , the set x I ( Γ t ) : θ W ( x ) l e x θ W ( z ) for   all z I ( Γ t ) contains at most one element x with x 1 x n , whenever N \ { i } W ( Γ t ) for all i N . We add that it also suffices to impose the weaker condition that r 1 .
  • 3As to the inner WHILE/DO loop in Table 2, we assume short-circuit evaluation of relational expressions. This means that the expression ’ i > 1 and c i 1 = c j ’ is marked to be false as soon as i = 1 . Hence, no attempt will be made to access a nonexistent c 0 .
Table 1. Lexicographic minimization of θ ( x ) over P ( Γ t ) .
Table 1. Lexicographic minimization of θ ( x ) over P ( Γ t ) .
Input:  Directed simple game Γ t (assuming I ( Γ t ) ), p
Output:  ( c , y )
PROG LEXMIN
GLOBAL W ( Γ t ) \ N , P ( Γ t ) , x * ( ) , p , t ; GLOBAL a S , b S for   all S W ( Γ t ) \ N
n | N | ; t v ( N )
FOR i = 1 TO n DO { c i | { S W ( Γ t ) : i S } | }
P ( Γ t ) x I ( Γ t ) : x 1 x n | x i x j | { 0 , 1 } for   all i j , c i = c j
FOR each S W ( Γ t ) \ N DO {compute ( a S , b S ) as in (4) and (5)}
DIM x * ( 1 : p )
START THREAD LEXMIN1 ; ; START THREAD LEXMINp
DO {wait for threads LEXMIN 1 , , LEXMIN p to complete}
y x * ( 1 ) ; Θ * Θ ( y )
FOR i = 2 TO p DO { IF Θ ( x * ( i ) ) < l e x Θ * THEN y x * ( i ) ; Θ * Θ ( y ) }
END PROG
THREAD FUNCTION LEXMIN i
x * ( i ) last x P ( Γ t ) ; Θ * Θ ( x * ( i ) ) ; l smallest index j for which Θ j * > 0
FOR the ith to the 2nd last x P ( Γ t ) STEP p DO {
   k number of parts of t in x ; Θ ( 0 , , 0 )
  FOR each S W ( Γ t ) \ N DO {
     h t j a S k x b S j
    IF t h + 1 l THEN Θ t h + 1 Θ t h + 1 + 1 ELSE EXIT FOR
    IF Θ l > Θ l * THEN EXIT FOR}
  IF Θ < l e x Θ * THEN x * ( i ) x ; Θ * Θ ; l smallest index j for which Θ j * > 0 }
END FUNCTION
Table 2. Completion of ν ( Γ t ) .
Table 2. Completion of ν ( Γ t ) .
Input:  Directed simple game Γ t (assuming I ( Γ t ) ) and
associated pair ( c , y )
Output:  ν ( Γ t )
PROG COMPL
n | N | ; y 1 y ; ν ( Γ t ) { y 1 }
i n + 1 ; m 1
WHILE i > 2 DO {
   j i 1 ; i j
  WHILE i > 1 and c i 1 = c j DO { i i 1 }
  IF y i > y j THEN {
   l 0
  FOR each b B ( i , j ) DO {
    FOR k = 1 TO m DO {
       l l + 1 ; y l ( y 1 k , , y i 1 k , b , y j + 1 k , , y n k ) } }
   m l ; ν ( Γ t ) { y 1 , , y m } } }
END PROG
Back to TopTop