Complexity of and Algorithms for Borda Manipulation

Voting is a simple mechanism to combine preferences in multi-agent systems. Unfortunately, results like those of Gibbrard-Sattertwhaite prove that most voting rules are manipulable. That is, it may pay for agents to mis-report their preferences. One appealing escape from manipulation is computational complexity (?). Whilst a manipulation may exist, perhaps it is computationally too difficult to find? Unfortunately, few voting rules in common use are NP-hard to manipulate with the addition of weights to votes. The small set of voting rules that are NP-hard to manipulate with unweighted votes includes single transferable voting, 2nd order Copeland, ranked pairs (all with a single manipulator), and maximin (with two manipulators) (?; ?; ?).

Borda is probably the only commonly used voting rule where the computational complexity of unweighted manipulation remains open. ? (?) observe that:

“The exact complexity of the problem [manipulation by a coalition with unweighted votes] is now known with respect to almost all of the prominent voting rules, with the glaring exception of Borda”

It is known that computing a manipulation of Borda is NP-hard when votes are weighted (?), and polynomial when votes are unweighted and there is just a single manipulator (?). With a coalition of manipulators and unweighted votes, it has been conjectured that the problem is NP-hard (?).

One of our most important contributions is to close this question. We prove that computing a manipulation of Borda with just two manipulators is NP-hard. As a consequence, we treat computing a manipulation as an approximation problem in which we try to minimize the number of manipulators required. We propose two new approximation methods. These methods are based on intuitions from bin packing and multiprocessor scheduling. Experiments show that these methods significantly outperform the previous best known approximation method. They find optimal manipulations in the vast majority of the randomly generated elections tested.

The Borda rule is a scoring rule proposed by Jean-Charles de Borda in 1770. Each voter ranks the $m$ candidates. A candidate receives a score of $m-k$ for appearing in $k^{th}$ place. The candidate with the highest aggregated score wins the election. As is common in the literature, we will break ties in favour of the coalition of the manipulators. The Borda rule is used in parliamentary elections in Slovenia and, in modified form, in elections within the Pacific Island states of Kiribati and Nauru. The Borda rule or modifications of it are also used by many organizations and competitions including the Robocup autonomous robot soccer competition, the X.Org Foundation, the Eurovision song contest, anf in the election of the Most Valuable Player in major league baseball. The Borda rule has many good features. For instance, it never elects the Condorcet loser (a candidate that loses to all others in a majority of head to head elections). However, it may not elect the Condorcet winner (a candidate that beats all others in a majority of head to head elections).

We will number candidates from 1 to $m$. We suppose a coalition of $n$ agents are collectively trying to manipulate a Borda election to ensure a preferred candidate $d$ wins. We let $s(i)$ be the score candidate $i$ receives from the votes cast so far. A score vector $\langle s(1),\ldots,s(m)\rangle$ gives the scores of the candidates from a set of votes. Given a set of votes, we define the gap of candidate $i$ as $g(i)=s(d)+n(m-1)-s(i)$. For $d$ to win, we need additional votes that add a score to candidate $i$ which is less than or equal to $g(i)$. Note that if $g(i)$ is negative for any $i$, then $d$ cannot win and manipulation is impossible.

Our NP-hardness proof uses a reduction from a specialized permutation problem that is strongly NP-complete (?).

One of our main contributions is to prove that computing a manipulation of the Borda rule is NP-hard, settling an open problem in computational social choice.

The unweighted coalition manipulation problem (UCM) is to decide if there exist votes for a coalition of unweighted manipulators so that a given candidate wins. As in (?), we suppose that the manipulators have complete knowledge about the scores given to the candidates from the votes of the non-manipulators.

To show NP-hardness, we reduce a Permutation Sum problem over $n$ integers, $X_{1}$ to $X_{n}$, to a manipulation problem with $n+3$ candidates. By Lemma 1, we can construct an election in which the non-manipulators cast votes to give the score vector:

$$\langle C,2(n+2)-X_{1}+C,\ldots,2(n+2)-X_{n}+C,2(n+2)+C,y\rangle$$

where $C$ is a constant and $y\leq C$. We claim that two manipulators can make candidate $1$ win such an election iff the Permutation Sum problem has a solution.

($\Rightarrow$) Suppose we have two permutations $\sigma$ and $\pi$ of $1$ to $n$ with $\sigma(i)+\pi(i)=X_{i}$. We construct two manipulating votes which have the scores:

$$\langle n+2,\sigma(1),\ldots,\sigma(n),0,n+1\rangle$$

