On the Construction of High Dimensional Simple Games

Voting is a commonly applied method for the aggregation of the preferences of multiple agents into a joint decision. If preferences are binary, i.e., "yes" and "no", every voting system can be described by a (monotone) Boolean function <i>\chi\colon\{0,1\}^n\rightarrow \{0,1\}</i>. However, its naive encoding needs <i>2^n</i> bits. The subclass of threshold functions, which is sufficient for homogeneous agents, allows a more succinct representation using <i>n</i> weights and one threshold. For heterogeneous agents one can represent <i>\chi</i> as an intersection of <i>k</i> threshold functions. Taylor and Zwicker have constructed a sequence of examples requiring <i>k\ge 2^{\frac{n}{2}-1}</i> and provided a construction guaranteeing <i>k\le {n\choose {\lfloor n/2\rfloor}}\in 2^{n-o(n)}</i>. The magnitude of the worst case situation was thought to be determined by Elkind et al.~in 2008, but the analysis unfortunately turned out to be wrong. Here we uncover a relation to coding theory that allows the determination of the minimum number for $k$ for a subclass of voting systems. As an application, we give a construction for <i>k\ge 2^{n-o(n)}</i>, i.e., there is no gain from a representation complexity point of view.


Introduction
Consider a set N = {1, . . . , n} of agents whose binary preferences should be aggregated to a group decision. We assume that voting is used as aggregation method, i.e., each agent can say either "yes" or "no", which we encode by 1 and 0, respectively, to a given proposal. The group decision is then an "accept" (1) or "reject" (0). Formally, the used voting system can be modeled as a Boolean function χ : {0, 1} n → {0, 1}. By imposing some, quite natural, additional constraints, we obtain the class of so-called simple games, see Subsection 2.2. They are widely applied and very useful tools for understanding decision making in political and other contexts. One major drawback is that they do not admit an obvious succinct representation. The naive approach, listing the function values of χ, needs 2 n bits. Listing so-called minimal winning coalitions, see Subsection 2.2, also needs 2 n−o(n) items in the worst case.
However, the subclass of threshold functions of monotone Boolean functions or weighted games of simple games, see Subsection 2.2, can be represented by just n integer weights w i , for i ∈ {1, . . . , n}, and an integer threshold/quota q. If a representation as a threshold function/weighted games is possible, at most O(n log n) bits are needed for each integer [16]. In the case of homogeneous agents or players, May's theorem [15] states that we can choose w i = 1 and 1 ≤ q ≤ n, i.e., a very succinct representation is possible. In the case of heterogeneous agents or players there are unfortunately simple games which are not weighted games if n ≥ 4. However, Taylor and Zwicker have constructively shown that each simple game can be represented as the intersection of at most n n/2 ∈ 2 n−o(n) weighted games, where the weights are either 0 or 1 and the quotas are 1, see Subsection 2.2. The smallest number k such that a given simple game Γ can be represented as the intersection of k weighted games is called the dimension of Γ. From a representation complexity point of view, we have the following important questions: How large can the dimension of a simple game be? And how can the corresponding weighted games be constructed?

Related Work
With respect to the first question, Taylor and Zwicker provided a sequence of examples requiring at least k ≥ 2 n 2 −1 weighted games [17]. So, there is a large gap in the knowledge of the magnitude of the worst-case situation, which was thought to be closed by Elkind et al. in 2008, see [4]. Unfortunately, their analysis is flawed, which we will demonstrate in Section 3.
Taylor and Zwicker made the observation that although there are simple games with arbitrarily large dimension, they do not seem to be used in real-world voting systems. At the time of writing [17], the authors were only aware of practical voting systems with a dimension of at least 2. Classical examples of dimension 2 are given by the Amendment of the Canadian constitution [11] and the US federal legislative system [18]. The voting systems of the Legislative Council of Hong Kong and the Council of the European Union under its Treaty of Nice rules have a dimension of exactly three, which was proven in [3,7], respectively. Quite recently, it has been shown that the voting system of the Council of the European Union under its Treaty of Lisbon rules has a dimension between 7 and 13 368 [12]. There, the authors also address the second question by providing heuristic algorithms based on integer linear programming. Besides that, the probably first published general approach for the determination of lower bounds for the dimension of a simple game is presented.
Instead of the intersection, each simple game can also be represented as a finite union of weighted games, which leads to the notion of co-dimension, see e.g. [8]. Allowing arbitrary combinations of unions and intersections results in the concept of a Boolean dimension, which is introduced and studied in [5]. We remark that the voting system of the Council of the European Union under Lisbon rules has a Boolean dimension of exactly three [12]. For the subclass of so-called complete simple or linear games, the dimension was studied in [9].

