Quickly Determining Who Won an Election

We introduce the following problem. Consider an election with voters $1,\dots,n$ who each vote for a single candidate out of $1,\dots,d$. Each voter $i$ chooses each candidate $j$ with known probability $p_{i,j}\in(0,1)$, independently of all other voters. A candidate wins the election if they receive a strict majority of the votes which may be, depending on the model, an absolute or a relative majority. After the votes have been collected, it is possible to count the vote of any voter $i$, taking a known time $c_{i}\geq 0$ (which can also be thought of as cost). The present paper is concerned with the following question: In what order should votes be counted so as to minimize the expected time (or cost) until it is known who won the election? We allow adapting this order along the way.

The above problem is a stochastic function-evaluation problem (for a survey, see [Ünl04]): The votes can be regarded as random variables taking one of $d$ values, and the function maps these variables to the index of the winning candidate or, if no such candidate exists, to $0$. When $d=2$, results on such problems can be applied to our problem. Note that for $d=2$, there is no difference between absolute and relative majority. If $n$ is odd, the problem for $d=2$ is somewhat simpler because function value $0$ is impossible. The function can then be seen as a so-called $k$-of-$n$ function, a Boolean function that is $1$ if and only if at least $k$ of the $n$ variables have value $1$. For these functions, a beautiful optimal strategy due to Salloum, Breuer, and (independently) Ben-Dov is known [SB84, BD81]. In what follows, we refer to this as the SBB strategy. In our setting, it translates to the following: An interchange argument shows that, if it were known a-priori that candidate $j$ is the winner, it would be optimal to inspect votes in increasing order of $c_{i}/p_{i,j}$ ratios. Since the two strategies, for $j\in\{1,2\}$, have to count $\lfloor n/2\rfloor+1$ votes before they have verified the winner, there exists, by the pigeonhole principle, a vote that is contained in both corresponding prefixes. An unconditionally optimal strategy can safely inspect this vote and then recurse on the resulting subinstance. In the case that $d=2$ and $n$ is even, determining who is the winner of the election, or determining that there is no winner because of a tie, is equivalent to determining whether there are precisely $n/2$ votes for both candidates, and an optimal strategy can be derived in a similar way [AJO11, GGHK22].

For our general setting, where $d$ can be greater than 2, we do not expect a similarly clean strategy. For previously studied functions of Boolean variables that are slight extensions of $k$-of-$n$ functions, the stochastic evaluation problem is either known to be NP-hard or no polynomial-time algorithms¹¹1For an algorithm for our problem to run in polynomial time, we require that, in every situation, it can find the next vote to count in time polynomial in the input size. Note that the corresponding decision tree may have exponential size. For an in-depth discussion of such issues, we refer to the survey by Ünlüyurt [Ünl04, Section 4.1]. computing optimal strategies are known. A recent trend in stochastic function evaluation has been to design (polynomial-time) approximation algorithms instead, i.e., algorithms whose expected cost can be bounded with respect to the expected cost of an optimal strategy, preferably by a constant factor [GGN22, GGHK22, GHKL22, PS22, Liu22, DHK16].

The problems considered in this paper have similarities to the stochastic function-evaluation problem for Boolean linear threshold functions. Constant-factor approximation algorithms have been developed for that problem, using two different approaches. The first approach reduces the problem to Stochastic Submodular Cover through the construction of a utility function and solves the problem with an algorithm called Adaptive Dual Greedy  [DHK16]. We show that this approach yields an $O(d)$-approximation for our problems (but it is conceivable that a more nuanced analysis could yield a better approximation factor). The second approach generates a separate strategy for each of the possible values of the function, by solving multiple instances of a constrained maximization problem, and interweaves the resulting strategies together [GGN22]. Applying this approach and current analysis to our problems would involve interweaving at least $d$ separate strategies, leading to (at least) a linear dependence on $d$.

Instead, we develop a two-phase approach, where the first phase reduces the number of relevant candidates to $O(1)$ and the second phase handles the remaining candidates with some of the aforementioned techniques. As we show, this approach yields $O(1)$-approximation algorithms for both the absolute-majority and the relative-majority setting.

A strategy is considered particularly useful in practice if it is non-adaptive (e.g., [GV06, GHKL22, GGN22]), i.e., it considers votes in a pre-specified order until the function is evaluated. For the absolute-majority version, we give an $O(1)$-approximation algorithm with only two rounds of adaptivity. In counting rounds, we use the “permutation” definition: In each round, votes are inspected in an order that is pre-specified for that round, until some stopping condition is reached. This definition is consistent with usage in a number of previous papers (e.g., [AAK19, GGN21]).

For future work, we leave it open whether there are non-adaptive $O(1)$-approximate strategies and, if so, whether they can be computed in polynomial time.

Let $n$ be the number of voters, and $d$ be the number of candidates. We number the voters from $1$ to $n$, and the candidates from $1$ to $d$. We sometimes use $[k]$ to denote the set $\{1,\dots,k\}$.

