Compilation complexity

Compilation complexity is the smallest number of bits required to summarize a input to a function, such that the output of the function can be computed correctly. The notion was particulatly studied in voting theory. Often, a group has to accept a decision, but some of the voters have not arrived yet. It is desired to take the votes of the present voters and summarize them such that, when the other voters arrive, we can determine the winner. The compilation complexity of a voting-rule is the smallest number of bits required for the summary.

An important advantage of low compilation complexity is that it makes it easier to verify voting outcomes. For example, suppose an elections are held in a country of 1,000,000 people, divided into 1000 voting-stations of 1000 voters each. Low compilation complexity lets us summarize the outcome in each voting-station separately, which is relatively easy to verify by double-counting by representatives of the parties. Then, every citizen can verify the final outcome by summing the results from the 1000 voting stations. This verifiability is important so that the public trusts and accepts the voting rule.

Compilation complexity of single-winner voting rules

Chevaleyre, Lang, Maudet and Ravilli-Abadie analyze the compilation complexity of some common single-winner voting rules based on ordinal ballots. The analysis is based on the notion of equivalence of partial profiles.

Equivalence of partial profiles

Suppose there are n voters, of which only m<n have voted. The votes of these m voters are called a partial profile. Given a voting rule r, two partial profiles P and Q on m voters are called r-equivalent if, for any partial profile R, the rule winner on the complete profile P u R is equal to the rule winner on the complete profile Q u R.

The relation "r-equivalent" is obviously an equivalence relation, so it partitions the set of profiles on m voters to equivalence classes. We denote by eq(r,m,p) the number of equivalence classes when the voting-rule is r, the number of voters already voted is m, and the number of candidates is p. The compilation complexity of any rule is the logarithm of the number of equivalence classes, that is,$\lceil \log(eq(r,m,p))\rceil$.

Maximum and minimum compilation complexity

The number of equivalence classes for any rule is in $O(\min \left({(p!)}^{m},m^{(p!)}\right))$. Therefore, the maximum compilation complexity of any voting rule is in $\min \left(m\cdot \log {p!},~p!\cdot \log {m}\right)$. But there are rules with a much smaller compilation complexity. For example, if there is a sure winner, then the number of equivalence classes is p (the number of possible winners), so the compilation complexity is $\log {p}$.

Plurality voting

In plurality voting, any partial profile can be summarized by recording the plurality score of each candidate - the number of times each candidate appears first. Since this number is at most m, the compilation complexity is in $O(p\log {m})$.

Another bound can be attained by counting equivalence classes: the equivalence classes correspond to all vectors of p integers with sum m. Taking the logarithm gives $\Theta (p\log {(1+m/p)}+m\log(1+p/m))$ which is in $O(m+p)$.

Borda voting

In Borda voting, any partial profile can be summarized by recording the Borda score of each candidate. Since the Borda score is at most m(p-1), the compilation complexity is at most $(p-1)\cdot \log {(m(p-1))}$, and there is a matching lower bound, so the complexity is in $\Theta (p\log {mp})$.

Voting rules based on weighted majority graph

The weighted majority graph of a voter profile is a directed graph in which the nodes are the candidates, and there is a directed edge from x to y iff a majority of voters prefer x to y. The weight of this edge is the number of voters who prefer x to y. Many rules are based only on the majority graph; the number of equivalence classes of such rules is at most the number of possible weighted majority graphs. This number is denoted by T(m,p) - the number of weighted tournaments on p vertices that can be obtained from m voters. Therefore, the comiplation complexity is at most log(T(m,p)). This complexity is tight for Condorcet-consistent rules, such as: Copeland, Simpson (maximin), Slater, Banks, uncovered set, Schwartz. An upper bound on log(T(m,p)) is ${\frac {p(p-1)}{2}}\log(m+1)$, since it is sufficient to keep, for each pair of candidates x,y, the number of voters who prefer x to y, and this number is between 0 and m. The bound is not tight, but it is asymptotically tight; $\Theta (p^{2}\log {m})$.

Voting rules with runoff

The compilation complexity of two-round voting (plurality with runoff) is in $\Theta (p^{2}\log {m})$.

The compilation complexity of Single transferable vote is in $O\left(p2^{p}\log(1+{\frac {m}{2^{p}}})+mp\log(1+{\frac {2^{p}}{m}})\right)$.

Topics

• Compilation complexity of common voting rules
• Compilation complexity of multiwinner rules

Related problems

• Knowledge compilation - compiling a part of the input offline, such that the when the online input arrives, the output can be computed quickly. Here, the goal of the compilation is to save time, rather than to save space.
• Complexity of vote elicitation - given a voting rule, a set of known votes and a set of new voters, is the outcome of the vote already determined from the known votes? Clearly, if the outcome is already determined, then the compilation complexity is very small: we just have to keep this outcome.
• Computation of possible and necessary winners - given a voting rule, a set of incomplete votes (partial orders on the set of candidates), who are the candidates who can still possibly win the election, and is there a candidate who surely wins it? Clearly, if there is a sure winner, then the compilation complexity is very small: we just have to keep the identity of this sure winner.
• Communication complexity - given a voting rule and a set of voters, what is the worst-case number of bits transmitted by the best protocol allowing to compute the outcome of the election? Compilation complexity can be seen as one-round communication complexity.