Our Contribution
We show up a link between the dimension of simple games and coding theory. More precisely, we give a construction of a simple game from an error-correcting code, including the determination of the corresponding exact dimension. Using results on error-correcting codes, we can conclude the existence of simple games whose dimension asymptotically matches the worst-case upper bound 2 n−o(n) of Taylor and Zwicker [17], i.e., we close the gap in the literature that was previously filled by the flawed result of Elkind et al. [4].
We thoroughly discuss the lower bound construction of Taylor and Zwicker, i.e, we determine the corresponding exact dimension. Curiously enough, just the integer weights 0, 1, and 2 are needed for the used weighted games. It turns out that Elkind et al. considered an isomorphic variant of the example of Taylor and Zwicker.

Outline
The remaining part of this paper is structured as follows: In Section 2, we introduce some notation and formally define the considered concepts in the paper. We also state a well-known theoretical upper bound for the dimension. Section 3 shows that the example given by Elkind et al. [4,Theorem 8] is an isomorphic variant of the example given by Taylor and Zwicker [17,Theorem 1.7.5]. The games that form the basis for our results are introduced in Section 4. Finally, Section 5 contains the proofs of high dimension and a theorem that forms the main contribution of the paper.

Preliminaries
We will start by briefly introducing error-correcting codes for readers not familiar with coding theory, see e.g. [2] for a more comprehensive introduction. In the second part of this section, we list the basic notation and definitions of simple games and their dimension. Here we refer the interested reader to [17].

Error-Correcting Codes
The Hamming weight hw(x) of a bit vector x = x 1 x 2 . . . x n ∈ {0, 1} n is the number of 1-bits in x: hw(x) = |{i : x i = 1}|. The Hamming distance d(x, y) between two bit vectors x and y is the number of bit positions, where the bits in x and y are different: Imagine a situation in which a 4 bit message has to be transmitted from a sender to a receiver in a noisy environment, where bits are risking to be flipped during the transmission. By adding extra bits to the message in a clever way, we can recover the original message if a few bits are flipped. One way of doing this is by using the well-known Hamming [8,4] code, where 4 bits are added as illustrated by the following example: The Hamming distance between any two vectors in H is at least 4. This means that we can recover a message if one bit is flipped by locating the only vector in H with Hamming distance 1 to the received message. If two bits are flipped, we can only detect that something bad has happened. This is a so-called single-error correcting and double-error detecting code -a SECDED code.
Let C 8 = H \ {0000 0000, 1111 1111} denote the subset of H consisting of the 14 bit vectors with Hamming weight 4. The code C 8 is referred to as a constant weight code, since all the members of C 8 has the same Hamming weight. We will refer to C 8 several places in the paper.