For $X=(X_{1},\ldots,X_{n})\in\{1,\ldots,d\}^{n}$ we define $N_{j}(X)$ to be the number of entries $X_{i}$ of $X$ that are equal to $j$. The absolute-majority function $f:\{1,\ldots,d\}^{n}\rightarrow\{0,1,\ldots,d\}$ is defined as follows:

Here $f(X)=j$ means $j$ is an absolute-majority winner, meaning $j$ receives more than half the votes, and $f(X)=0$ means there is no absolute-majority winner. The relative-majority function $f:\{1,\dots,d\}^{n}\rightarrow\{0,\dots,d\}$ is as follows:

Similar to the previous function, the output of $f$ is either the winner of the election, or $0$ if there is no winner. Here the winner must receive more votes than any other candidate.

The above two functions are symmetric functions, meaning that the results of the function only depend on the number of $1$’s, …, $d$’s in the input. (This property is called anonymity in social-choice theory.) We assume that the vote of voter $i$ is an independent random variable $X_{i}$, taking a value in the set $\{1,\ldots,d\}$. For each candidate $j$, we use $p_{i,j}$ to denote the probability that $X_{i}=j$. We assume that each $p_{i,j}>0$.

In our vote-inspection problems, we are given as input the $p_{i,j}$ values for each voter $i$ and candidate $j$. For each voter $i$, we are also given a value $c_{i}\geq 0$. The only way to discover the value of $X_{i}$, the vote of voter $i$, is to “inspect” vote $i$, which incurs cost $c_{i}$. (We will sometimes use the phrase “test variable $X_{i}$” instead of “inspect vote $i$”.) In other words, $c_{i}$ is the cost of inspecting the vote of voter $i$. The problem is to determine the optimal (adaptive) order in which to sequentially inspect the votes, so as to minimize the expected total cost of determining the winner of the election.

An assignment $a$ to the $n$ variables $X_{i}$ is a vector $a\in\{1,\ldots,d\}^{n}$, where $a_{i}$ is the value assigned to $x_{i}$. We use assignments to represent the values of the votes of the $n$ voters. A partial assignment is a vector $b\in\{1,\ldots,d,*\}^{n}$, where $b_{i}=*$ indicates that the value of $X_{i}$ has not been determined. In discussing vote inspection strategies, we use a partial assignment $b$ to represent the current state of knowledge regarding the values of the votes inspected so far, with $b_{i}$ equal to the value of voter $i$’s vote if it has been inspected already, and $b_{i}=*$ otherwise. In the same way as for $X$, we use $N_{j}(b)$ to denote the number of entries $i$ of $b$ such that $b_{i}=j$. So $N_{j}(b)$ represents the number of inspected votes that are for candidate $j$.

We describe an adaptive 4-approximation algorithm for the absolute-majority version of our problem. The general idea is as follows. Throughout, we keep a partial assignment $b$ that records the vote values known so far. For each candidate $j$, let $g_{j}(b)$ denote the number of known votes for candidates other than $j$, capped at $\lceil n/2\rceil$. We can rule out $j$ as the absolute-majority winner of the election iff $g_{j}(b)=\lceil n/2\rceil$. The algorithm has two phases. In the first phase, we inspect the votes $i$ in increasing order of their costs $c_{i}$, until there are at most two candidates $j$ who could still get enough votes to win the election. Equivalently, Phase 1 ends when the third-smallest value of $g_{j}(b)$, for all $j$, is $\lceil n/2\rceil$. At this point, if we have enough information to determine the outcome of the election, we are done. Otherwise, for each of the at most two remaining potential winners $j$, we need to determine whether the remaining uninspected votes include enough additional votes for candidate $j$ to make $j$ the absolute-majority winner. (If neither do, then the election has no absolute-majority winner.) We take one of these remaining potential winners, calculate the minimum number $k$ of votes they would need to win, and use the SBB strategy for evaluating $k$-of-$n$ functions to determine whether this candidate is the winner. If not, and if another candidate is still a potential winner, we again use the SBB strategy to check if that candidate is the winner. If not, we know there is no winner. Pseudocode for the algorithm is presented in Algorithm 1 (note that we are more verbose than necessary regarding the output, for readability).

We now prove an approximation bound on the algorithm.

The SBB strategy is a highly adaptive strategy; it is easy to see that Algorithm 1 may require $\Omega(n)$ rounds of adaptivity. Motivated by this, we also sketch a modification of this algorithm such that the new algorithm needs only 3 rounds of adaptivity, but the approximation ratio is increased slightly from 4 to 6. Specifically, we replace Phase 2 which contains the two runs of the SBB strategy. After Phase 1 is completed, if we are still uncertain about the result of the election, we can first evaluate if $\alpha$ is the absolute-majority winner by using the non-adaptive 2-approximation algorithm for evaluating a $k$-of-$n$ function, which was introduced in Gkenosis et al. [GGHK18]. This algorithm performs a modified (cost-sensitive) round robin between two orderings, one in increasing order of $c_{i}/p_{i,\alpha}$, and the other in increasing order of $c_{i}/(1-p_{i,\alpha})$. The modified round robin is due to Allen et al. [AHKÜ17] and we present the pseudocode in Appendix B (as it is used as part of another algorithm). It keeps track of the next vote to be inspected in each ordering, and the total cost incurred so far for each ordering. It computes, for each ordering, the sum of the cost incurred so far, plus the cost of the next test. It performs the next test from the ordering for which this sum is smaller (breaking ties arbitrarily). We call this Phase 2.