$$\langle n+2,\pi(1),\ldots,\pi(n),0,n+1\rangle$$

Since $\sigma(i)+\pi(i)=X_{i}$, these give a total score vector:

$$\langle 2(n+2)+C,2(n+2)+C,\ldots,2(n+2)+C,2(n+1)+y\rangle$$

As $y\leq C$ and we tie-break in favour of the manipulators, candidate $1$ wins.

($\Leftarrow$) Suppose we have a successful manipulation. To ensure candidate $1$ beats candidate $n+2$, both manipulators must put candidate $1$ in first place. Similarly, both manipulators must put candidate $n+2$ in last place otherwise candidate $n+2$ will will beat our preferred candidate. Hence the final score of candidate $1$ is $2(n+2)+C$. The gap between the final score of candidate $1$ and the current score of candidate $i+1$ (where $1\leq i\leq n$) is $X_{i}$. The sum of these gaps is $n(n+1)$. If any candidate $2$ to $n+1$ gets a score of $n+1$ then candidate $1$ will be beaten. Hence, the two scores of $n+1$ have to go to the least dangerous candidate which is candidate $n+3$.

The votes of the manipulators are thus of the form:

$$\langle n+2,\sigma(1),\ldots,\sigma(n),0,n+1\rangle$$

$$\langle n+2,\pi(1),\ldots,\pi(n),0,n+1\rangle$$

Where $\sigma$ and $\pi$ are two permutations of $1$ to $n$. To ensure candidate $1$ beats candidate $j$ for $j\in[1,n]$, we must have:

$$2(n+2)-X_{j}+C+\sigma(j)+\pi(j)\leq 2(n+2)+C$$

Rearranging this gives:

$$\sigma(j)+\pi(j)\leq X_{j}$$

Since $\sum_{i=1}^{n}X_{i}=n(n+1)$ and $\sum_{i=1}^{n}\sigma(i)=\sum_{i=1}^{n}\pi(i)=\frac{n(n+1)}{2}$, there can be no slack in any of these inequalities. Hence,

$$\sigma(j)+\pi(j)=X_{j}$$

That is, we have a solution of the Permutation Sum problem.

$\Box$

Recall that we have assumed that the manipulators have complete knowledge about the scores from the votes of the non-manipulators. The argument often put forward for such an assumption is that partial or probabilistic information about the votes of the non-manipulators will add to the computational complexity of computing a manipulation.

NP-hardness only bounds the worst-case complexity of computing a manipulation. Given enough manipulators, we can easily make any candidate win. We consider next minimizing the number of manipulators required. For example, Reverse is a simple approximation method proposed to compute Borda manipulations (?). The method constructs the vote of each manipulator in turn: candidate $d$ is put in first place, and the remaining candidates are put in reverse order of their current Borda scores. The method continues constructing manipulating votes until $d$ wins. A long and intricate argument shows that Reverse constructs a manipulation which uses at most one more manipulator than is optimal.

We can view Reverse as greedily constructing a manipulation matrix. A manipulation matrix is an $n$ by $m$ matrix, $A$ where $A(i,j)=k$ iff the $i$th manipulator adds a score of $k$ to candidate $j$. A manipulation matrix has the properties that each of the $n$ rows is a permutation of 0 to $m-1$, and the sum of the $j$th column is less than or equal to $g(j)$, the maximum score candidate $j$ can receive without defeating $d$. Reverse constructs this matrix row by row.

Our two new approximation methods break out of the straightjacket of constructing a manipulation matrix in row wise order. They take advantage of an interesting result that relaxes the constraint that each row is a permutation of 0 to $m-1$. This lets us construct a relaxed manipulation matrix. This is an $n$ by $m$ matrix that contains $n$ copies of 0 to $m-1$ in which the sum of the $j$th column is again less than or equal to $g(j)$. In a relaxed manipulation matrix, a row can repeat a number provided other rows compensate by not having the number at all.

We build a bipartite graph between the vertices $V_{i}$ and $W_{j}$ for $i\in[0,m-1]$ and $j\in[1,m]$. $V_{i}$ represent the scores assigned to the first row of $B$, whilst $W_{j}$ represent the columns of $A$ from where these will be taken. We add the edge $(V_{i},W_{j})$ to this bipartite graph for each $i\in[0,m-1]$,$j\in[1,m]$ and $k\in[1,n]$ where $A(k,j)=i$. Note that there can be multiple edges between any pair of vertices. By construction, the degree of each vertex is $n$.