Simple Games and their Dimension
A simple game Γ = (N, W ) is a pair where N = {1, . . . , n}, for some positive integer n, denotes the set of players or agents and W is a collection of subsets of N , i.e., W ⊆ 2 N , satisfying the following conditions: (2) N ∈ W ; A coalition S is a subset of N . If S ∈ W , then it is called winning; otherwise, it is said to be losing. The relation to a Boolean function χ : {0, 1} n → {0, 1} is given as follows: Let S be the set of coordinates of the input vector x that are equal to 1, i.e., all players that vote "yes". The players in N \S vote "no". If χ(x) = 1, then S is winning; otherwise, it is losing.
Conditions (1) and (2) ensure that the group decision does not contradict the individual preferences in the case of unanimity. The monotonicity condition (3) models the assumption that an enlarged set of supporters should not turn the group decision from an acceptance into rejection, which is quite reasonable. So a simple game Γ corresponds to a monotone Boolean function χ with the extra conditions χ(0) = 0 and χ(1) = 1.
Clearly, a simple game Γ is uniquely characterized by either its set W of winning or its set L of losing coalitions, which may both be as large as 2 n − 1 in general. A first reduction is possible: A coalition S is called minimal winning if it is winning and all of its proper subsets are losing. Similarly, a coalition T is called maximal losing if it is losing and all of its proper supersets are winning. The family consisting of all minimal winning coalitions is denoted by W m and the family of all maximal losing coalitions is denoted by L M . Since no minimal winning coalition is a proper subset of another minimal winning coalition, we can apply Sperner's Lemma, see e.g. [13], to conclude |W m | ≤ n n/2 . Similarly, we conclude L M ≤ n n/2 . A simple game Γ = (N, W ) is weighted if there exists a quota q ∈ R >0 and weights w 1 , w 2 , . . . , w n ∈ R ≥0 such that S ∈ W if and only if i∈S w i ≥ q. We remark that one can require the weights and the quota to be non-negative integers [6]. The intersection (N, W 1 )∩(N, W 2 ) of two simple games is the simple game (N, W 1 ∩ W 2 ). Taylor and Zwicker [17] have shown that any simple game can be written as the intersection of |L M | weighted games Γ T , T ∈ L M , where a coalition S wins in Γ T if S ∩ (N \ T ) = ∅. A weighted representation using weights 0 and 1 is given as follows: A player in N \ T has weight 1 and all other players have weight 0 in the game Γ T that has quota 1.
The dimension d of a simple game Γ is the smallest positive integer such that Γ = To give an intuition of how this upper bound relates to 2 n , we can use the the following double inequality that holds for all even positive integers n [14]: For all odd positive integers n, we can use the equality n n 2 = n−1 n−1 2 2n n+1 and obtain the following inequalities: For a bit vector x = x 1 x 2 . . . x n ∈ {0, 1} n with n bits, we let S x be the coalition where i ∈ S if and only x i = 1. For a coalition S ⊆ N , we define the bit vector x S accordingly. We use the notationx andS for complements for bit vectors and sets, respectively.

The Example of Taylor and Zwicker
Let us reconsider the construction of a simple game with large dimension from [17,Theorem 1.7.5]. To this end, let k be an odd integer, S = {1, . . . , k}, T = {k + 1, . . . , 2k}, and N = S ∪ T . A coalition X ⊆ N is winning iff either |X| ≥ k + 1 or |X| = k and |X ∩ T | ≡ 0 (mod 2). Denote the corresponding simple game by Γ k . The minimal winning coalitions of Γ k are given by W m = and the maximal losing coalitions of Γ k are given by L M = Since k ≡ 1 (mod 2), we have n ≡ 2 (mod 4) for n = 2k = |N | and |W m | = L M = 1 2 · n n/2 , so that the dimension of Γ k is at most 1 2 · n n/2 . We remark that Γ k is self-dual, so that its dimension equals its co-dimension. Theorem 1. For each odd integer k, the dimension of Γ k is given by 2 k−1 .
, where x denotes the negation of a binary vector and xy denotes the concatenation of two binary vectors x and y. We have C = L M , |C| = 2 k−1 , and we remark that the minimum Hamming distance of C is 4 for k > 1.
For the lower bound on the dimension, we refer to [17, Theorem 1.7.5]. 1 For the other direction set C p = x ∈ {0, 1} k : Since |S 1 ∩ S| ≥ 1, we additionally have w 0 (S 1 ) ≥ 1 = q 0 , so that S 1 is winning in v. Now let S 2 be a coalition with |S 2 | = k and |S 2 ∩ S| ≡ 0 (mod 2). If x is the characteristic vector of S 2 ∩ S, then • w x (S 2 ) = hw(x) · 0 + (k − hw(x)) · 1 = k − hw(x) < q x for x = 0; • w x (S 2 ) = 0 < 1 = q x for x = 0, so that S 2 is a losing coalition in v. Let S 3 be a coalition with |S 3 | = k and |S 3 ∩ S| ≡ 1 (mod 2). Since Finally, let S 4 be a coalition of cardinality k − 1. Since k − 1 is even, we have the following two cases: In both cases, it is possible to extend S 4 to a coalition S 5 ∈ L M by adding a player, so that S 4 has to be losing in v. Thus, we have v = Γ k and dim(Γ k ) ≤ 2 k−1 . Now let us restate the example of [4,Theorem 8]: Let k be an odd integer and n = 2k, N = {1, . . . , n}. Consider the simple game where all coalitions of cardinality larger than k are winning and all coalitions of cardinality smaller than k are losing. A coalition X of cardinality k is winning iff the Hamming distance between X and {1, . . . , k} is equivalent to 2 modulo 4. In other words, this means that |X ∩ {1, . . . , k}| is even and |X ∩ {k + 1, . . . , n}| is odd.
Interchanging the first k players with the last k players yields the example of Taylor and Zwicker. Since Theorem 8 in [4] claims that the dimension is at least 2k k /2, there is a contradiction to Theorem 1. The flaw 2 of the corresponding proof happens where it says that if x is the bit vector of a losing coalition and x i = x j , then switching x i and x j results in a bit vector of a winning coalition. An explicit counter example for n = 6 is given by the characteristic vectors 100110 and 010110 which both represent losing coalitions.