Since the problem of evaluating $f$ requires determining whether or not $\alpha$ is the winner, the cost spent in Phase 2 is upper-bounded by twice the expected cost of evaluating the value of $f$. If we know $\alpha$ is not the absolute-majority winner after Phase 2, we start Phase 3 by evaluating if $\beta$ is the winner using the same algorithm in Gkenosis et al. This will again add at most twice the expected cost of evaluating $f$. Clearly, if both $\alpha$ and $\beta$ are not the winner, there is no absolute-majority winner in the election..

We thus have the following theorem.

We note that it is possible to reduce the rounds of adaptivity from 3 to 2 using a modified round-robin applied to 4 different non-adaptive orderings. We give details in Appendix B.

We now turn our attention to the relative-majority version of our problem and present an $8$-approximation algorithm. Similar to our previous approach, we keep a partial assignment $b$ to track the values of inspected votes and also to indicate which vote values are not yet known. To show that a candidate $j$ has more votes than a candidate $k$ is equivalent to showing that

The fact that $N_{*}(b)=n-\sum_{k\in\{1,\dots,d\}}N_{k}(b)$ motivates designing

where $g_{j,k}(b)=n+1$ iff candidate $j$ is guaranteed to have more votes than candidate $k$. Hence, to conclude that $j$ is a relative-majority winner, we must have $g_{j,k}(b)=n+1$ for all $k\in\{1,\dots,d\}\setminus\{j\}$. Our algorithm again has two phases. In Phase 1, we still inspect the votes in increasing order of their costs. We end Phase 1 when there are at most two candidates who can possibly win and let $\alpha,\beta$ denote the two candidates. Then, there are at most three possible results of the election: $\alpha$ wins, $\beta$ wins, or it is a tie. We will first determine if $\alpha$ wins or not. Recall that, if $\alpha$ wins, they must have more votes than $\beta$, which means $g_{\alpha,\beta}(b)$ needs to reach $n+1$ at some point. Since a vote for $\alpha$,$\beta$, or any candidate in $\{1,\dots,d\}\setminus\{\alpha,\beta\}$ contributes $2$, $0$, or $1$ to $g_{\alpha,\beta}$, respectively (until threshold $n+1$ is reached), we can use the Adaptive Dual Greedy algorithm introduced by Deshpande et al. [DHK16] to evaluate whether $g_{\alpha,\beta}(b)$ reaches its threshold value $n+1$. If yes, clearly $\alpha$ is the winner. If not, then we test the remaining variables in increasing order of $c_{i}/(1-p_{i,\alpha})$ until it is certain whether $\beta$ is the winner or there is a tie. As shown below, if all remaining votes are for $\alpha$, then $\alpha$ and $\beta$ are tied, otherwise $\beta$ is the winner. The pseudocode is presented in Algorithm 2 (again, this is slightly more verbose than necessary for readability).

We now give an analysis of the algorithm.

In this paper, we have introduced the problem of quickly determining the winner of an election. We have also given the first constant-factor approximation algorithms for this problem in both the absolute-majority and the relative-majority case. While the approximation guarantees are one-digit numbers, we have no reason to believe that they match some type of approximation hardness. In fact, even NP-hardness remains an open problem. Assuming our problem is NP-hard, proving this is the case might require new techniques. Some stochastic evaluation problems are known to be NP-hard, for example, evaluation of Boolean linear threshold functions (cf. [Ünl04]) and evaluation of $s$-$t$ connectivity in general graphs [FFX⁺17]. However, it is open whether a number of Stochastic Score function evaluation problems, related to our problem, are NP-hard [AJO11, GGHK22, GHKL22]. The question of whether the stochastic evaluation problem for Boolean read-once formulas is NP-hard has been open since the 1970’s (cf. [Ünl04]).

A structural question left open by our work is whether the adaptivity gap of our problem is constant. The strongest lower bound on the adaptivity gap that we are aware of comes from the lower bound of $1.5$ for $k$-of-$n$ functions [PS22]. Extending the corresponding construction, one may try to consider an instance in which there are some votes of negligible cost that determine a forerunner, who can then be proved to be a winner cheaply by an adaptive strategy (by selecting the corresponding votes) but not by a non-adaptive strategy (because it does not know which votes to inspect). The extension is, however, not straightforward. One is restricted to certain distributions of who is the forerunner, and even votes for another candidate make progress on goal functions associated with other candidates.

Many natural extensions and variants of our model are possible, e.g., to other voting systems. A relatively small extension would concern larger target numbers of votes than $n/2$, possibly even candidate-specific ones. Such scenarios can be approached by adding an appropriate number of $0$-cost votes for each candidate (i.e., with probability close enough to $1$) and then using our algorithm for the absolute-majority version. Similarly, one could consider weighted voting systems (with modern applications in liquid democracy or voting in shareholder meetings). Ranked-voting systems could also be investigated.