Exact Algorithms for Weighted and Unweighted Borda Manipulation Problems

# Exact Algorithms for Weighted and Unweighted Borda Manipulation Problems

Yongjie Yang\titlenoteSupported by the DFG Cluster of Excellence (MMCI) and the China Scholarship Council (CSC).
Universität des Saarlandes
Saarbrücken, Germany
Jiong Guo\titlenoteSupported by the DFG Cluster of Excellence (MMCI).
Universität des Saarlandes
Saarbrücken, Germany
###### Abstract

Both weighted and unweighted Borda manipulation problems have been proved -hard. However, there is no exact combinatorial algorithm known for these problems. In this paper, we initiate the study of exact combinatorial algorithms for both weighted and unweighted Borda manipulation problems. More precisely, we propose  - time and  - time111 is the notation with suppressed factors polynomial in the size of the input. combinatorial algorithms for weighted and unweighted Borda manipulation problems, respectively, where is the number of manipulators and is the number of candidates. Thus, for we solve one of the open problems posted by Betzler et al. [IJCAI 2011]. As a byproduct of our results, we show that the unweighted Borda manipulation problem admits an algorithm of running time , based on an integer linear programming technique. Finally, we study the unweighted Borda manipulation problem under single-peaked elections and present polynomial-time algorithms for the problem in the case of two manipulators, in contrast to the -hardness of this case in general settings.

\numberofauthors

2

## Categories and Subject Descriptors

F.2 [Theory of Computation]: Analysis of Algorithms and Problem Complexity; G.2.1 [Combinatorics]: Combinatorial algorithms; J.4 [Computer Applications]: Social Choice and Behavioral Sciences

Algorithms

## Keywords

voting systems, Borda manipulation, exact combinatorial algorithm, single-peaked election

## 1 Introduction

Voting systems have many applications in a variety of areas, including political election, web spam reduction, multiagent planning, etc. The Borda system, proposed by Jean-Charles de Borda in 1781 borda (), is one of the most significant voting systems. It is the prototype of scoring systems and many other voting systems. The Borda system has been used for selecting presidential election candidates in some of the Pacific island countries such as Nauru and Kiribati. It also has been shown that the Borda system is a powerful technique for pattern recognition.

Certain issues which have been attracting much attention in voting systems are the strategic behaviors, e.g., one or more than one voter to influence the outcome of the elections by doing some tricks. By the celebrated Gibbard-Satterthwaite Theorem Gibbard73 (); satterthwaite1975 (), every reasonable voting system with at least three candidates can be attacked by the voters with providing insincere votes. However, from the viewpoint of complexity theory, if it is -hard to determine how to influence the election, one may give up his attacking to the election. From this point, computational complexity could be a reasonable way to protect elections from being attacked. The first study in this direction was conducted by Bartholdi et al. in their seminal paper BARTHOLDI89 (). Since then, researches on computational complexity of strategic behaviors of voting systems have been opened up (See DBLP:conf/ijcai/IanovskiYEW11 (); DBLP:conf/ijcai/ObraztsovaE11 (); DBLP:conf/atal/ErdelyiPR11 (); DBLP:conf/aaai/DaviesKNW11 (); DBLP:conf/ijcai/BetzlerNW11 () for more details). Recently, many -hard strategic behavior problems have been extensively studied from the view point of exact, exponential-time algorithms, for instance, manipulations DBLP:journals/jacm/ConitzerSL07 (), bribery problems DBLP:journals/algorithmica/DornS12 (), control problems DBLP:journals/jair/FaliszewskiHHR09 (), etc. For more recent development in this direction, we refer to the excellent survey by Betzler et al. DBLP:conf/birthday/BetzlerBCN12 (). We focus on deriving exact combinatorial algorithms for weighted and unweighted Borda manipulation problems, both of which have been proved -hard DBLP:conf/ijcai/BetzlerNW11 (); DBLP:conf/aaai/DaviesKNW11 ().

### 1.1 Preliminaries

A multiset is a generalization of a set where objects of are allowed to appear more than one time in , that is, is allowed for . An element of is one copy of some object. We use to denote that is an element of . The cardinality of denoted by is the number of elements contained in . For example, the cardinality of the multiset is . For two multisets and , we use to denote the multiset containing all elements in and . For example, for and , .