Suppose we take any $U\subseteq\{V_{i}|i\in[0,m-1]\}$. By a simple counting argument, the neighborhood of $U$ must be at least as large as $U$. Hence, the Hall condition holds and a perfect matching exists (?). Consider an edge $(V_{i},W_{j})$ in such a perfect matching. We construct the first row of $B$ by setting $B(1,j)=i$. As this is a matching, each $i\in[0,m-1]$ occurs once, and each column is used exactly one time. We now construct an $n-1$ by $m$ matrix from $A$ by removing one element equal to $B(1,j)$ from each column $j$. By construction, each value $i\in[0,m-1]$ occurs $n-1$ times, and the column sums are now $h(j)-B(1,j)$. Hence it is a relaxed manipulation matrix. We can therefore appeal to the induction hypothesis. This gives us an $n$ by $m$ manipulation matrix $B$ with the same column sums as $A$. $\Box$

We can extract from this proof a polynomial time method to convert a relaxed manipulation matrix into a manipulation matrix. Hence, it is enough to propose new approximation methods that construct relaxed manipulation matrices. This is advantageous for greedy methods like those proposed here as we have more flexibility in placing later entries into good positions in the manipulation matrix.

Our first approximation method, Largest Fit is inspired by bin packing and multiprocessor scheduling. Constructing an $n$ by $m$ relaxed manipulation matrix is similar to packing $n$ objects into $m$ bins with a constraint on the capacity of the different bins. In fact, the problem is even similar to scheduling $nm$ unit length jobs on $n$ different processors with a constraint on the total memory footprint of the $n$ different jobs running at every clock tick. Krause et al. have proposed a simple heuristic for this problem that schedules the unassigned job with the largest memory requirement to the time step with the maximum remaining available memory that has less than $n$ jobs assigned (?). If no time step exists that can accommodate this job, then the schedule is lengthened by one step.

Largest Fit works in a similar way to construct a relaxed manipulation matrix. It assigns the largest unallocated score to the largest gap. More precisely, it first assigns $n$ instances of $m-1$ to column $d$ of the matrix (since it is best for the manipulators to put $d$ in first place in their vote). It then allocates the remaining $(n-1)m$ numbers in reverse order to the columns corresponding to the candidate with the current smallest score who has not yet received $n$ votes from the manipulators. Unlike Reverse, we do not necessarily fill the matrix in row wise order.

Our second approximation method, Average Fit takes account of both the size of the gap and the number of scores still to be added to each column. If two columns have the same gap, we want to choose the column that contains the fewest scores. To achieve this, we look at the average score required to fill each gap: that is, the size of the gap divided by the number of scores still to be added to the column. Average Fit puts the largest unassigned score possible into the column which will accommodate the largest average score. Average Fit does not allocate the largest unassigned score but the largest such score that will fit into the gap. This avoids defeating $d$ where it is not necessary. If two or more columns can accommodate the same largest average score, we tie-break either arbitrarily or on the column containing fewest scores. The latter is more constrained and worked best experimentally. However, it is possible to construct pathological instances on which the former is better.

We show that Largest Fit is incomparable to Reverse since there exists an infinite family of problems on which Largest Fit finds the optimal manipulation but Reverse does not, and vice versa. Full proofs of Theorems 3–4 can be found in (?).

Unlike Reverse, Largest Fit can use more than one extra manipulator than is optimal. In fact the number of extra manipulators used by Largest Fit is not bounded.

Average Fit is also incomparable to Largest Fit. Like Reverse, it finds the optimal manipulations on the elections in the last proof. So far we have not found any instances where Reverse performs better than Average Fit. However, there exist examples on which Largest Fit finds the optimal manipulation but Average Fit does not.

To test the performance of these approximation methods in practice, we ran some experiments. Our experimental setup is based on that in (?). We generated either uniform random votes or votes drawn from a Polya Eggenberger urn model. In the urn model, votes are drawn from an urn at random, and are placed back into the urn along with ${b}$ other votes of the same type. This captures varying degrees of social homogeneity. We set ${b}=m!$ so that there is a 50% chance that the second vote is the same as the first. In both models, we generated between $2^{2}$ and $2^{7}$ votes for varying $m$. We tested 1000 instances at each problem size. To determine if the returned manipulations are optimal, we used a simple constraint satisfaction problem.