From Error Correcting Codes to Simple Games
In this section, we present a generic recipe for constructing the simple games forming the basis for our results. Throughout the paper, we let C ⊆ {0, 1} n denote a set of bit vectors of length n having positive Hamming weight satisfying this condition: For x ∈ C, we define the simple game Γ x with players N = {1, 2, . . . , n} as follows: S wins in Γ x if and only if S ∩ S x = ∅. The simple game Γ C is now defined by Γ C = ∩ x∈C Γ x . In other words, a set S is winning if and only if S is a so-called hitting set for the collection of sets {S x } x∈C .
The error-correcting code C 8 from Example 1 is a set of bit vectors satisfying (5). Another example is the following: Example 2. Let C be defined as follows for n = 8: The Hamming weights of the vectors 0000 1111 and 1100 0000 differ by 2 but their Hamming distance is 6. So (5) holds for these vectors. Coalition {1, 5} is winning in Γ C , since it intersects the sets {5, 6, 7, 8}, {1, 2} and {3, 4, 5, 6}. The bit vector 1000 1000 that corresponds to the set {1, 5} shares at least one 1-bit with all members of C.

A Dimension Lemma
We now prove a lemma explicitly stating the dimension of our games.
Proof. The game Γ x , x ∈ C, is clearly weighted, so the dimension of Γ C is not higher than |C|.
We now assume that the dimension of Γ C is less than |C|. Let L x = N \ S x for x ∈ C. The coalition L x is clearly a losing coalition in Γ C because L x ∩ S x = ∅. Using the pigeonhole principle, we conclude that there are x, y ∈ C with x = y such that L x and L y lose in the same weighted game Γ , where Γ is one of the less than |C| weighted games whose intersection is Γ C .
By considering basic properties for the Hamming distance and the Hamming weight, we observe that (5) also holds if we replace x and y with their complementsx andȳ. If one of the vectorsx orȳ had all 1-bits in the d(x,ȳ) positions, where the two vectors differ, then the left-hand side of (5) would be d(x,ȳ) and (5) would not hold. We therefore conclude that there are players p x ∈ L x \ L y and p y ∈ L y \ L x . We let A and B be the coalitions obtained if L x and L y swap these players: We now show that A and B are winning coalitions in Γ C . Without loss of generality, we consider the coalition A. It is clear that x A and x share a 1-bit so A wins in Γ x . Now let us assume that there is a member z of C \ {x} such that A loses in Γ z . In other words, x A and z do not share a 1-bit. The vector x A is obtained by flipping a 0-bit and a 1-bit in the vectorx: The d(x A ,z) bits shared by x A and z are all 0 in which case we have the following: We now use hw(x A ) = n − hw(x) together with (7): By using d(x, z) = d(x,z) and (6) and (8), we obtain the following inequality: Since (9) contradicts (5), we conclude that A wins in Γ z for any z ∈ C. Consequently, A also wins in Γ C . Summing up, we now have two coalitions L x and L y that lose in Γ , and we can obtain two winning coalitions in Γ C if L x and L y swap two players. These coalitions also win in Γ and we obtain a contradiction, since this would mean that the total weight in Γ of the players in L x and L y has increased.
It is worth noting that the dimension of the game If we can construct games with dimension m using our approach, we can also construct games with dimension m for every m ≤ m as expressed by the following corollary: Corollary 1. Let Γ C be a simple game with n players and dimension m, then there are simple games with n players and dimension m , 1 ≤ m ≤ m.
Proof. Just delete some elements from C.

