Department of Economics, University of Fribourg, 1700 Fribourg, Switzerland
Received: 16 November 2016 / Accepted: 7 February 2017 / Published: 28 February 2017
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.
integer nucleolus; integer prenucleolus; desirability relation; simple games
C63; C71; D72
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 , p. 1163). A cooperative TU game is a pair , henceforth called a game, with a finite set of players and a coalition function , . For every payoff vector and coalition , let . If , , we denote the excess of coalition S at by . This way, we can associate with each the vector of all excesses , arranged in nonincreasing magnitude. The nucleolus of Γ with respect to a set X of feasible payoff vectors is the set of payoff vectors which minimize lexicographically over X (cf. Schmeidler ), as if they were the outcome of an egalitarian arbitration among player coalitions (cf. Maschler , p. 611). Our choice for X will be the integer imputation set , under the condition that . Thus, we assume that the players face an integer resource allocation problem in that comes in discrete units that cannot be broken apart. We call 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 , Krohn and Sudhölter , Kurz et al. ). In Wolff and Karagök , the integer nucleolus is used to analyze the apportionment of ministries in the Swiss parliament. Fragnelli and Gastaldi  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 et al. . 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 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  (p. 615) that is implemented in most of the studies compiled by Leng and Parlar  (p. 669):
where , while , , is the set of coalitions with excess for each optimal solution to (cf. Guajardo and Jörnsten  and Nguyen and Thomas ). For some , eventually , in which case is solved by the set of pairs with . 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 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  for literature references).
A simple game with is a monotonic game Γ, whereby if , that satisfies for each , while . We denote by the set of winning coalitions of . A simple game is called an ordered (or complete or linear) simple game, if it exhibits a complete desirability relation on the players in the set N. It is called a directed simple game, if in addition , without loss of generality. Given a game Γ, if for two players , then player i is said to be more desirable than player j, in which case
Player i is said to be strictly more desirable than player j, denoted by , if , while not . The players are called symmetric—denoted by —if both and (cf. Maschler and Peleg , 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  and Aziz , Ch. 3). It may also be rooted naturally in the setup of the game. For example, consider a simple game that is a weighted majority game with a quota and the weights of the players, where . Here, . Hence, for two players whenever . We shall represent such a game by the tuple , in brief , where . Note that the desirability relation of an ordered simple game is strictly preserved by the counting vector , where (cf. Lapidot [18,19]). Note also that the integer nucleolus of any game Γ is nonempty and finite whenever . A characterization of 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
We begin with two general properties of the integer nucleolus:
Let Γ be a game. If for two players , then for each .
Take any . Suppose , noting that by definition of . Assume , so for every by definition. In particular, , and thus .
Observe that for each . Since by assumption, there exists a coalition such that , implying .
Hence, a reallocation at 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 and , then . ☐
Let Γ be a game. If for two players , then for each .
Take any . Without loss of generality, suppose , noting again that by definition of . Assume , so for every by definition. In particular, , and thus . At the same time, for each . Consequently, a reallocation at of one unit of payoff from player j to player i yields an integer imputation that improves θ, a contradiction. Therefore, if and , then . ☐
Let Γ be a game, where for two players . If for , and payoff vector differs from only in that the payoffs of players i and j are permuted, then by the anonymity (impartiality) of .
The following lemma and a subsequent corollary are our main theoretical result:
The integer nucleolus of a directed simple game with has a unique element, henceforth denoted by , that weakly preserves ; i.e., .
By definition of a directed game, . Then, because of Lemmas 1 and 2, Remark 1, and the nonemptiness of , a payoff vector like exists. To prove its uniqueness, suppose for that and . Denote by i the largest index j for which . Hence, for . Without loss of generality, suppose Note that if and only if :
; i.e., . Assume . Then, if and only if , in which case also . Now consider any coalition , , with . If , then , and thus for every player . Since for each such player, and hence . If , then , and thus , for every , whereby also . However, as , we conclude that .
Next, assume . Observe for any coalition , , with that . Hence, . Consequently, as , again . In all, .
, whereby since . In particular, , as . Hence, , and therefore , a contradiction.
To summarize, it cannot be true that , , and . ☐
The proof of Lemma 3 does not depend on the assumed monotonicity of simple games, and the desirability relation was not needed to show the uniqueness of . 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 .1
A permutation π of the player set N of a game Γ such that for each is called a symmetry of Γ. Because of Lemma 3 and Remark 1:
The integer nucleolus of a directed simple game with is the set of images of under all symmetries of .
We close this section with three examples and a remark:
Let be represented by . Then, . Additionally, ; i.e., and . Since , and , we obtain a set of six payoff vectors. We provide them in anti-lexicographic order:
Let (the non-proper game) be represented by . Then, , while . Hence, .
Consider the game Γ where and , , , , . Note that , whereas . Lemma 3 and Corollary 1 thus cannot be generalized to every directed game Γ.
In Example 2, player 6 is a null player, yet . In general, let Γ be a game, and write as the set of null players of Γ. Suppose and for . Since , there exists a coalition , such that , whereby for all , . So, a reallocation at of one unit of payoff from player i to a player improves θ. Hence, for each and every .
3. An Algorithm to Compute
Given a directed simple game , denote by the subvector of θ associated with the coalitions in , and by the subset of integer imputations in anti-lexicographic order that satisfy Lemmas 1 and 2. Let . Write as the set of veto players of , and let . If , then , because is directed.
Let be a directed simple game with . If , then .
Assume , and note that due to . Hence, . In particular, . Now suppose , whereby for each . Since for any two players , only one element of the set assigns the payoff t to coalition , this element being
where denotes the largest integer that does not exceed , and . Thus, .
Next, suppose ; i.e., . Take any , , and denote by i the largest index j such that . Accordingly, for all . Without loss of generality, assume . As , there exists a coalition , , and hence by the monotonicity of . Consequently, . This excess may be obtained at only by winning coalitions with , but then also at . Since , we obtain , and so .2 ☐
The borderline case of a directed simple game with implies that , and thereby , as well as because of the symmetry of all players. The associated payoff vector is determined by (3) for .
Thus, if is a directed simple game and , we may search for without reference to the coalitions not contained in . In view of this observation, we now suggest an algorithm to compute the integer nucleolus of any such game. Since the elements of have independent excess vectors , our algorithm can make the most of computing machinery that supports the parallel execution of multiple threads in an application program. Note for each with , , that is a partition of t into k () 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ć  (pp. 325–326).
To proceed, define the incidence vector of any coalition in that if and only if , and consider the auxiliary vector , where
Hence, if and , , then players in coalition S receive a positive payoff. These players can be read off the auxiliary vector , where
The total payoff of coalition S at thus amounts to . For example, if and , we obtain , , and . Thereby, if and —noting that results from a partition of t into four parts—.
For each , let with , and attach to the auxiliary vector , where
This way, holds the number of occurrences of excesses of a size at , top-down from the largest excess t to the smallest excess 0 of the coalitions in the set . Thereby, given any two payoff vectors , is preferred to if and only if . While calculating and counting excesses hand in hand, we may be able to tell quite early how compares to a current best status quo, say . Let , and suppose l is the first index i for which . Then, payoff vector can already be discarded if any of the first entries of has been detected to take a positive value or once is known to exceed .
This observation has been built into the computer pseudocode in Table 1. The code distributes most of the workload across a user-defined number 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 is small). On input, and p are passed to the main program LEXMIN that at first generates both n and t as well as the counting vector , the set , and the pairs , . Then, it allocates memory for an array of p best status-quo payoff vectors, before invoking the thread functions . Each of them refers to a separate piece of code, such as the code for thread function . This function initializes , , 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 , starting from element number i. For each resulting payoff vector and underlying number k of parts of t, the inner loop computes the excesses associated with and populates . If in the course of these operations index comes out less than l, or is exceeded, then will be discarded by a subsequent exit instruction. In the remaining cases, whenever is lexicographically smaller than , the elements of the set are updated. Once all threads are completed, LEXMIN minimizes Θ lexicographically over the set of retained payoff vectors in order to obtain the unique argument , and then the pair is returned. Note that all relevant variables are considered as local to LEXMIN and its thread functions unless stated otherwise.
A payoff vector can already be discarded if is seen to be no smaller than , while is known to be greater than , etc. This may serve to reject more quickly, while the extra comparisons can have the opposite effect.
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 , at the cost of an extended bookkeeping.
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  and Aziz , Ch. 3, for the complexity of detecting player types).
The coalitions have independent pairs , which suggests a distributed execution of the second loop in LEXMIN.
Once is known, we conduct a scan of the counting vector for all subvectors , where and , the range being as large as possible. If no such subvector exists, then , and we are done. Otherwise, given whichever pair of matching indices, we retain all elements of obtained earlier, as well as every payoff vector that can be derived from these elements by permuting the payoffs of the players .
The pseudocode program COMPL in Table 2 generates a corresponding sequence of approximations to . On input, and the pair are passed. To begin with, the program determines n and initializes . Then, starting from , the program looks for the smallest for which both and .3 Whenever a matching i is found, the program retrieves all permutations of the payoffs in from the respective permutation set, named , and updates . In the following iteration, j is set to , and so on. The search ends if , and then is returned. Note that for each matching pair the respective subvector of takes the form , where . The set can thus be calculated with ACM Algorithm 152 (Nexcom) by Hopley , under the normalization .
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 :
Let be represented by . In this game,
Thereby, ; i.e., the game exhibits the desirability relation . Hence,
The sole thread then proceeds as follows if the elements of arrive at the thread’s inner loop in the above order from coalition to coalition :
Upon initialization, , whereby , such that and . The first payoff vector in the (ordered) set will be discarded as soon as has calculated the excess of coalition , since , and thus , etc. Eventually, can be improved at , where , and again at , where . The latter payoff vector is finally identified as by the main program LEXMIN, and the pair is returned. At last, routine COMPL finds in view of that there is no matching pair . Therefore, on output, .
For a generalized simple game , the monotonicity property is dropped, and it is not maintained that and (cf. Carreras and Freixas , p. 153, and Taylor and Zwicker , p. 4). The desirability relation of a directed generalized simple game is also strictly preserved by the counting vector . However, may have to be redefined as denoting the set . 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:
Let be a directed generalized simple game with . Suppose , . Denote by i the largest index j for which , where without loss of generality. Then .
Assume , whereby , since is directed and . Hence, for each player . Since , it cannot be true that both and are contained in . So, assume . Consider any nonempty coalition , . Observe that whenever . Consequently, if or , and thus , then . Furthermore, if , and hence again , then also . Therefore, and since , if , then . ☐
Hence, if for two payoff vectors , 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 . In a worst-case scenario, if while there are no symmetric players, then (cf. Hall , p. 44) for the asymptotic total number of payoff vectors that have to be considered. In another worst-case scenario, every coalition , , is winning, and the inner loop of each thread function then executes times altogether.
The algorithm has been applied on two personal computers to solve several samples of weighted majority games , where is an odd sum of integer weights, and . The weights have been drawn from the interval at random, in terms of uniform deviates as supplied by a system routine. The chosen order of the coalitions 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 . The algorithm’s run-times were measured as the elapsed time when computing the solution of a given game from the pair and the set . 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, , whereas 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, , while in the second. The average run-times were about two seconds (first sample) and about ten seconds (second sample). In comparison, the Gurobi(TM)  linear-programming tool (version 6.5.0, with default settings) needed between about 4 and 35 min, with an average of about 20 min, to complete only the first linear program of procedure (1) on machine 2 for the ten games where . 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 admits two or more winning single-player coalitions, then . In such a case—or when the individual rationality of the game solution is not an issue—we may refer to the integer prenucleolus , where is the game’s integer preimputation set with . Note that is nonempty and finite.
Let be a simple game. If , then for all .
Take any and let . Observe that , whereby . Then, consider an arbitrary player :
Assume . Hence, . Let and consider any coalition , whereby . Since is monotonic, , and hence there must be a player , . Now take any coalition . Suppose , such that . Since , a reallocation at of one unit of payoff from player k to player i improves θ, and therefore . Next, suppose . Observe that by the monotonicity of , and that by definition of the set . Consequently, . As , we conclude that θ can still be improved at by a reallocation of one unit of payoff from player k to player i. Thus again , a contradiction.
Assume . Hence, due to . Take any player , and let . Thereby, . Moreover, let . Since none of the T-type coalitions can receive an aggregate payoff smaller than , we have . So, . Therefore, a reallocation at of one unit of payoff from player i to player k improves θ, which means that , also a contradiction.
In all, it cannot be true that and or for some . ☐
Let be a generalized simple game. If , then for all .
Take any . Note that part (b) of the proof of Lemma 6 does not depend on the monotonicity of or on the convention that . With being redefined as denoting the set , the assumption that is also not needed. Hence, . Now assume . It then follows from that there must be a player with . Letting and , we conclude—analogous to part (b) of the proof of Lemma 6—that . Consequently, a reallocation at of one unit of payoff from player k to player i improves θ, which contradicts the assumption that . Therefore, if , then . ☐
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:
Let Γ be a game, and suppose . If for two players , then . If , then .
Let Γ be a game. If is a payoff vector that differs from only in that the payoffs of two symmetric players are permuted, then , analogous to Remark 1.
We end our discussion of the integer prenucleolus with a few examples and clarifying remarks:
Let be represented by . In this game, . Its integer prenucleolus is composed of all integer preimputations—except for —that satisfy Lemmas 6 and 8: . Note that player 4 is a null player.
Let be represented by . This is a game without null players, and . We get .
Let be the directed generalized simple game where and . In this game, . At the same time, e.g., , and hence the game is not monotonic. We find that and .
Observe for the game in Example 5 that has two elements that weakly preserve . Hence, Lemma 3 and Corollary 1 do not carry over to the integer prenucleolus.
Note for the game in Example 6 that . Thus, in contrast to the continuous case, although for all .
If negative payoffs are infeasible for a simple game with , we may resort to the integer pseudo-nucleolus as an auxiliary solution concept, where and . The set 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 , noting that the players in the set are symmetric and that for all , , due to the monotonicity of . We also leave it to the reader to extend the algorithm in Section 3 to the computation of for directed simple games . An extended algorithm will admit negative payoffs of some of the players and allow for multiple optimal payoff vectors that weakly preserve .
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  (p. 27). This game has two minimum-sum integer representations, where the quota is 99 and the weight vectors are and, respectively, . 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 has the two representations and . We obtain , and .
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.
Schmeidler, D. The Nucleolus of a Characteristic Function Game. SIAM J. Appl. Math.1969, 17, 1163–1170. [Google Scholar] [CrossRef]
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]
Peleg, B. On Weights of Constant-Sum Majority Games. SIAM J. Appl. Math.1968, 16, 527–532. [Google Scholar] [CrossRef]
Krohn, I.; Sudhölter, P. Directed and Weighted Majority Games. Math. Methods Oper. Res.1995, 42, 189–216. [Google Scholar] [CrossRef]
Kurz, S.; Napel, S.; Nohn, A. The Nucleolus of Large Majority Games. Econ. Lett.2014, 123, 139–143. [Google Scholar] [CrossRef]
Wolff, R.; Karagök, Y. Consistent Allocation of Cabinet Seats: The Swiss Magic Formula. Public Choice2012, 150, 547–559. [Google Scholar] [CrossRef]
Fragnelli, V.; Gastaldi, F. Remarks on the Integer Talmud Solution for Integer Bankruptcy Problems. TOP2016. [Google Scholar] [CrossRef]
Fragnelli, V.; Gagliardo, S.; Gastaldi, F. Integer Solutions to Bankruptcy Problems with Non-Integer Claims. TOP2014, 22, 892–933. [Google Scholar] [CrossRef]
Fragnelli, V.; Gagliardo, S.; Gastaldi, F. Bankruptcy Problems with Non-Integer Claims: Definition and Characterizations of the ICEA Solution. TOP2016, 24, 88–130. [Google Scholar] [CrossRef]
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]
Guajardo, M.; Jörnsten, K. Common Mistakes in Computing the Nucleolus. Eur. J. Oper. Res.2015, 241, 931–935. [Google Scholar] [CrossRef]
Nguyen, T.-D.; Thomas, L. Finding the Nucleoli of Large Cooperative Games. Eur. J. Oper. Res.2016, 248, 1078–1092. [Google Scholar] [CrossRef]
Taylor, A.; Zwicker, W. Simple Games: Desirability Relations, Trading, Pseudoweightings; Princeton University Press: Princeton, NJ, USA, 1999. [Google Scholar]
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]
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]
Aziz, H. Algorithmic and Complexity Aspects of Simple Coalitional Games. Ph.D. Thesis, University of Warwick, Warwick, UK, 2009. [Google Scholar]
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]
Lapidot, E. The Counting Vector of a Simple Game. Proc. Am. Math. Soc.1972, 31, 228–231. [Google Scholar] [CrossRef]
Zoghbi, A.; Stojmenović, I. Fast Algorithms for Generating Integer Partitions. Int. J. Comput. Math.1998, 70, 319–332. [Google Scholar]
Hall, M., Jr. Combinatorial Theory, 2nd ed.; Wiley: New York, NY, USA, 1986. [Google Scholar]
Gurobi Optimization, Inc. Gurobi(TM) Optimizer, Version 6.5.0; Gurobi Optimization, Inc.: Houston, TX, USA, 2015. [Google Scholar]
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 , the set contains at most one element with , whenever for all . We add that it also suffices to impose the weaker condition that .
3As to the inner WHILE/DO loop in Table 2, we assume short-circuit evaluation of relational expressions. This means that the expression ’ and ’ is marked to be false as soon as . Hence, no attempt will be made to access a nonexistent .
Lexicographic minimization of over .
Lexicographic minimization of over .
Input: Directed simple game (assuming ), p Output: