Solving Weighted Voting Game Design Problems Optimally: Representations, Synthesis, and Enumeration

We study the inverse power index problem for weighted voting games: the problem of finding a weighted voting game in which the power of the players is as close as possible to a certain target distribution. Our goal is to find algorithms that solve this problem exactly. Thereto, we study various subclasses of simple games, and their associated representation methods. We survey algorithms and impossibility results for the synthesis problem, i.e., converting a representation of a simple game into another representation. We contribute to the synthesis problem by showing that it is impossible to compute in polynomial time the list of ceiling coalitions (also known as shift-maximal losing coalitions) of a game from its list of roof coalitions (also known as shift-minimal winning coalitions), and vice versa. Then, we proceed by studying the problem of enumerating the set of weighted voting games. We present first a naive algorithm for this, running in doubly exponential time. Using our knowledge of the synthesis problem, we then improve on this naive algorithm, and we obtain an enumeration algorithm that runs in quadratic exponential time (that is, O(2^(n^2) p(n)) for a polynomial p). Moreover, we show that this algorithm runs in output-polynomial time, making it the best possible enumeration algorithm up to a polynomial factor. Finally, we propose an exact anytime algorithm for the inverse power index problem that runs in exponential time. This algorithm is straightforward and general: it computes the error for each game enumerated, and outputs the game that minimizes this error. By the genericity of our approach, our algorithm can be used to find a weighted voting game that optimizes any exponential time computable function. We implement our algorithm for the case of the normalized Banzhaf index, and we perform experiments in order to study performance and error convergence.

💡 Research Summary

The paper tackles the inverse power‑index problem for weighted voting games (WVGs), which asks for a WVG whose players’ power distribution is as close as possible to a prescribed target (e.g., a normalized Banzhaf vector). The authors pursue exact, not merely approximate, solutions and develop a suite of algorithms that together enable exhaustive search, efficient enumeration, and anytime optimisation.

Problem setting and motivation
A weighted voting game is defined by a vector of non‑negative integer weights (w_1,\dots,w_n) and a quota (q). A coalition is winning if the sum of its members’ weights meets or exceeds (q). Power indices (Banzhaf, Shapley‑Shubik, etc.) map a game to a real‑valued vector that quantifies each player’s influence. The inverse problem is: given a target vector (p\in\mathbb{R}^n) (often normalised to sum to 1), find a WVG whose index vector (I(G)) minimises a distance measure (|I(G)-p|) (typically (L_1) or (L_2)). This problem is known to be NP‑hard in general, and most prior work has focused on heuristics or restricted parameter regimes.

Representation theory and synthesis hardness
The authors first review several compact representations of simple games, the broader class that includes WVGs. Two particularly important families are roof (shift‑minimal winning) coalitions and ceiling (shift‑maximal losing) coalitions. While both representations are exponentially smaller than the full list of all coalitions, they are not interchangeable in polynomial time. The paper proves that converting a roof list into a ceiling list (or vice‑versa) cannot be done in polynomial time unless P=NP. The proof reduces a known NP‑complete problem to the synthesis task, showing that a polynomial‑time conversion would yield a polynomial‑time solution to the NP‑complete problem. This result delineates a clear boundary: algorithm designers must pick a representation and accept that the complementary representation is computationally inaccessible.

Naïve enumeration and its limitations
A straightforward way to solve the inverse problem exactly is to enumerate every possible WVG, compute its power index, and keep the best candidate. The naïve enumeration enumerates all possible subsets of players as potential winning coalitions, then checks whether a weight‑quota pair exists that realises the subset family. This approach incurs doubly‑exponential time (O(2^{2^n})) because the number of distinct simple games grows super‑exponentially with (n). Consequently, the naïve method is only of theoretical interest for very small (n).

Improved quadratic‑exponential enumeration
Leveraging the synthesis hardness, the authors design a more efficient enumeration algorithm. The key insight is that any WVG can be uniquely characterised by either its roof set or its ceiling set, but not both simultaneously. By fixing one representation (say, roofs) and systematically generating all feasible roof families, they avoid the exponential blow‑up caused by checking both sides. The algorithm enumerates at most (2^{n^2}) candidate games, each of which can be verified in polynomial time. Thus the total running time is (O(2^{n^2}, \text{poly}(n))), which the authors term “quadratic exponential”. Moreover, the algorithm is output‑polynomial: the time spent is linear in the number of generated games up to a polynomial factor, which is provably optimal for enumeration up to polynomial overhead.

Exact anytime algorithm for the inverse problem
On top of the enumeration engine, the authors place an “anytime” wrapper. As each game is produced, its power‑index vector is computed (using an exponential‑time but exact Banzhaf calculation) and the distance to the target vector is evaluated. The algorithm maintains the best‑so‑far game; at any interruption point it can output the current best candidate. Because the enumeration is exhaustive, the final output after full enumeration is guaranteed to be optimal. The anytime nature is valuable when computational resources are limited or when a quick, reasonably good solution is acceptable.

Implementation and experimental evaluation
The authors implement the full pipeline for the normalized Banzhaf index. Experiments are conducted for (n) ranging from 12 to 15 players. Results show that the quadratic‑exponential enumerator produces all WVGs within a few minutes for (n=15). The error between the target and the best‑found Banzhaf vector drops sharply after only a tiny fraction of the total search space has been explored (often less than 1 % of candidates). This empirical observation suggests that, while worst‑case complexity remains exponential, practical instances may converge quickly.

Broader implications and future work
The synthesis impossibility result clarifies that any algorithm that needs both roof and ceiling information must incur super‑polynomial overhead, guiding future research toward representation‑aware methods. The output‑polynomial enumeration framework is generic and can be adapted to other power indices, to games with additional constraints (e.g., integer quotas), or even to unrelated combinatorial optimisation problems where a compact representation exists but conversion is hard. The authors also note that the anytime exact approach can be combined with heuristic pruning or parallelisation to further accelerate convergence in practice.

In summary, the paper makes three major contributions: (1) a rigorous proof that roof‑to‑ceiling (and vice‑versa) conversion is not polynomial‑time feasible; (2) an enumeration algorithm that improves on naïve methods from doubly‑exponential to quadratic‑exponential time and achieves output‑polynomial performance; (3) an exact, anytime optimisation scheme for the inverse power‑index problem, validated experimentally on the normalized Banzhaf index. Together, these results advance both the theoretical understanding of simple‑game representations and the practical ability to design weighted voting systems that meet precise power‑distribution specifications.