Normally, a voting system can be specified by a set of candidates, a multiset of votes casted by a corresponding set of voters ( is casted by ), and a voting protocol which maps the election to a candidate which we call the winner. Each vote is defined by a bijection  (in some other literature, a vote is defined as a linear order over the candidates), where denotes the set . The position of a candidate in is the value of . We say a voter placing a candidate in his/her -th position or a voter fixing his/her -th position by the candidate if . The candidate placed in the highest, that is, the -th, position in is called the most preferred candidate of , the candidate placed in the second-highest, that is, the -th, position in is called the second preferred candidate of , and so on.

In the following, we use to denote the number of candidates. A Borda protocol can be defined by a vector . Each voter contributes score to his/her most preferred candidate, score to his/her second preferred candidates, and so on. The winner is a candidate who has the highest total score. Here, we break a tie randomly, that is, if there is more than one candidate having the highest score, the winner will be chosen randomly from these candidates. In a weighted Borda system, each voter is associated with a non-negative integer weight and contributes score to his/her most preferred candidate, score to his/her second preferred candidate, and so on. Accordingly, a candidate having the highest total score wins the election. The unweighted Borda system is the special case of the weighted Borda system where each voter has the unit weight of .

For a candidate and a voter , we use to denote the score of which is contributed by , that is, (in an unweighted Borda system, ). Let denote the total score of contributed by voters in , that is, .

In the settings of manipulation, we have, in addition to , a set of voters which are called manipulators. The manipulators form a coalition and desire to coordinate their votes to make a distinguished candidate win the new election with votes in , where is the multiset of votes casted by the manipulators. The formal definitions of the problems studied in this paper are as follows.

Unweighted Borda Manipulation (UBM)
Input: An election where is not the winner, and a set of manipulators.
Question: Can the manipulators cast their votes in such a way that wins the election

Weighted Borda Manipulation (WBM)
Input: A weighted election where is not the winner, a set of manipulators and a weight function .
Question: Can the manipulators cast their votes in such a way that wins the weighted election , where if and otherwise?

Since we break ties randomly, in order to make the winner, the manipulators must assure that after the manipulation the distinguished candidate becomes the only candidate who has the highest total score among all candidates.

### 1.2 Related Work and Our Contribution

As one of the most prominent voting systems, complexity of strategic behaviors under the Borda systems has been intensively studied. It is known that many types of bribery and control behaviors under the unweighted Borda system are -hard. For manipulation behaviors, WBM is -hard even when the election contains only three candidates DBLP:journals/jacm/ConitzerSL07 (). Bartholdi et al. BARTHOLDI89 () showed that both UBM and WBM in the case of only one manipulator are polynomial-time solvable. The complexity of UBM in the case of more than one manipulator remained open for many years, until very recently it was proved -hard even when restricted to the case of only two manipulators DBLP:conf/ijcai/BetzlerNW11 (); DBLP:conf/aaai/DaviesKNW11 (). Heuristic and approximation algorithms for UBM have been studied in the literature DBLP:journals/ai/ZuckermanPR09 (); DBLP:conf/aaai/DaviesKNW11 (). It is worthy to mention that Zuckerman et al. DBLP:journals/ai/ZuckermanPR09 () showed that UBM admits an approximation algorithm which can output a success manipulation with manipulators whenever the given instance has a success manipulation with manipulators. By applying the integer linear programming (ILP) techinique, UBM can be solved exactly with a very high computational complexity DBLP:conf/ijcai/BetzlerNW11 (). However, no purely combinatorial exact algorithm seems known for these problems. In particular, Betzler et al. DBLP:conf/ijcai/BetzlerNW11 () posed as an open problem whether UBM can be solved exactly with a running time single-exponentially depending on in the case of constant number of manipulators.

We propose two algorithms solving WBM and UBM in time and time, respectively, where is the number of manipulators and is the number of candidates. Both algorithms are based on dynamic programming techniques. Our results imply that both WBM and UBM can be solved in time single exponentially on in the case of constant number of manipulators, answering the open question in DBLP:conf/ijcai/BetzlerNW11 (). Additionally, we improve the running time of the ILP-based algorithms for UBM to . The key here is to transfer UBM to an integer linear programming with variables. Furthermore, we study polynomial-time algorithms for UBM in the case of at most two manipulators under single-peaked elections (the definition of single-peaked election is introduced in Sec. 4). Due to lack of space, some proofs are deferred to the long version.

## 2 Algorithm for Weighted Borda Manipulation

In this section, we present an exact combinatorial algorithm for WBM. The following observation is clearly true.

###### Observation 1

Every true-instance of WBM has a solution where each manipulator places the distinguished candidate in his/her highest position.

Let be the given instance. Due to Observation 1, there must be a solution with if this instance is true. Therefore, to make the winner, should be satisfied for all , where . The value of is called the capacity of . Meanwhile, if in the given instance there is a candidate with , then the given instance must be a false-instance. Therefore, in the following, we assume that the given instance contains no candidate with . Based on these, we can reformulate WBM as follows:

Reformulation of WBM
Input: A set of candidates associated with a capacity function , and a multiset of non-negative integers.
Question: Is there a multiset of bijections mapping from to such that holds for all ?

Here, the bijection corresponds to the vote casted by the -th manipulator and corresponds to the weight of the -th manipulator (suppose that a fixed ordering over the manipulators is given).

Our algorithm is based on a dynamic programming method which is associated with a boolean dynamic table defined as , where is a subset of candidates, and for all . Here, each encodes the positions that are occupied by the candidates of in the vote casted by the -th manipulator. The entry means that there is a multiset of bijections mapping from to such that for each and, for every candidate , is “safe” under . Here, we say a candidate is safe under , if . Intuitively, means that we can place all candidates of in the positions encoded by for all without exceeding the capacity of any . Clearly, a given instance of WBM is a true-instance if and only if . The algorithm is as follows:
Initialization: For all and , if , then ; otherwise, .
Updating: For each from 2 to , we update the entries with as follows: if and such that and , then , otherwise, .

###### Theorem 2

WBM is solvable in time.

###### Proof

We consider the above algorithm for WBM. In the initialization, we check whether for each candidate and each encoded position for each . Since there are many candidates and many positions to be considered for each , the running time of the initialization is bounded by . In the recurrence, we compute for all and all with , where . To compute each of them, we consider all possibilities of and . For each possibility, we further check whether and . Since there are at most such possibilities, and there are at most entries needed to be computed, we arrive at the total running time of .

The correctness directly follows from the meaning of the dynamic table we defined.

In DBLP:conf/ijcai/BetzlerNW11 (), Betzler et al. posed as an open question whether UBM in case of two manipulators can be solved in less than time. By Theorem 2, we can answer this question affirmatively.

###### Corollary 3

WBM (UBM is a special case of WBM) in case of two manipulators can be solved in time.

## 3 Algorithm for Unweighted Borda Manipulation

In this section, we study the UBM problem. Recall that UBM is a special case of WBM where all voters have the same unit weight. However, compared to the weighted version, when we compute for a candidate , it is irrelevant which manipulators placed in the -th positions. The decisive factor is the number of manipulators placing in the -th positions. This leads to the following approach where we firstly reduce UBM to a matrix problem and then solve this matrix problem by a dynamic programming technique, resulting in a better running time than in Corollary 3. Firstly, the matrix problem is defined as follows.

Filling Magic Matrix (FMM)
Input: A multiset of non-negative integers and an integer .
Question: Is there an matrix with non-negative integers such that and , and

In the following, we present an algorithm for FMM. The algorithm is based on a dynamic programming method associated with a boolean dynamic table , where and is a multiset. The entry means that there is an matrix such that: (1) for all ; (2) for all ; and (3) for all . It is clear that a given instance of FMM is a true-instance if and only if , where is the multiset containing copies of . The algorithm for solving FMM is as follows.
Initialization: For each possible multisets , if and , then set ; otherwise, set .
Updating: For each from 2 to and each possible multiset , if there is a multiset such that , and , then set ; otherwise, set .

###### Lemma 4

FMM is solvable in time.

###### Proof

