Exact algorithms for weighted and unweighted Borda manipulation problems

Theoretical Computer Science 622 (2016) 79–89

Contents lists available at ScienceDirect

Theoretical Computer Science www.elsevier.com/locate/tcs

Exact algorithms for weighted and unweighted Borda manipulation problems ✩ Yongjie Yang, Jiong Guo ∗ Shandong University, School of Computer Science and Technology, ShunHua Road 1500, 250101 Jinan, China Universität des Saarlandes, Campus E 1.7, D-66123, Saarbrücken, Germany

a r t i c l e

i n f o

Article history: Received 11 March 2014 Received in revised form 16 November 2015 Accepted 4 February 2016 Available online 8 February 2016 Communicated by P. Spirakis Keywords: Exact algorithm Computational social choice Borda manipulation Single-peaked elections

a b s t r a c t t +m−1

· (t + 1)m )-time algorithms for the We propose O ∗ ((m · 2m )t +1 )-time and O ∗ ( t weighted and the unweighted Borda manipulation problems, respectively, where t is the number of manipulators and m is the number of candidates. In particular, for t = 2, our algorithm for the unweighted case runs in O ∗ (3m ) time, affirmatively resolving one open problem posed by Betzler et al. [2]. As a byproduct of our results, we show that the unweighted Borda manipulation problem admits an algorithm with running time O ∗ (29m log m ), based on an integer linear programming technique. Finally, we prove that the unweighted Borda manipulation problem is polynomial-time solvable in single-peaked elections, in contrast to the N P -hardness in the general case. © 2016 Published by Elsevier B.V. 2

1. Introduction Voting is a common method for preference aggregation and collective decision-making, and has applications in political elections, multi-agent systems, web spam reduction, etc. [27,28,35]. A major concern in voting systems is strategic behavior, e.g., candidates, voters or external agents to influence the election results by carrying out some strategy. By the celebrated Gibbard–Satterthwaite Theorem [18,31], every reasonable voting system with more than two candidates can be attacked by voters with providing insincere votes. To address this issue, Bartholdi et al. [21] proposed to use complexity as a barrier against strategic behavior: if it is computationally hard to determine how to influence the result, one might give up on attacking the election. Since the work of Bartholdi et al. [21], many strategic voting problems have been proposed and extensively studied from the complexity point of view (see [2,8,12,20,26] for some representative works). Recently, many N P -hard strategic voting problems have been studied from the viewpoint of exact, exponential-time algorithms, for instance, manipulation problems [7], bribery problems [10], control problems [16], etc. We refer to [1] for a comprehensive survey on this topic. In this paper, we study two N P -hard manipulation problems under the Borda system. In particular, we devise exact combinatorial algorithms for the problems. The Borda system, proposed by Jean-Charles de Borda in 1781 [4], 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 [29]. Moreover, it has been proved to be very useful in pattern recognition [13,33].

✩

*

A preliminary version (extended abstract) of this paper appeared in the proceedings of AAMAS 2013. Corresponding author at: Shandong University, Shunhua Road 1500, 250101, Jinan, China. E-mail addresses: [email protected] (Y. Yang), [email protected] (J. Guo).

http://dx.doi.org/10.1016/j.tcs.2016.02.003 0304-3975/© 2016 Published by Elsevier B.V.

80

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

1.1. Preliminaries A multiset S = {s1 , s2 , . . . , s| S | } is a generalization of a set where objects of S are allowed to appear more than one time in S, that is, si = s j is allowed for i = j. An element of S is one copy of some object. We use s ∈+ S to denote that s is an element of S. The cardinality of S denoted by | S | is the number of elements contained in S. For example, the cardinality of the multiset {1, 1, 1, 2, 3, 3} is 6. For two multisets A and B, we use A  B to denote the multiset containing all elements in A and B. For example, for A = {1, 1, 2, 3, 3, 4} and B = {1, 2, 3}, A  B = {1, 1, 1, 2, 2, 3, 3, 3, 4}. A voting system is specified by a set C of candidates, a multiset V = {π v 1 , π v 2 , . . . , π v n } of votes cast by a corresponding set V = { v 1 , v 2 , . . . , v n } of voters (π v i is cast by v i ), and a voting protocol which maps the election (C , V , V ) to a subset of candidates, the winners. Throughout this paper, m = |C |. Moreover, each vote π v ∈+ V is defined as a bijection π v : C → [m], where [m] denotes the set {1, 2, . . . , m}. The position of a candidate c in a vote π v is the value of π v (c ). We say a candidate c is placed in the x-th position by a voter v, or c occupies the x-th position of the vote π v if π v (c ) = x. The Borda protocol over C can be characterized by an integer vector m − 1, m − 2, . . . , 0. It selects the winners as follows: every vote π v (voter v) contributes π v (c ) − 1 points to every candidate c ∈ C ; and the candidates with the highest total score are the winners. In particular, if there is only one winner, we call it a unique winner. In the weighted Borda system, each voter v is associated with a non-negative integer weight f ( v ) and contributes f ( v ) · (π v (c ) − 1) points to every candidate c ∈ C . Accordingly, winners are the candidates with the highest total score. Clearly, the unweighted Borda system is a special case of the weighted Borda system where each voter has the unit weight 1. For a candidate c and a voter v, let SC v (c ) denote the score of c contributed by v, that is,  SC v (c ) = f ( v ) · (π v (c ) − 1). Moreover, let SC V (c ) denote the total score of c contributed by voters in V , that is, SC V (c ) = v ∈V SC v (c ). In the settings of manipulation, we have, in addition to V , a set V of voters which are called manipulators. The manipulators form a coalition and desire to coordinate their votes to make a given distinguished candidate p win the new election with votes in V  V , where V is the multiset of votes cast by the manipulators. Following the relevant literature (see, e.g., [5,16]), we distinguish between the unique-winner model and the nonunique-winner model of the problems. In particular, the unique-winner model requires that p is the only candidate that has the highest score, while the nonuniquewinner model has no such requirement. For ease of exposition, we mainly focus on the unique-winner model. However, all our results hold for the nonunique-winner model as well. The formal definitions of the problems studied in this paper are as follows. Unweighted Borda Manipulation (UBM) Input: An election (C ∪ { p }, V , V ) where p is not the winner, and a set V of t manipulators. Question: Can the manipulators cast their votes V with |V | = t in such a way that p wins the election (C ∪ { p }, V  V , V ∪ V )? Weighted Borda Manipulation (WBM) Input: A weighted election (C ∪ { p }, V , V , f 1 : V → N) where p is not the winner, a set V of t manipulators and a weight function f 2 : V → N. Question: Can the manipulators cast their votes V with |V | = t in such a way that p wins the weighted election (C ∪ { p }, V   V , V ∪ V , f : V ∪ V → N), where f ( v ) = f 1 ( v ) if v ∈ V and f ( v ) = f 2 ( v ) otherwise? 1.2. Related work and our contribution Unless stated otherwise, all the results discussed in the following hold for both the unique-winner model and the nonunique-winner model. Complexity of strategic behavior for Borda has been intensively studied in the literature. It is known that many types of bribery and control behavior under the unweighted Borda system are N P -hard [6,11,25,30]. Regarding manipulation behavior, the WBM problem is N P -hard even when the election contains only three candidates [7]. Bartholdi et al. [21] showed that both the UBM problem and the WBM problem in the case of only one manipulator are polynomial-time solvable. The complexity of the UBM problem in the case of more than one manipulator remained open for many years, until very recently it was proved N P -hard even in the case of two manipulators [2,8]. Heuristic and approximation algorithms for the UBM problem have been studied in the literature [8,36]. It is worth mentioning that Zuckerman et al. [36] devised an approximation algorithm for the UBM problem, which can output a success manipulation with t + 1 manipulators whenever the given instance has a success manipulation with t manipulators. By applying an integer linear programming (ILP) technique, the UBM problem can be solved exactly with an extremely high computational complexity O ∗ (m! O (m!) )1 [2]. However, purely exact combinatorial algorithms for both the WBM problem and the UBM problem seem not to be intensively studied so far. In particular, Betzler et al. [2] posed as an open problem whether the UBM problem can be solved exactly with a running time single-exponentially depending on m in the case of two manipulators.

1

O ∗ () is the O () notation with suppressed factors polynomial in the size of the input.

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

81

In this paper, we propose two exact combinatorial algorithms solving the WBM problem and the UBM problem in t +m−1 O ∗ ((m · 2m )t +1 ) time and O ∗ ( · t m ) time, respectively, where t is the number of manipulators and m is the number of t candidates. Both algorithms are based on dynamic programming techniques. Our results imply that both the WBM problem and the UBM problem are solvable in time single exponentially on m in the case of constant number of manipulators. In particular, for t = 2, we have an algorithm of running time O ∗ (3m ) for the UBM problem, affirmatively answering the open question in [2]. In addition, by giving an ILP formulation with m2 variables for the UBM problem, we improve the ILP-based 2 algorithm for the UBM problem to O ∗ (29m log m ). Finally, we study polynomial-time algorithms for the UBM problem in the case of at most two manipulators under single-peaked elections (the definition of single-peaked elections is given in Section 4). 2. Algorithm for weighted Borda manipulation In this section, we present an exact combinatorial algorithm for the WBM problem. The following observation is clearly true for both the unique-winner model and the nonunique-winner model. Observation 1. Every yes-instance of the WBM problem has a solution where each manipulator places the distinguished candidate p in his/her highest position. In the following, we first consider the unique-winner model. Let ((C ∪{ p }, V , V , f 1 ), V , f 2 , t ) be the given instance. Due to Observation 1, there must be a solution V with SC V ∪V ( p ) = SC V ( p ) + v ∈V f ( v ) · m if this instance is a yes-instance. Therefore, to make p the winner, SC V (c ) ≤ g (c ) should be satisfied for all c ∈ C , where g (c ) = SC V ( p ) + v ∈V f ( v ) · m − SC V (c ) − 1. The value of g (c ) is called the capacity of c. Meanwhile, if in the given instance there is a candidate c with g (c ) < 0, then the given instance must be a no-instance. Therefore, in the following, we assume that the given instance contains no candidate c with g (c ) < 0. Based on these, we can reformulate the WBM problem as follows:

Reformulation of WBM Input: A set C of candidates associated with a capacity function g : C → N, and a multiset F = { f 1 , f 2 , . . . , f t } of non-negative integers. Question: Is there a multiset  = {π1 , π2 , . . . , πt } of bijections mapping from C to [m] such that for all c ∈ C , t f · ( π i i (c ) − 1) ≤ g (c ) holds? i =1 Here, the bijection πi corresponds to the vote cast by the i-th manipulator and f i ∈+ F corresponds to the weight of the i-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 DT (C , Z 1 , Z 2 , . . . , Z t ), where C ⊆ C is a subset of candidates, Z i ⊆ [m] and |C | = | Z i | for all i ∈ [t ]. Here, each Z i encodes the positions that are occupied by the candidates of C in the vote cast by the i-th manipulator. The entry DT (C , Z 1 , Z 2 , . . . ,Z t ) = 1 means that there is a multiset  = {π1 , π2 , . . . , πt } of bijections mapping from C to [m] such that for each i ∈ [t ], c ∈C {πi (c )} = Z i and, for every candidate c ∈ C , c is “safe” under . Here, we say a candidate c is safe t under , if i =1 f i · (πi (c ) − 1) ≤ g (c ). Intuitively, DT (C , Z 1 , Z 2 , . . . , Z t ) = 1 means that we can place all candidates of C in the positions encoded by Z i for all i ∈ [t ] without exceeding the capacity of any c ∈ C . Clearly, a given instance of the WBM problem is a yes-instance if and only if DT (C , Z 1 = [m], Z 2 = [m], . . . , Z t = [m]) = 1. The algorithm is as follows: Initialization: For all c ∈ C and z1 , z2 , . . . , zt ∈ [m], if wise, DT ({c }, { z1 }, { z2 }, . . . , { zt }) = 0.

t

i =1

f i · ( zi − 1) ≤ g (c ), then DT ({c }, { z1 }, { z2 }, . . . , { zt }) = 1; other-

Updating: For each integer 2 ≤  ≤ m, we update the entries DT (C , Z 1 , Z 2 , . . . , Z t ) with |C | = | Z 1 | = | Z 2 | = . . . = | Z t | =  as follows: if ∃c ∈ C and ∃ zi ∈ Z i for all i ∈ [t ] such that DT (C \ {c }, Z 1 \ { z1 }, Z 2 \ { z2 }, . . . , Z t \ { zt }) = 1 and DT ({c }, { z1 }, { z2 }, . . . , { zt }) = 1, then DT (C , Z 1 , Z 2 , . . . , Z t ) = 1, otherwise, DT (C , Z 1 , Z 2 , . . . , Z t ) = 0. Theorem 1. The WBM problem is solvable in O ∗ ((m · 2m )t +1 ) time.

t

Proof. We consider the above algorithm for the WBM problem. In the initialization, we check whether i =1 f i · ( z i − 1) ≤ g (c ) for each candidate c ∈ C and each encoded position zi ∈ [m] for each i ∈ [t ]. Since there are m many candidates and m many positions to be considered for each zi , the running time of the initialization is bounded by O ∗ (mt +1 ). In the recurrence, we compute DT (C , Z 1 , Z 2 , . . . , Z t ) for all C ⊆ C and all Z 1 ⊆ [m], Z 2 ⊆ [m], . . . , Z t ⊆ [m] with |C | = | Z 1 | = | Z 2 | = . . . = | Z t | = , where 2 ≤  ≤ m. To compute each of them, we consider all possibilities of c ∈ C and z1 ∈ Z 1 , z2 ∈ Z 2 , . . . , zt ∈ Z t . For each possibility, we further check whether DT (C \ {c }, Z 1 \ { z1 }, Z 2 \ { z2 }, . . . , Z t \ { zt }) = 1 and DT ({c }, { z1 }, { z2 }, . . . , { zt }) = 1. Since there are at most mt +1 such possibilities, and there are at most 2(t +1)m entries needed to be computed, we arrive at the total running time of O ∗ ((m · 2m )t +1 ). The correctness directly follows from the meaning of the dynamic table we defined. 2

82

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

The above algorithm applies to the nonunique-winner model. However, in the nonunique-winner model we define g (c ) for each candidate c ∈ C as follows.

g (c ) = SC V ( p ) +



f ( v ) · m − SC V (c ).

v ∈V

Betzler et al. [2] posed as an open question whether the UBM problem in the case of two manipulators can be solved in time single exponentially on the number of candidates. By Theorem 1, we can answer this question affirmatively. Corollary 2. The WBM problem (UBM is a special case of WBM) in the case of two manipulators can be solved in O ∗ (8m ) time. 3. Algorithm for unweighted Borda manipulation In this section, we study the UBM problem. We first study the unique-winner model. 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 SC V (c ) for a candidate c, it is irrelevant which manipulators placed c in the j-th position. The decisive factor is the number of manipulators placing c in the j-th position. This leads to the following approach where we firstly reduce the UBM problem to a matrix problem, and then solve this matrix problem by a dynamic programming technique, resulting in a better running time than in Corollary 2. Firstly, the matrix problem is defined as follows. Filling Magic Matrix (FMM) Input: A multiset g = { g 1 , g 2 , . . . , gm } of non-negative integers and an integer t > 0. Question: Is there an m × m matrix M with non-negative integers such that ∀i ∈ [m],

m

j =1 M [i ][ j ] = t, and ∀ j ∈ [m],

m

i =1 M [i ][ j ] = t?

m

j =1 ( j

− 1) · M [i ][ j ] ≤ g i and

Using matrix to solve manipulation problems has also been considered by Davies et al. [8]. In this paper, the authors used an n by m relaxed manipulation matrix to devise several heuristic algorithms for the unweighted manipulation problem under Borda, Baldwin’s and Nanson’s voting protocols, where n denotes the number of voters and m the number of candidates. The entry A [i ][ j ] defined in their matrix A is the score that the i-th voter gives to the j-th candidate (the scores might need to be adjusted to get a final solution to the manipulation instance; see [8] for further details). Therefore, each entry is an integer between 0 to m − 1. Our mechanism differs from theirs in several aspects. First, our matrix has both m rows and m columns. Moreover, each row corresponds to a candidate and each column corresponds to a position. The entry M [i ][ j ] is defined as the number of manipulators that rank the i-th candidate in the j-th position. Therefore, each entry is an integer between 0 and t, where t is the number of manipulators. Second, their algorithms are heuristic algorithms, while ours are exact algorithms. Third, our method can be easily adapted to reduce Borda manipulation instances to ILP instances with m2 variables (we discuss in detail later), however their method seems difficult to reduce Borda manipulation instances to ILP instances with the number of variables bounded by a function of m. In the following, we present an algorithm for the FMM problem. The algorithm is based on a dynamic programming method associated with a boolean dynamic table DT (, T ), where  ∈ [m] and T = { T j ∈ N | j ∈ [m], T j ≤ t } is a multiset. The entry DT (, T ) = 1 means that there is an m × m matrix M such that: (1)

m

m

j =1

M [i ][ j ] = t for all i ∈ []; (2)



i =1

M [i ][ j ] =

T j for all j ∈ [m]; and (3) j =1 ( j − 1) · M [i ][ j ] ≤ g i for all i ∈ []. It is clear that a given instance of FMM is a yes-instance if and only if DT (m, T [m] ) = 1, where T [m] is the multiset containing m copies of t. The algorithm for solving FMM is as follows. Initialization: For each possible multiset T = { T j ∈ N | j ∈ [m], T j ≤ t }, if DT (1, T ) = 1; otherwise, set DT (1, T ) = 0.

m

j =1

T j = t and

m

j =1 ( j

− 1) · T j ≤ g 1 , then set

Updating: For each integer from 2 to m and each possible multiset T = { T j ∈ N | j ∈ [m], T j ≤ t }, if there is a multiset m m } with T = { T 1 , T 2 , . . . , T m i =1 T i = t and T i ≤ T i for all i ∈ [m], such that DT ( − 1, T − T ) = 1 and j =1 ( j − 1) · T j ≤ g  , }. then set DT (, T ) = 1; otherwise, set DT (, T ) = 0. Here, T − T = { T 1 − T 1 , T 2 − T 2 , . . . , T m − T m

t +m−1

Lemma 3. The FMM problem is solvable in O ∗ (

t

· (t + 1)m ) time.

Proof. In the initialization, we consider all possible multisets T = { T j ∈ N | j ∈ [m], T j ≤ t } with

m

t +m−1

m

m

j =1

T j = t and

possibilities (according to j =1 ( j − 1) · T j ≤ g 1 . Since T has at most j =1 T j = t), the running time of the t t +m−1 initialization is bounded by O ∗ ( . In the recurrence, we use a loop indicated by a variable  with 2 ≤  ≤ m to ) t update DT (, T ). In each loop we compute the values of the entries DT (, T ) for all multisets T = { T j ∈ N | j ∈ [m], T j ≤ t }. m } with To compute each of the entries, we check whether there is a multiset T = { T 1 , T 2 , . . . , T m i =1 T i = t, such that t +m−1 m DT ( − 1, T − T ) = 1 and possible multisets T , the time to compute j =1 ( j − 1) · T j ≤ g  . Since there are at most t

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

83

t +m−1

each DT (, T ) is bounded by O ∗ (

). Since T has at most (t + 1)m possibilities, there are at most (t + 1)m entries t +m−1 needed to be computed in each loop, implying a total time of O ∗ ( · (t + 1)m ) for recurrence procedure. In conclusion, t   t +m−1 ∗ m the total time of the algorithm is O ( · (t + 1) ). t The correctness directly follows from the meaning we defined for the dynamic table. 2 t

We now come to show how to solve the UBM problem via the FMM problem. Lemma 4. The UBM problem is polynomial-time reducible to the FMM problem. Proof. Let  = ((C ∪ { p }, V , V ), V , t ) be an instance of the UBM problem. By Observation 1, we know that if  is a yes-instance there is a solution V such that each manipulator places p in his/her highest position. We assume that SC V ( p ) + t · m − SC V (c ) − 1 ≥ 0 for all c ∈ C as discussed in Section 2. Let (c 1 , c 2 , . . . , cm ) be any arbitrary ordering of C . We construct an instance  = (t , g ) of FMM where t has the same value as in  and g = { g 1 , g 2 , . . . , gm } with g i = SC V ( p ) + t · m − SC V (c i ) − 1 for all i ∈ [m]. It is clear that the construction takes polynomial time. In the following, we prove that  is a yes-instance if and only if  is a yes-instance. ⇒: Given a solution V for  , we can get a solution for  by setting M [i ][ j ] = |{π ∈+ V | π (c i ) = j }|, where {π ∈+ V | π (c i ) = j } is the multiset containing all votes π ∈+ V with π (c i ) = j. By the above construction, the correctness of M is easy to verify. ⇐: We begin the proof for this direction with some useful notations. A permutation matrix is a square binary matrix that has exactly one entry of 1 in each row and each column. Given an m × m permutation matrix B, we can derive a vote π over C by setting π (c i ) = j for each B [i ][ j ] = 1. To see that π is a vote, recall that each row of B has exactly one entry of 1, which implies that π is defined for every c i ∈ C . Moreover, each column of B has also exactly one entry of 1, which implies that for each j ∈ [m], there is exactly one candidate c i with π (c i ) = j. Due to the above analysis, each m × m permutation matrix encodes a vote over C . Let M be a solution for  = (t , g = { g 1 , g 2 , . . . , gm }). We claim that M can be represented as a sum of t permutation matrices. The proof for the claim is by induction on t. For t = 1, M is clearly a permutation matrix. Now, suppose the claim has been proved for t − 1. We construct a bipartite graph with m vertices on the left and m vertices on the right so that there is an edge between a vertex i on the left and a vertex j on the right if and only if M [i ][ j ] > 0. We will argue that this bipartite graph satisfies the conditions of Hall’s theorem [19] and therefore admits a perfect matching. To see this, label  each edge (i , j ) with its weight M [i ][ j ]. Then the total weight of all edges that leave each vertex on the m left is t (since j =1 M [i ][ j ] = t for each i ∈ [m]), and the total weight of all edges that enter each vertex on the right is t

m

(since i =1 M [i ][ j ] = t for each j ∈ [m]). Now, consider some set of vertices S on the left. The total weight of edges leaving S is | S | · t. Thus, if vertices in S have fewer than | S | neighbors on the right, by the Pigeonhole Principle there has to be some neighbor of S on the right such that the total weight of the incoming edges is more than t, a contradiction. Now, a perfect matching in this graph corresponds to a permutation matrix; by subtracting this matrix from M, we get a matrix with nonnegative entries such that the sum of each row and column is t − 1. We can now apply the induction hypothesis to complete the proof for the claim. According to the above claim, the matrix M can be represented as a sum of t permutation matrices M 1 , M 2 , . . . , M t , each M k encoding a vote πk over C as discussed above. The score of every candidate c i ∈ C , contributed by the votes π1 , . . . , πt , is then m  t 

( j − 1) · M k [i ][ j ] =

j =1 k =1

By further setting

m  ( j − 1) · M [i ][ j ] ≤ g i = SC V ( p ) + t · m − SC V (c i ) − 1. j =1

πk ( p ) = m for each k ∈ [t ], it is clear now that {π1 , . . . , πt } is a solution for  . 2

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

t +m−1

Theorem 5. The UBM problem can be solved in O ∗ ( of manipulators.

t

· (t + 1)m ) time, where m is the number of candidates and t is the number

The above theorem holds for the nonunique-winner model. The correctness can be checked analogously, but with g i being defined for each i ∈ [m] in Lemma 4 as follows.

g i = SC V ( p ) + t · m − SC V (c i ) ≥ 0. Notice that for the case that the number of manipulators is bounded by a constant, we have a single exponential time algorithm for the UBM problem, with respect to the number of candidates. In particular, for t = 2, we have an algorithm of runtime O ∗ (3m ). Corollary 6. The UBM problem in the case of two manipulators can be solved in O ∗ (3m ) time.

84

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

Fig. 1. This figure shows a visual representation of a single-peaked election which contains five candidates A , B , C , D , E and three votes π v 1 (defined by π v 1 ( B ) = 5, π v 1 ( D ) = 4, π v 1 ( E ) = 3, π v 1 (C ) = 2, and π v 1 ( A ) = 1), π v 2 (which is defined by π v 2 ( D ) = 5, π v 2 ( B ) = 4, π v 2 (C ) = 3, π v 2 ( A ) = 2, and π v 2 ( E ) = 1), and π v 3 (which is defined by π v 3 ( A ) = 5, π v 3 (C ) = 4, π v 3 ( B ) = 3, π v 3 ( D ) = 2, and π v 3 ( E ) = 1). The harmonious order L is L( A ) = 1, L(C ) = 2, L( B ) = 3, L( D ) = 4, L( E ) = 5. Here, π v 1 is illustrated by the dark line, π v 2 is illustrated by the gray line and π v 3 is illustrated by the dashed line.

Next we give an ILP formulation for the FMM problem. The ILP contains m2 variables xi j for i , j ∈ [m] and subjects to the following restrictions:

⎧ m  ⎪ ⎪ xi j = t for all j ∈ [m] ⎪ ⎪ ⎪ ⎪ ⎪ i =1 ⎪ ⎪ m ⎪ ⎪ ⎨ xi j = t for all i ∈ [m] j =1

⎪ ⎪ m ⎪  ⎪ ⎪ ( j − 1) · xi j ≤ g i for all i ∈ [m] ⎪ ⎪ ⎪ ⎪ j =1 ⎪ ⎪ ⎩ xi j ≥ 0 for all i , j ∈ [m] where t ∈ N and g = { g 1 , g 2 , . . . , gm } with g i ∈ N for all i ∈ [m] are input. Lenstra [24] proposed an O ∗ (ζ O (ζ ) )-time algorithm for solving ILP with ζ variables. The running time was then improved by Kannan [23]. Lemma 7. (See [23].) An ILP problem with ζ variables can be solved in O ∗ (24.5ζ log ζ ) time. Due to Lemmas 4 and 7, we have the following theorem. Theorem 8. The UBM problem admits an algorithm with running time O ∗ (29m

2

log m

).

4. Borda manipulation under single-peaked elections The concept of single-peaked preferences was introduced by Black in 1948 [3]. The complexity of many voting problems under single-peaked elections has been studied in the literature [5,15,17]. It turned out that many N P -hard problems become polynomial-time solvable when restricted to single-peaked elections [5,17]. Given a set C of candidates and a bijection L : C → [m] where m = |C |, we say that a vote π v : C → [m] is coincident with L if and only if for any three distinct candidates a, b, c ∈ C with L(a) < L(b) < L(c ) or L(c ) < L(b) < L(a), π v (c ) > π v (b) implies π v (b) > π v (a). The candidate having the highest value of π v (·) is called the peak of π v with respect to L. An election (C , V , V ) is a single-peaked election if there exists a bijection L : C → [m] such that all votes of V are coincident with L. We call such a bijection L a harmonious order of (C , V , V ). See Fig. 1 for a concrete example of single-peaked elections. It has been shown in [9,14,22] that one can test whether a given election is a single-peaked election in polynomial time. Moreover, a harmonious order can be calculated 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 (C ∪ { p }, V , V ), a harmonious order L, and a set V of manipulators. We are asked whether the manipulators can cast their votes V in such a way that all their votes are coincident with L and p wins the election (C ∪ { p }, V  V , V ∪ V ) [34]. 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 [21] but becomes N P -hard with two manipulators [2,8]. Notice that the unweighted Borda manipulation problem in single-peaked elections is not a special case of the unweighted Borda manipulation problem in the general case, since the former one requires that the manipulator’s votes should be single-peaked. In this section, we prove that the unweighted Borda manipulation problem with one or two manipulators can be solved in polynomial time under single-peaked elections. We first consider the unique-winner model.

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

85

Fig. 2. Case 2 in the proof of Lemma 10. The left-hand shows the original vote π v with π v (l2 ) > π v (l1 ) > π v (l3 ) > π v ( p ) > π v (r1 ) > π v (l4 ) > π v (l5 ) > π v (r2 ) > π v (r3 ) > π v (l6 ). The right-hand shows the recast vote π  π with π v ( p ) > π v (l1 ) > π v (l2 ) > π v (l3 ) > π v (r1 ) > π v (l4 ) > π v (l5 ) > π v (r2 ) > π v (r3 ) > π v (l6 ). Here C small = {l4 , l5 , l6 , r1 , r2 , r3 }, π has domain { p , l1 , l2 , l3 } and codomain {10, 9, 8, 7}, and π has domain {r1 , l4 , l5 , r2 , r3 , l6 } and codomain {1, 2, 3, 4, 5, 6}.

Theorem 9. Both UBM1SP and UBM2SP are polynomial-time solvable. All remaining parts of this section are devoted to the proof of Theorem 9. To this end, let (C ∪ { p }, V , V ) be the given single-peaked election and L be a harmonious order of (C ∪ { p }, V , V ). Let (la , la−1 , . . . , l1 , p , r1 , r2 , . . . , rb ) be an ordering of C ∪ { p } with L(la ) < L(la−1 ) < . . . < L(l1 ) < L( p ) < L(r1 ) < L(r2 ) < . . . < L(rb ), and let C L = {la , la−1 , . . . , l1 } and C R = {r1 , r2 , . . . , rb }. A partial vote is a partial injection π : C ∪ { p } → [m + 1] which maps a subset C ⊆ C ∪ { p } to [m + 1] such that for any two distinct a1 , a2 ∈ C , π (a1 ) = π (a2 ). Here, C is the domain and {π (a) | a ∈ C } is the codomain of π . A position not in the codomain is called a free position. For simplicity, we define π (c ) = −1 for c ∈ / C . For two partial votes π1 with domain C 1 and π2 with domain C 2 , we say π1 and π2 are compatible if for every c ∈ C 1 ∩ C 2 , π1 (c ) = π2 (c ). Furthermore, for such compatible partial votes π1 and π2 , let π1  π2 denote the partial vote π with domain C 1 ∪ C 2 such that π (c ) = π1 (c ) for all c ∈ C 1 and π (c ) = π2 (c ) for all c ∈ C 2 . For a partial vote π with domain C and a vote π , we say π is extendable to π if for any a ∈ C , π (a) = π (a). The definition of single-peaked elections directly implies the following observation. Observation 2. Let L be a harmonious order, π v be a vote which is coincident with L and c be the peak of π v , then for any c 1 , c 2 with L(c 1 ) < L(c 2 ) < L(c ) or L(c ) < L(c 2 ) < L(c 1 ), π v (c 1 ) < π v (c 2 ) < π v (c ). Lemma 10. Every yes-instance of the UBM problem under single-peaked elections has a solution where every manipulator places the distinguished candidate p in his/her highest position. Proof. Assume that V is a solution that contradicts the claim of the lemma, and v is a manipulator who did not place p in his/her highest position. We first consider the case that C R = ∅ and C L = ∅. Assume that v placed some li in his/her highest position. Let a = |C L | and b = |C R |. Due to Observation 2, π v ( p ) > π v (r1 ) > π v (r2 ) > . . . > π v (rb ). We consider two cases. The first case is that for all l ∈ C L , π v (l) > π v ( p ). In this case, we can create a new solution by recasting π v with π v ( p ) > π v (l1 ) > π v (l2 ) > . . . > π v (la ) > π v (r1 ) > π v (r2 ) > . . . > π v (rb ). The second case is that there is a l ∈ C L with π v (l) < π v ( p ). In this case, there must be a z ∈ [a] such that π v (l j ) > π v ( p ) for all j ∈ [z − 1] and π v (l j ) < π v ( p ) for all a ≥ j ≥ z. Let C small = C R ∪ {l z , l z+1 , . . . , la }. Then we can recast π v with π  π , where π is the partial vote with domain (C ∪ { p }) \ C small and codomain {|C ∪ { p }|, |C ∪ { p }| − 1, . . . , |C small | + 1} such that π ( p ) > π (l1 ) > π (l2 ) > . . . > π (l z−1 ), and π is the partial vote which has domain C small and is extendable to the original vote π v . That is, keep the positions of the candidates in C small unchanged, and adjust the positions of the other candidates so that p is ranked in the top and the vote is single-peaked with respect to the harmonious order. Clearly, after doing so, SC ( p ) − SC (c ) is increased for every c = p, where SC (c ) is the score of the candidate c. Therefore, we get a new solution after recast π v as above. Fig. 2 illustrates such a case. The case where one of C R and C L is an empty set is simpler. In particular, if C R = ∅, we recast π v so that π v ( p ) = a and π v (li ) = a − i; if C L = ∅, we recast π v so that π v ( p ) = b and π v (r i ) = b − i. By recasting so, SC ( p ) − SC (c ) is increased for every c = p, and thus we have a new solution. 2 For a subset C of candidates and a bijection L : C ∪ { p } → [|C ∪ { p }|], we say that the candidates in C lie consecutively in L if and only if there are no c 1 , c 2 ∈ C and c ∈ (C ∪ { p }) \ C such that L(c 1 ) < L(c ) < L(c 2 ). Further, we say two candidates c 1 and c 2 are neighbors in L if |L(c 1 ) − L(c 2 )| = 1. Let N (c ) denote the set of neighbors of c. Clearly, every candidate has at most two neighbors. A block is a subset of candidates lying consecutively in L. For a block S ⊆ C ∪ { p }, let N ( S ) = {c ∈ (C ∪ { p }) \ S | ∃c ∈ S with c ∈ N (c )}. It is easy to verify that | N ( S )| ≤ 2 for every block S. The following lemma has been proven in [32] [Theorem 1]. Lemma 11. For two bijections L : C ∪ { p } → [|C ∪ { p }|] and π : C ∪ { p } → [|C ∪ { p }|], π is coincident with L if and only if for any integer j with 1 ≤ j ≤ m, all candidates in the set {c ∈ C ∪ { p } | π (c ) ≥ j } lie consecutively in L.

86

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

The following observation directly follows from the above lemma. Observation 3. Let π be a vote with p as the peak. L is the harmonious order of the given election and C L , C R are defined as above. Then, π is coincident with L if and only if for all li , li ∈ C L (resp. r j , r j ∈ C R ), i < i (resp. j < j ) implies π (li ) > π (li ) (resp. π (r j ) > π (r j )). 4.1. Algorithm for UBM1SP Note that the polynomial-time algorithm for the general Borda manipulation problem with one manipulator proposed in [21] does not apply to UBM1SP, since UBM1SP requires that the manipulator’s vote should be single-peaked. Our polynomialtime algorithm for UBM1SP is a slightly modified version of the algorithm in [21]. Basically, the algorithm places candidates one-by-one in the positions of the manipulator’s vote, from the highest to the lowest. The currently highest, unoccupied position of the vote is called the “next free position”. The details of the algorithm is as follows: (1) Place p in the highest position; (2) Set S = { p }, where the block S is used to store all candidates which have been placed in some positions by the manipulator; (3) If none of N ( S ) can be “safely” placed in the next free position, then return “No”. A candidate c can be safely placed in the j-th position of the manipulative vote if SC V (c ) + j − 1 < SC V ( p ) + m, that is, placing c in the position will not give c a higher score than that of p in the final election. The correctness of this step is as follows. Due to the single-peakedness of the manipulative vote, if none of N ( S ) can be “safely” placed in the next free position, none of other candidates in C \ ( S ∪ N ( S )) can be placed in the next free position. However, since each vote is a bijection from C ∪ { p } to [m + 1], the given instance is a no-instance; thus, we can correctly return “No”, given that none of N ( S ) can be safely placed in the next free position. (4) Otherwise, place a candidate c ∈ N ( S ), which can be safely placed in the next free position, in the next free position and set S = S ∪ {c }. If S = C ∪ { p }, return “Yes”, otherwise, go back to step (3). Clearly, the above algorithm needs O (m) time, where m is the number of candidates: each iteration extends the block S by adding one new candidate to S. Since S can be extended at most m times and each iteration takes constant time, the total time is bounded by O (m). Lemma 10 implies the correctness of placing p in the highest position. Moreover, the extension of S by the elements in N ( S ) guarantees the constructed vote is coincident with L, by Lemma 11. The correctness of the algorithm when it returns “No” has been discussed. Moreover, due to the step (3), if the algorithm returns “Yes”, then each candidate in C will not have a higher score than that of p in the final election. Since the manipulative vote is single-peaked as discussed above, the algorithm is correct. 4.2. Algorithm for UBM2SP The algorithm for UBM2SP is similar to the one for UBM1SP: Greedily fill free positions of both manipulators until no free position remains or no candidate can be safely placed in a next free position. Main Idea: Let π1 and π2 be the votes of the two manipulators v 1 and v 2 . We use S 1 and S 2 to denote the sets of candidates that are already placed in some positions of π1 and π2 , respectively. At the beginning, S 1 = S 2 = { p } and we then iteratively extend S 1 and S 2 by placing candidates in π1 and π2 . After each iteration, we will assure the invariant that S 1 = S 2 and S 1 is a block of L. In each iteration, define S = S 1 = S 2 and let l and r be the two neighbors of S in L. In order to keep π1 and π2 single-peaked, there are only two cases to consider: First, both next free positions of π1 and π2 are occupied by one of l and r; Second, l is placed in the next free position of one of π1 and π2 , and r is placed in the next free position of the other. If we have c ∈ {l, r } satisfying SC V (c ) + 2α < SC V ( p ) + 2m, where α is the score contributed by one of π1 and π2 with placing c in its next free position, then we prefer the first case, set S 1 := S 1 ∪ {c } and S 2 := S 2 ∪ {c }, and proceed with the next iteration. Otherwise, we check whether the second case is “safe”, that is, SC V (r ) + α < SC V ( p ) + 2m and SC V (l) + α < SC V ( p ) + 2m. If not, then the given instance is a no-instance; otherwise, S 1 := S 1 ∪ {l} and S 2 := S 2 ∪ {r }. Next, we have to restore the invariant that S 1 = S 2 . Observe that S 1 , S 2 , and S 1 ∩ S 2 all are blocks in L. Moreover, S 1 \ S 2 and S 2 \ S 1 form two blocks and both are neighbors to S 1 ∩ S 2 . We apply here another iteration to consider the candidates in S 1 \ S 2 (or S 2 \ S 1 ) one-by-one. For each of them in S 1 \ S 2 (or S 2 \ S 1 ), we place it in the highest safe position in π2 (or π1 ) and fill the “gaps” that are consecutive free positions with candidates not in S 1 ∪ S 2 . We refer further details to the While loop in Lines 21–37 of the algorithm ALGO-UBM2SP. For simplicity, we define some new notations. For a candidate c and an integer s with 1 ≤ s ≤ m, we use c → s (or c  s) to denote that c can (or cannot) be safely placed in the (m + 1 − s)-th position of some manipulator. We also use c → {s1 , s2 } (or c  {s1 , s2 }) to denote that c can (or cannot) be safely placed in the (m + 1 − s1 )-th position of one manipulator and in the (m + 1 − s2 )-th position of the other, simultaneously. For a block S i corresponding to a manipulator v i with i = 1, 2 and a candidate c ∈ N ( S i ), we use extend( S i , c ) to denote the following operations: (1) place c in the next free position of πi , that is, set πi (c ) = m + 1 − | S i |; and (2) extend S i with S i := S i ∪ {c }. To show the correctness of the algorithm, we need the following lemma. For a vote π and two integers x ≤ x with x, x ∈ [m + 1], let Cπ (x, x ) = {c ∈ C ∪ { p } | x ≤ π (c ) ≤ x }. Let

 CL C (L, −c ) = CR

if c ∈ C R if c ∈ C L

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

87

Algorithm 1: The algorithm ALGO-UBM2SP for UBM2SP. 1 Both manipulators place p in their highest positions; 2 Set S 1 = S 2 = { p }; 3 while S 1 = S 2 = C ∪ { p } do 4 S := S 1 ; 5 if ∃c ∈ N ( S ) with c → {| S |, | S |} then 6 extend( S 1 , c ); 7 extend( S 2 , c ); 8 end

9 10 11 12 13 14 15 16

/* In the case N ( S ) = {c }, c is the only candidate which can be placed in the next free positions without destroying the single-peakedness. Thus, if c  {| S |, | S |}, return “No”. */ else if | N ( S )| = {c } and c  {| S |, | S |} then Return “No”; end else

else

17 18 19 20 21 22 23 24 25

Let {c , c } = N ( S ); if c → | S 1 | and c → | S 2 | then extend( S 1 , c ); extend( S 2 , c ); Return “No”; end

end while S 1 = S 2 do Let c be any candidate in N ( S 1 ∩ S 2 ) that has already been placed in a position by only one manipulator v ∈ { v 1 , v 2 }; while c  | S z |, where z = 1 if v = v 2 and z = 2 if v = v 1 do if N ( S z ) \ {c } = ∅ then Return “No”; end else

26 27 28 29 30 31 32 33

let c = N ( S z ) \ {c }; if c → | S z | then extend( S z , c ); else Return “No”; end

34

end

35 36

end extend( S z , c );

37

end

38 end 39 Return “Yes”;

Lemma 12. Let {π1 , π2 } be a solution for UBM2SP, and c ∈ C be a candidate with π1 (c ) = x and π2 (c ) = y. If there are two integers x , y such that (1) x > x, y > y; (2) SC V (c ) + x + y − 2 < SC V ( p ) + 2m; and (3) Cπ1 (x + 1, x ) ⊆ C (L, −c ), Cπ2 ( y + 1, y ) ⊆ C (L, −c ), then shifting c to position x in π1 and shifting c to position y in π2 but not changing the relative order of other candidates results in another solution. More formally, the following two votes π1 , π2 with





π1 (c ) =





π2 (c ) =

⎧ ⎪ ⎨π1 (c ) ⎪ ⎩

x j

⎧ ⎪ ⎨π2 (c ) ⎪ ⎩

y j

if π1 (c ) > x or π1 (c ) < x if c = c

if x < π1 (c ) = j + 1 ≤ x

if π2 (c ) > y or π2 (c ) < y if c = c

if y < π2 (c ) = j + 1 ≤ y

must be another solution. Proof. We can transform π1 to π1 by continually switching the position of c and the position of the candidate c with π1 (c ) = π1 (c ) + 1, until c is moved to the x -th position. Since c ∈ C (L, −c ), due to Observation 3, each switching will not change a vote which is coincident with L to a vote which is not coincident with L. By the same way, we can transform π2 to π2 such that π2 is coincident with L. Since SC V (c ) + x + y − 2 < SC V (c ) + 2m, and each switch does not increase the total scores of any other candidates, {π1 , π2 } must be a solution. 2

88

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

We now come to show the correctness of the algorithm. We say two partial votes π1 , π2 with domains S 1 , S 2 with | S 1 | ≤ | S 2 |, respectively, are extendable to a solution, if there is a solution {π1 , π2 } such that π1 (and π2 ) is identical to the first | S 1 | (and | S 2 |) positions of π1 (and π2 ). Lemma 13. ALGO-UBM2SP solves UBM2SP correctly in O (m) time, where m is the number of candidates. Proof. Firstly, we consider the correctness. In each step, the algorithm extends S 1 (or S 2 ) by adding a candidate from N ( S 1 ) (or N ( S 2 )) to S 1 (or S 2 ), which makes S 1 (or S 2 ) always be a block. Due to Lemma 11, if the algorithm returns “Yes”, the two votes π1 and π2 must be coincident with L. We need the following observations. Observation 4. If at some point S 1 = S 2 = S, π1 , π2 are extendable to a solution, and a candidate c ∈ N ( S ) satisfies c → {| S |, | S |}, then the partial votes π1 with π1 (c ) = π1 (c ) for c ∈ S and π1 (c ) = m + 1 − | S | and π2 with π2 (c ) = π2 (c ) for c ∈ S and π2 (c ) = m + 1 − | S | are extendable to a solution. Observation 5. If at some point S 1 = S 2 = S with N ( S ) = {l, r }, π1 , π2 are extendable to a solution, no candidate c ∈ N ( S ) satisfies c → {| S |, | S |}, and l → | S | and r → | S |, then, the partial votes π1 with π1 (c ) = π1 (c ) for c ∈ S and π1 (l) = m + 1 − | S | and π2 with π2 (c ) = π2 (c ) for c ∈ S and π2 (r ) = m + 1 − | S | are extendable to a solution. Observation 6. If at some point two partial votes π1 and π2 with domains S 1 and S 2 , respectively, are extendable to a solution and there is a candidate c which has been placed in some position in πi (but has not been placed by the other vote, that is, π3−i ), where i = 1 or i = 2, then, the partial votes πi and π with π (c ) = π3−i (c ) for c ∈ S 3−i , and π (c ) = min{SC V ( p ) + 2m − SC V (c ) − πi (c ) + 1, m + 1 − | S 3−i |} are extendable to a solution. The correctness of the above observations follows from Lemma 12. Due to Lemma 10, Line 1 in Algorithm 1 is correct. Then, we consider the while loop in Line 3. Due to Observation 4, if the If condition in Line 5 is satisfied and the given instance is a yes-instance, then, the partial votes after the execution of the If sentences must be extendable to a solution. Otherwise, if the If condition in Line 5 is not satisfied, and N ( S ) contains only one candidate, then the given instance must be a no-instance as described in the comments for Line 9. Finally, if the If condition in Line 14 is satisfied, then, due to Observation 5, we should extend( S 1 , c ) and extend( S 2 , c ), as described in the Lines 15 and 16. On the other hand, if the If condition in Line 14 is not satisfied, then the given instance must be a no-instance; and thus, we return “No”, as described in Line 18. The reason for this is that, due to Lemma 11 and Observation 5, if the given instance is a yes-instance, then π1 , π2 must be extendable to a solution and thus, the next free positions must be occupied by N ( S ). If all the if conditions of in Lines 5–20 are not satisfied, the next free positions cannot be safely placed, then we can return “No”. After the execution of extend operations in Lines 15 and 16, S 1 = S 2 , and the algorithm then goes to the While loop indicated by Line 21. Since S 1 ∩ S 2 = ∅ (at least p ∈ S 1 ∩ S 2 ) and both S 1 and S 2 are blocks (this is easy to check by the definition of extend), there must be at least one candidate c ∈ N ( S 1 ∩ S 2 ) which has already been placed in a position by a manipulator v ∈ { v 1 , v 2 }. Due to Observation 6, if the given instance is a yes-instance, then we can place c in the position y = min{SC V ( p ) + 2m − SC V (c ) − πi (c ) + 1, m + 1 − | S z |}, where i = 1, z = 2 if v = v 1 and i = 2, z = 1 if v = v 2 , to get partial votes which are extendable to a solution. Due to Lemma 11, all free positions higher than the y-th position can only be occupied by candidates from C (L, −c ) \ S z , and each of these free positions is occupied by a unique candidate from C (L, −c ) \ S z . These are exactly what the While loop in Lines 23–35 do: placing the candidates in C (L, −c ) \ S z in the free positions which are higher than the y-th position one-by one. After the loop, the operation in Line 36 places c in the y-th position. However, if |C (L, −c ) \ S z | is less than the number of free positions which are higher than the y-th position, then due to Lemma 11, the given instance must be a no-instance. Due to the above analysis, operations in Lines 5–37 correctly extend the partial votes to two new partial votes which are also extendable to a solution, or correctly returns “No”. To analyze the running time, we need to consider how many times the operations in Lines 5–20, Line 22, Lines 24–34, and Line 36 are executed. For simplicity, let nx– y (or nx ) denote the number of times that Lines x–y (Line x) are executed throughout the algorithm. It is clear that n22 = n36 . Since each execution of Lines 5–20, Lines 24–34 and Line 36 extends at least one of S 1 and S 2 by adding a new candidate to the block or terminates the algorithm, and both S 1 and S 2 can be extended at most 2m times, we conclude that n5–20 + n22 + n24–34 + n36 = O (m). Since each execution of these lines needs constant time, we arrive at a total running time of O (m). 2 The above algorithms can be easily adapted to solve the nonunique-winner model by adjusting the inequalities comparing the scores of the distinguished candidate p and other candidates so that the final score of p is at least the same as that of any other candidate. 5. Conclusion and future work We have studied combinatorial algorithms for Borda manipulation problems. In particular, we proposed two exact comt +m −1 binatorial algorithms with running times O ∗ ((m · 2m )t +1 ) and O ∗ ( t + 1)m ) for the WBM problem and the UBM · ( t

Y. Yang, J. Guo / Theoretical Computer Science 622 (2016) 79–89

89

problem, respectively, where t is the number of manipulators and m is the number of candidates. If t is bounded by a constant, our algorithm for the UBM problem is a single-exponential algorithm with respect to the number of candidates. This resolved an open problem posed by Betzler et al. [2] affirmatively. In addition, we gave an ILP formulation with m2 vari2 ables for the UBM problem. According to an algorithm for ILP [23], this formulation gives an O ∗ (29m log m )-time algorithm for the UBM problem. Finally, we studied the UBM problem under single-peaked elections and proposed polynomial-time algorithms for the problem in the case of no more than two manipulators. We remark that all our algorithms can be easily adapted to solve the manipulation problems under the (positional) scoring systems. Recall that a (positional) scoring system over a set of m candidates is characterized by an integer vector am , am−1 , . . . , a1 . Moreover, each vote gives ai points to the candidate placed in the i-th position. The winners are the candidates with the highest score. The Borda system is in fact a (positional) scoring system with scoring vector m − 1, . . . , 0. Other common (positional) scoring systems include Plurality, r-Approval, Veto. See [1] for further details. One future direction would be to improve the presented combinatorial algorithms. Parameterized complexity has been proved a powerful tool to handle N P -hard problems. As showed here and in [2], the UBM problem is fixed-parameter tractable with respect to the number m of candidates. A challenging work is to improve the running time to O ∗ (2m log m ), or even O ∗ (cm ) with c being a constant. Furthermore, the complexity of the UBM problem in the case of more than two manipulators under single-peaked elections remains open. Acknowledgements We thank the anonymous reviewers for their constructive comments. In particular, we thank the reviewer who suggested the current proof of Lemma 4 which is much simpler and more refined than our old one. References [1] N. Betzler, R. Bredereck, J. Chen, R. Niedermeier, Studies in computational aspects of voting – a parameterized complexity perspective, in: The Multivariate Algorithmic Revolution and Beyond, 2012, pp. 318–363. [2] N. Betzler, R. Niedermeier, G.J. Woeginger, Unweighted coalitional manipulation under the Borda rule is NP-hard, in: IJCAI, 2011, pp. 55–60. [3] D. Black, On the rationale of group decition-making, J. Polit. Econ. 56 (1948) 23–34. [4] J. Borda, Mémoire sur les élections par scrutin, Des Sciences, 1781, pp. 657–665. [5] F. Brandt, M. Brill, E. Hemaspaandra, L.A. Hemaspaandra, Bypassing combinatorial protections: polynomial-time algorithms for single-peaked electorates, in: AAAI, 2010, pp. 715–722. [6] E. Brelsford, P. Faliszewski, E. Hemaspaandra, H. Schnoor, I. Schnoor, Approximability of manipulating elections, in: AAAI, 2008, pp. 44–49. [7] V. Conitzer, T. Sandholm, J. Lang, When are elections with few candidates hard to manipulate?, J. ACM 54 (3) (2007) 1–33. [8] J. Davies, G. Katsirelos, N. Narodytska, T. Walsh, L. Xia, Complexity of and algorithms for the manipulation of Borda, Nanson’s and Baldwin’s voting rules, Artificial Intelligence 217 (2014) 20–42. [9] J.P. Doignon, J.C. Falmagne, A polynomial time algorithm for unidimensional unfolding representations, J. Algorithms 16 (2) (March 1994) 218–233. [10] B. Dorn, I. Schlotter, Multivariate complexity analysis of swap bribery, Algorithmica 64 (1) (2012) 126–151. [11] E. Elkind, P. Faliszewski, A.M. Slinko, Cloning in elections: finding the possible winners, J. Artificial Intelligence Res. 42 (2011) 529–573. [12] G. Erdélyi, L. Piras, J. Rothe, The complexity of voter partition in Bucklin and Fallback voting: solving three open problems, in: AAMAS, 2011, pp. 837–844. [13] M.V. Erp, L. Schomaker, Variants of the Borda count method for combining ranked classifier hypotheses, in: IWFHR, 2000, pp. 443–452. [14] B. Escoffier, J. Lang, M. Öztürk, Single-peaked consistency and its complexity, in: ECAI, 2008, pp. 366–370. [15] P. Faliszewski, E. Hemaspaandra, L.A. Hemaspaandra, The complexity of manipulative attacks in nearly single-peaked electorates, Artificial Intelligence 207 (2014) 69–99. [16] P. Faliszewski, E. Hemaspaandra, L.A. Hemaspaandra, J. Rothe, Llull and Copeland voting computationally resist bribery and constructive control, J. Artificial Intelligence Res. 35 (2009) 275–341. [17] P. Faliszewski, E. Hemaspaandra, L.A. Hemaspaandra, J. Rothe, The shield that never was: societies with single-peaked preferences are more open to manipulation and control, Inform. and Comput. 209 (2) (2011) 89–107. [18] A. Gibbard, Manipulation of voting schemes: a general result, Econometrica 41 (4) (1973) 587–601. [19] P. Hall, On representatives of subsets, J. Lond. Math. Soc. 10 (1935) 26–30. [20] E. Ianovski, L. Yu, E. Elkind, M.C. Wilson, The complexity of safe manipulation under scoring rules, in: IJCAI, 2011, pp. 246–251. [21] J.J. Bartholdi III, C.A. Tovey, M.A. Trick, The computational difficulty of manipulating an election, Soc. Choice Welf. 6 (3) (1989) 227–241. [22] J.J. Bartholdi III, M.A. Trick, Stable matching with preferences derived from a psychological model, Oper. Res. Lett. 5 (4) (1986) 165–169. [23] R. Kannan, Minkowski’s convex body theory and integer programming, Math. Oper. Res. 12 (1987) 415–440. [24] H.W. Lenstra, Integer programming with a fixed number of variables, Math. Oper. Res. 8 (4) (1983) 538–548. [25] H. Liu, D. Zhu, Parameterized complexity of control by voter selection in Maximin, Copeland, Borda, Bucklin, and Approval election systems, Theoret. Comput. Sci. 498 (2013) 115–123. [26] S. Obraztsova, E. Elkind, On the complexity of voting manipulation under randomized tie-breaking, in: IJCAI, 2011, pp. 319–324. [27] J. Pitt, L. Kamara, M.J. Sergot, A. Artikis, Voting in multi-agent systems, Comput. J. 49 (2) (2006) 156–170. [28] G. Popescu, Group recommender systems as a voting problem, in: HCI (26), 2013, pp. 412–421. [29] B. Reilly, Social choice in the South seas: electoral innovation and the Borda count in the Pacific island countries, Int. Polit. Sci. Rev. 23 (4) (2003) 355–372. [30] N.F. Russell, Complexity of control of Borda count elections, Master’s thesis, Rochester Institute of Technology, 2007. [31] M. Satterthwaite, Strategy-proofness and Arrow’s conditions: existence and correspondence theorems for voting procedures and social welfare functions, J. Econom. Theory 10 (2) (1975) 187–216. [32] M.A. Trick, Recognizing single-peaked preferences on a tree, Math. Social Sci. 17 (3) (1989) 329–334. [33] M. van Erp, L. Vuurpijl, L. Schomaker, An overview and comparison of voting methods for pattern recognition, in: IWFHR, 2002, pp. 195–200. [34] T. Walsh, Uncertainty in preference elicitation and aggregation, in: AAAI, 2007, pp. 3–8. [35] L. Xia, Designing social choice mechanisms using machine learning, in: AAMAS, 2013, pp. 471–474. [36] M. Zuckerman, A.D. Procaccia, J.S. Rosenschein, Algorithms for the coalitional manipulation problem, Artificial Intelligence 173 (2) (2009) 392–412.