There exists an interesting connection between the problem of finding a coalition of two manipulators for the Borda voting rule and two other problems in discrete mathematics: the problem of finding a permutation matrix with restricted diagonals sums (PMRDS) (?) and the problem of finding multi Skolem sequences (?). We consider this connection for two reasons. First, future advances in these adjacent areas may give insights into new manipulation algorithms or into the complexity of manipulation. Second, this connection reveals an interesting open case for Borda manipulation – Nordh has conjectured that it is polynomial when all gaps are distinct.

A permutation matrix is an $n$ by $n$ Boolean matrix which is obtained from an identity matrix by a permutation of its columns. Hence, the permutation matrix contains a single value 1 in each row and each column. Finding a permutation matrix such that the sums of its diagonal elements form a given sequence of numbers $(d_{1},\ldots,d_{2n-1})$ is the permutation matrix with restricted diagonals sums problem. This problem occurs in discrete tomography, where we need to construct a permutation matrix from its X-rays for each row, column and diagonal. The X-ray values for each row and column are one, while the values for the diagonal are represented with the sequence $(d_{1},\ldots,d_{2n-1})$.

We transform a manipulation problem with $n$ candidates and $2$ manipulators such that $\sum_{i=1}^{n}{g_{i}}=n(n-1)$ to a PMRDS problem. To illustrate the transformation we use the following example with 5 candidates. Let $\langle 4,4,6,6,0\rangle$ be a score vector, where our favorite candidate has 0 score, and $\langle 4,4,2,2\rangle$ be the corresponding gap vector. We label rows of a permutation matrix with scores of the first manipulator and columns of a permutation matrix with the reversed scores of the second manipulator. We label each element of the matrix with the sum of its row and column labels. Figure 3(a) shows the labelling for our example in gray.

Note that each element on a diagonal is labelled with the same value. Therefore, each diagonal labelled with value $k$ represents the gap of size $k$ in the manipulation problem. Hence, the sum of the diagonal $d_{i}$ labelled with $k$ encodes the number of occurrences of gaps of size $k$. For example, $d_{3}=2$ ensures that there are two gaps of size $2$ and $d_{5}=2$ ensures that there are two gaps of size $4$. The remaining diagonal sums, $d_{i}$, $i\in\{1,2,4,6,7\}$, are fixed to zero.

Consider a solution of PMRDS (Figure 3(b)). Cell $P(0,1)$ contains the value one. Hence, we conclude that the first manipulator gives the score $0$ and the second gives the score $2$ to a candidate with the gap $2$. Similarly, we obtain that the first manipulator gives the scores $\langle 1,3,0,2\rangle$ and the second gives the scores $\langle 3,1,2,0\rangle$ to fill gaps $\langle 4,4,2,2\rangle$. As the number of ones in each diagonal is equal to the number of occurrences of the corresponding gap, the constructed two manipulator ballots make our candidate a co-winner.

Finding a coalition of two manipulators for the Borda voting rule is also connected to the problem of finding multi Skolem sequences used for the construction of Steiner triple system (?). Given a multiset of positive integers $G$ we need to decide whether there exists a partition of a set $H=\{1,\ldots,2n\}$ into a set of pairs $(h_{i},h_{i}^{\prime})$, $i=1,\ldots,n$ so that $G\equiv\{h_{i}-h_{i}^{\prime}|h_{i},h_{i}^{\prime}\in H\}$. There is a reduction from a manipulation problem with $n$ candidates and $2$ manipulators such that $\sum_{i=1}^{n}{g_{i}}=n(n-1)$ to a special case of multi Skolem sequences with $\sum_{i=1}^{n}G_{i}=n^{2}$ similar to the reduction from a scheduling problem in (?) ¹¹1The reduction implicitly assumes that $\sum_{i=1}^{n}G_{i}=n^{2}$ as the author confirmed in a private communication..

We have proved that it is NP-hard to compute how to manipulate the Borda rule with just two manipulators. This resolves one of the last open questions regarding the computational complexity of unweighted coalition manipulation for common voting rules. To evaluate whether such computational complexity is important in practice, we have proposed two new approximation methods that try to minimize the number of manipulators. These methods are based on ideas from bin packing and multiprocessor scheduling. We have studied the performance of these methods both theoretically and empirically. Our best method finds an optimal manipulation in almost all of the elections generated.

Jessica Davies is supported by the National Research Council of Canada. George Katsirelos is supported by the ANR UNLOC project ANR 08-BLAN-0289-01. Nina Narodytska and Toby Walsh are supported by the Australian Department of Broadband, Communications and the Digital Economy, the ARC, and the Asian Office of Aerospace Research and Development (AOARD-104123).

Our NP-hardness proof requires a technical lemma that we can construct votes with a given target sum.