In the initialization, we consider all possible multisets with and . Since has at most possibilities, the running time of the initialization is bounded by . In the recurrence, we use a loop indicated by a variable with to update . In each loop we compute the values of the entries for all multisets . To compute each of the entries, we check whether , and for all possible multisets . Since there are at most possible multisets , the time to compute each is bounded by . Since has at most possibilities, there are at most entries needed to be computed in each loop, implying a total time of for recurrence procedure. In conclusion, the total time of the algorithm is .

The correctness directly follows from the meaning we defined for the dynamic table.

We now come to show how to solve UBM via FMM. A partial vote is a partial injection which maps a subset onto such that for any two distinct , . Here, is the domain and is the codomain of . A position not in the codomain is called a free position. For simplicity, we define for .

###### Lemma 5

UBM can be reduced to FMM in polynomial time.

###### Proof (Sketch)

Let be an instance of UBM. By Observation 1, we know that if is a true-instance there must be a solution such that each manipulator places in his/her highest position. We assume that for all as discussed in Section 2. Let be any arbitrary ordering of . We construct an instance of FMM where has the same value as in and with for all . It is clear that the construction takes polynomial time. In the following, we prove that is a true-instance if and only if is a true-instance.

Given a solution for , we can get a solution for by setting , where is the multiset containing all votes with . By the above construction, the correctness of is easy to verify.

Let a matrix be a solution for . Then, a solution for , where there are exactly manipulators who place in the -th positions, can be constructed by the following polynomial algorithm. For simplicity, for a candidate and an integer with , means that there are less than manipulators who have already placed in the -th position. For two partial votes and and two candidates and , means to switch the position of in and the position of in , that is, if then, after , .

Algorithm for constructing a solution for from
Step 1

Initialize of partial votes such that each partial vote has empty domain;

Step 2

Set for all ;

Step 3

For to , do

Step 3.1

While where the -th position is free, do

Step 3.1.1

Let be any candidate with ;

Step 3.1.2

If , then set ;

Step 3.1.3

Else, let and let be a vote with ;

Step 3.1.3.1

If the -th position of is free, then set

Step 3.1.3.2

Else

Step 3.1.3.2.1

While with , do

Step 3.1.3.2.1.1

;

Step 3.1.3.2.1.2

Let ;

Step

End While 3.1.3.2.1

Step 3.1.3.2.2

;

Step 3.1.3.2.3

Set ;

Step

End Else 3.1.3.2

Step

End Else 3.1.3

Step

End While 3.1

Step

End For 3

Step 4

Return .

Since and there are exactly manipulators, there must be a candidate with whenever there is a vote whose -th position is free, which guarantees the soundness of Step 3.1.1. Similarly, there must be a with in Step 3.1.3, since, otherwise, , contradicting that the given instance of FMM is a true-instance. After the switches in the while loop in Step 3.1.3.2.1 and Step 3.1.3.2.2, both and must fulfill the injection properties of partial votes. See Fig. 1 for an example of the switches of the while loop in Step 3.1.3.2.1.

Obviously, such a constructed corresponds to a solution for UBM: for each candidate , .

To analysis the running time of the algorithm, we need the following lemma.

###### Lemma 6

Each execution of the “while” loop in Step 3.1.3.2.1 takes polynomial time.

###### Proof

To prove the lemma, we construct an auxiliary bipartite graph with as the left-hand vertices and as the right-hand vertices, where and are the sets of candidates which have been placed by and in some -th position (a -th position is a position higher than the -th position), respectively. Two vertices are adjacent if and only if they represent the same candidate (as the vertices linked by a gray line in Figure 1) or they were placed in the same (but not identity) positions (as the vertices linked by a black line in Figure 1). We observe that the constructed auxiliary graph has maximum degree two. Since is not empty, there is a simple path with and . It is clear that each execution of the “while” loop corresponds to the following switching processing: switching the positions of and for all  (since and , is even). The lemma follows from the truth that the length of the simple path is bounded by .

We now analysis the running time. The algorithm has three loops. The “for” loop in Step 3 has rounds. The “while” loop in Step 3.1 has at most rounds since each execution of the loop fixes a free position for some . Due to Lemma 6, the “while” loop in Step 3.1.3.2.1 takes polynomial time. Summery all above, the running time of the algorithm is polynomially in and , which complete the proof.