Simple Games with High Dimension
The key question we will deal with in this section is the following: Can we find families C of bit vectors with high cardinality satisfying (5)? According to Lemma 1, this would automatically give us games with high dimension. From the theory on errorcorrecting codes, we know how to construct relatively large families of bit vectors forming SECDED constant weight codes. If we pick such a code, we clearly have a family C satisfying (5). This observation is the basis for the proofs in this section. As an example, the code C 8 from Example 1 corresponds to a simple game with 8 players and dimension 14.
It is important to stress that constant weight SECDED codes are not the only families satisfying the generic recipe (5) as illustrated by Example 2. There are many other families that satisfy (5), but we will use constant weight SECDED codes to construct our games with high dimension. In other words, there might be families with larger cardinalities compared to constant weight SECDED codes satisfying (5).
Agrell et al. [1] present lower bounds for cardinalities of constant weight SECDED codes. These lower bounds can be directly translated to lower bounds for dimensions for simple games if we use Lemma 1. This allows us to set up Table 1 that compares the dimensions of the games produced using composition of unanimity games [9] with the dimensions of the games based on our approach and the lower bounds from [1]. The first column displays n. The second column presents the dimensions of the games from [9] and [17]. The third column contains the dimensions of the games produced using our approach and constant weight SECDED codes. Finally, the last column shows the, slightly improved, upper bound n n/2 − 1. 3 As an example, we can see that our approach leads to a simple game with dimension 14 for n = 8 -the game Γ C8 .
For n ≥ 8, we have: We now use: .
We now state our main theorem, where we also consider values of n that are not powers of 2.
Proof. Graham and Sloane [10] have shown that there is constant weight SECDED code with Hamming weight w with cardinality at least 1 n n w for any w. For w = n 2 , we get (11) by using Lemma 1. Lemma 1 and Lemma 2 give us (12).
It follows from (2) and (3) that the lower bound presented in Theorem 2 is 2 n−o(n) . Our games are easily seen to be within a factor n from the upper bound from (1). Finally, we point out that the proof of the lower bound in [10] is constructive.

Conclusion
We have presented a link from coding theory to the dimension of simple games. We are not aware of any other connection between coding theory and simple games. While it seems a rather tough problem to determine the exact dimension of a simple game, we have provided an exact formula for those simple games arising from error correcting codes in Lemma 1. Via this connection, any improvement on lower bounds of constant weight codes improves the stated lower bounds for the worst-case dimensions of simple games. For the other direction, it would be interesting to know whether unrestricted codes satisfying inequality (5) have some application in coding theory. Till now, it is even unclear, at least for us, if those codes can be strictly larger than constant weight codes. From our point of view, this connection should be explored in more detail.
The asymptotic magnitude of the worst-case examples with respect to the dimension of simple games is determined, which closes a gap in the literature and uncovers a flaw in a previous attempt. The bad news is that from a representation complexity point of view, the usage of intersections of weighted games cannot be a solution for all cases. From a practical point of view, one may nevertheless ask whether the set of weighted games with small dimension are not too far apart from the set of simple games, so that there is no reason to use high-dimensional simple games in reality.
From a mathematical point of view, it would be interesting to determine the exact values of the worst-case examples.
The construction of the representing weighted games is still widely open and deserves further attention.