Due to Lemmas 4 and 5, we get the following theorem.

###### Theorem 7

UBM can be solved in time.

Next we show that FMM can be solved by an integer linear programming (ILP) based algorithm. The ILP contains variables for and, subject to the following restrictions

 ⎧⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪⎨⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪ ⎪⎩m∑i=1xij=t for all j∈[m]m∑j=1xij=t for all i∈[m]m∑j=1(j−1)⋅xij≤gi for all i∈[m]xij≥0 for all i,j∈[m]

where and with for all are input.

H. W. Lenstra lenstra83 () proposed an -time algorithm for solving ILP with variables. The running time was then improved by R. Kannan kannan89 ().

###### Lemma 8

kannan89 () An ILP problem with variables can be solved in time.

Due to Lemmas 5 and 8, we have the following theorem.

###### Theorem 9

UBM admits an algorithm with running time .

## 4 Borda Manipulation under Single-Peaked Elections

The single-peaked election was introduced by D. Black in 1948 Black48 (). The complexity of many voting problems under single-peaked elections has been studied in the literature DBLP:conf/tark/FaliszewskiHH11 (); DBLP:conf/aaai/BrandtBHH10 (); DBLP:journals/iandc/FaliszewskiHHR11 (). It turns out that many -hard problems become polynomial-time solvable when restricted to single-peaked elections DBLP:conf/aaai/BrandtBHH10 (); DBLP:journals/iandc/FaliszewskiHHR11 ().

Given a set of candidates and a bijection , we say that a vote is coincident with if and only if for any three distinct candidates with or , implies . The candidate having the highest value of is called the peak of with respect to . An election is a single-peaked election if there exists a bijection such that all votes of are coincident with . We call such a bijection a harmonious order of . See Fig. 2 for a concrete example of single-peaked elections.

It has been shown in DBLP:conf/ecai/EscoffierLO08 () that one can test whether a given election is a single-peaked election in polynomial time. Moreover, a harmonious order can be found in polynomial time if the given election is a single-peaked election.

For a manipulation problem under single-peaked elections, we are given a single-peaked election , a harmonious order , and a set of manipulators. We are asked whether the manipulators can cast their votes in such a way that all their votes are coincident with and wins the election DBLP:conf/aaai/Walsh07 (). In the following, let UBM1SP and UBM2SP denote the problems of UBM with only one manipulator and with exactly two manipulators under single peaked elections, respectively.

It is known that the unweighted Borda manipulation problem is polynomial-time solvable with one manipulator BARTHOLDI89 () but becomes -hard with two manipulators DBLP:conf/ijcai/BetzlerNW11 (); DBLP:conf/aaai/DaviesKNW11 (). Here, we show that this problem with two manipulators can be solved in polynomial time in single-peaked elections.

###### Theorem 10

Both UBM1SP and UBM2SP are polynomial-time solvable.

All remaining parts of this section are devoted to prove Theorem 10. To this end, let be the given single-peaked election and be a harmonious order of . Let be an ordering of with , and let and .

For two partial votes with domain and with domain , we say and are comparable if for every , . Furthermore, for such comparable partial votes and , let denote the partial vote with domain such that for all and for all .

For a partial vote with domain and a vote , we say is extendable to if for any , .

The definition of single-peaked elections directly implies the following observation.

###### Observation 11

Let be a harmonious order, be a vote which is coincident with and be the peak of , then for any with or , .

###### Lemma 12

Every true-instance of UBM under single-peaked elections has a solution where every manipulator places the distinguished candidate in his/her highest position.

###### Proof

Assume that is a solution that contradicts the claim of the lemma, and is a manipulator who did not place in his/her highest position. Without loss of generality, assume that and placed some in his/her highest position. Let and . Due to Observation 11, . We consider two cases. The first case is that for any , . In this case, we can create a new solution by recasting with . The second case is that there is a with . In this case, there must be a such that for all and for all . Let . We can get a new solution by recasting with , where is the partial vote with domain and codomain such that , and is the partial vote which has domain and is extendable to the original vote . Fig. 3  illustrates such a case.