# Complexity of Shift Bribery in Committee Elections

We study the (parameterized) complexity of SHIFT BRIBERY for multiwinner voting rules. We focus on SNTV, Bloc, k-Borda, and Chamberlin-Courant, as well as on approximate variants of Chamberlin-Courant, since the original rule is NP-hard to compute. We show that SHIFT BRIBERY tends to be significantly harder in the multiwinner setting than in the single-winner one by showing settings where SHIFT BRIBERY is easy in the single-winner cases, but is hard (and hard to approximate) in the multiwinner ones. Moreover, we show that the non-monotonicity of those rules which are based on approximation algorithms for the Chamberlin-Courant rule sometimes affects the complexity of SHIFT BRIBERY.

## Authors

• 21 publications
• 19 publications
• 57 publications
• 35 publications
• ### Manipulability of Single Transferable Vote

For many voting rules, it is NP-hard to compute a successful manipulatio...
11/19/2009 ∙ by Toby Walsh, et al. ∙ 0

• ### Algorithms for Destructive Shift Bribery

We study the complexity of Destructive Shift Bribery. In this problem, w...
10/03/2018 ∙ by Andrzej Kaczmarczyk, et al. ∙ 0

• ### An Efficient Generalized Shift-Rule for the Prefer-Max De Bruijn Sequence

One of the fundamental ways to construct De Bruijn sequences is by using...
01/30/2018 ∙ by Gal Amram, et al. ∙ 0

• ### Complexity of and Algorithms for Borda Manipulation

We prove that it is NP-hard for a coalition of two manipulators to compu...
05/27/2011 ∙ by Jessica Davies, et al. ∙ 0

• ### Achieving Fully Proportional Representation: Approximability Results

We study the complexity of (approximate) winner determination under the ...
12/14/2013 ∙ by Piotr Skowron, et al. ∙ 0

• ### On Choosing Committees Based on Approval Votes in the Presence of Outliers

We study the computational complexity of committee selection problem for...
11/13/2015 ∙ by Palash Dey, et al. ∙ 0

• ### A Quantitative Analysis of Multi-Winner Rules

To choose a multi-winner rule, i.e., a voting rule that selects a subset...
01/04/2018 ∙ by Martin Lackner, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

We study the complexity of campaign management—modeled as the Shift Bribery problem—for the case of multiwinner elections. In the Shift Bribery problem we want to ensure that our candidate is in a winning committee by convincing some of the voters—at a given price—to rank him or her more favorably. In particular, this models campaigns based on direct meetings with voters, in which the campaigner presents positive features of the candidate he or she works for. While the complexity of campaign management is relatively well-studied for single-winner elections, it has not been studied for the multiwinner setting yet (there are, however, studies of manipulation and control for multiwinner elections [29, 2]).

Based on the preferences of the voters, the goal of a multiwinner election is to pick a committee of candidates. These candidates might, for example, form the country’s next parliament, be a group of people short-listed for a job opening, or be a set of items a company offers to its customers (see the papers of Lu and Boutilier [25], Skowron et al. [34], and Elkind et al. [17] for a varied description of applications of multiwinner voting). Since the election results can affect the voters and the candidates quite significantly, we expect that they will run campaigns to achieve the most desirable results: a person running for parliament would want to promote her or his political platform; a job candidate would want to convince the HR department of her or his qualities.

We study the standard, ordinal model of voting, where each voter ranks the candidates from the one he or she likes best to the one he or she likes least. We focus on rules that are based either on the Borda scores of the candidates or on their -Approval scores. Briefly put, if we have candidates, then a voter gives Borda score to his or her most preferred candidate, score to the next one, and so on; a voter gives -Approval score to each of his or her top- candidates and score to the other ones.

The most basic multiwinner rules simply pick candidates with the highest scores (for example, SNTV uses -Approval scores, Bloc uses -Approval scores, and -Borda uses Borda scores). While such rules may be good for short-listing tasks, they do not seem to perform well for cases where the committee needs to be varied (or represent the voters proportionally; see the work of Elkind et al. [17]). In this case, we may prefer other rules, such as the Chamberlin-Courant family of rules [11], which try to ensure that every voter is represented well by some member of the committee (see the Preliminaries section for an exact definition).

Unfortunately, while the winners of SNTV, Bloc, and -Borda rules are polynomial-time computable, this is not the case for the Chamberlin-Courant rules (Procaccia et al. [32] and Lu and Boutilier [25] show -hardness). We deal with this problem in two ways. First, there are FPT algorithms for computing Chamberlin-Courant winners (for example, for the case of few voters). Second, there are good approximation algorithms (due to Lu and Boutilier [25] and Skowron et al. [35]). Following Caragiannis et al. [10] and Elkind et al. [17], we consider these approximation algorithms as voting rules in their own right (societies may use them in place of the original, hard-to-compute ones).

The idea of the Shift Bribery problem is as follows. We are given an election and a preferred candidate , and we want to ensure that is a winner (in our case, is a member of a winning committee) by shifting him or her forward in some of the votes, at an appropriate cost, without exceeding a given budget. The costs of shifting correspond to investing resources into convincing the voters that our candidate is of high quality. For example, if a company is choosing which of its products to continue selling, the manager responsible for a given product may wish to prepare a demonstration for the company’s higher management. Similarly, a person running for parliament would invest money into meetings with the voters, appropriate leaflets, and so on. Thus, we view Shift Bribery as a model of (a type of) campaign management.

Shift Bribery was introduced by Elkind et al. [16, 15], and since then a number of other researchers studied both Shift Bribery (e.g. Schlotter et al. [33] and Bredereck et al. [7, 9]), and related campaign management problems (e.g. Dorn and Schlotter [13], Baumeister et al. [3], and Faliszewski et al. [20]). Naturally, the problem also resembles other bribery problems, such as the original bribery problem of Faliszewski et al. [19] or those studied by Mattei et al. [28] and Mattei, Goldsmith, and Klapper [27]. We point the reader to the overview of Faliszewski and Rothe [18] for more details and references.

For single-winner elections, Shift Bribery is a relatively easy problem. Specifically, it is polynomial-time solvable for the -Approval rules. For the Borda rule, for which it is -hard, there are a good polynomial-time approximation algorithm [15] and exact algorithms [7]. In the multiwinner setting the situation is quite different. The main findings of our research are as follows (see also Table 1 in Section 3):

1. The computational complexity of Shift Bribery for multiwinner rules strongly depends on the setting. In general, for the cases of few candidates we find algorithms while for the cases where the preferred candidate is shifted by few positions only we find hardness results (even though these cases are often easy in the single-winner setting).

2. The computational complexity for the case of few voters most strongly depends on the underlying scoring rule. Generally, for the rules based on -Approval scores the complexity of Shift Bribery tends to be lower than for analogous rules based on Borda scores.

We did not study such multiwinner rules as the STV rule, the Monroe rule [30], or other Approval-based rules (see, e.g., the works of Brams and Kilgour [5] and Aziz et al. [1, 2]), in order to compare our results to those for the single-winner setting, while keeping the considered set of rules small.

## 2 Preliminaries

Elections and Voting Rules. For each integer , we set . An election  consists of a set of candidates and a collection of voters . Each voter is associated with a preference order, i.e., with a ranking of the candidates in decreasing order of appreciation by the voter. For example, if , then by writing we mean that  likes  best, then , and then . We write  to denote the position of candidate  in voter ’s preference order (e.g., in the preceding example we would have ). When we write a subset  of candidates in a description of a preference order, we mean listing all members of  in some fixed, easily computable order. If we put  in a preference order, then we mean listing members of  in the reverse of this fixed order.

Let be an election with  candidates and  voters. The Borda score of candidate  in the vote of , , is . The Borda score of  in the election  is . The single-winner Borda rule elects the candidate with the highest Borda score (if there are several such candidates, they tie as winners). For each , we define the -Approval score as follows: for a candidate  and voter , if  ranks  among the top  positions and otherwise it is ; we set . We define the single-winner -Approval rule analogously to the Borda rule.

A multiwinner voting rule  is a function that, given an election  and an integer , outputs a set of -element subsets of . Each size- subset of is called a committee and each member of is called a winning committee.

The most natural task that arises when considering (multiwinner) voting rules is the task of deciding whether a given candidate is among the winners (resp. is part of some winning committee). We will refer to this task as the Winner Determination problem. Sometimes, winner determination procedures considered in the literature consider slightly different goals (e.g. computing the score of a winning committee). However, all polynomial-time, , and winner determination procedures for the rules we study in this paper can be modified to solve Winner Determination.

We consider the following rules (below, is an election and is the committee size):

SNTV, Bloc, and -Borda compute the score of each candidate and output the committee of  candidates with the highest scores (or all such committees, if there are several). SNTV and Bloc use, respectively, -Approval and -Approval scores, while -Borda uses Borda scores. For these rules winners can be computed in polynomial time.333There may be exponentially many winning committees, but it is easy to compute their score and to check for a subset of candidates if it can be extended to a winning committee.

Under the Chamberlin-Courant rules (the CC rules), for a committee , a candidate  is a representative of those voters that rank highest among the members of . The score of a committee is the sum of the scores that the voters give to their representatives (highest-scoring committees win); Borda-CC uses Borda scores, -Approval-CC uses -Approval scores. Winner Determination for CC rules is -hard [32, 25], but is in  when parameterized by the number of voters or candidates [4].

Greedy-Borda-CC is a -approximation algorithm for the Borda-CC rule, due to Lu and Boutilier [25]. (The approximation is in the sense that the score of the committee output by the algorithm is at least a fraction of the score of the winning committee under Borda-CC.) The algorithm starts with an empty set  and executes  iterations, in each one adding to  the candidate  that maximizes the Borda-CC score of .444If there is a tie between several candidates, then we assume that the algorithm breaks it according to a prespecified order. For example, it always picks a Borda winner in the first iteration. Greedy-Borda-CC always outputs a unique winning committee.

Greedy-Approval-CC works in the same way, but uses -Approval scores instead of Borda scores. It is a -approximation algorithm for -Approval-CC. We refer to -Approval-Greedy-CC for (where is Lambert’s W function; is ) as PTAS-CC; it is the main part of Skowron et al.’s [35] polynomial-time approximation scheme for Borda-CC.

Parameterized Complexity. In a parameterized problem, we declare some part of the input as the parameter (e.g., the number of voters). A parameterized problem is fixed-parameter tractable (is in ) if there is an algorithm that solves it in time, where is the size of a given instance encoding, is the value of the parameter, and is some computable function. There is a hierarchy of classes of hard parameterized problems, . It is widely believed that if a problem is hard for one of the classes, then it is not in . The notions of hardness and completeness for parameterized classes are defined through parameterized reductions. For this paper, it suffices to use standard polynomial-time many-one reductions that guarantee that the value of the parameter in the problem we reduce to exclusively depends on the value of the parameter of the problem we reduce from. The following problems will be used in our reductions.

###### Definition 1.

An instance of Clique consists of a graph and an integer . We ask whether there is a set of vertices such that there is an edge between each two vertices from the set.

###### Definition 2.

An instance of Multicolored Independent Set consists of a graph , where each vertex has one of colors. We ask whether there are vertices of pairwise-distinct colors such that no two of them are connected by an edge.

###### Definition 3.

An instance of Set Cover consists of a set  of elements, a family  of subsets of , and and integer . We ask whether there is a subset of sets from whose union is .

Clique and Multicolored Independent Set are both -complete while Set Cover is -complete (in all cases, the solutions size is the parameter).

If a parameterized problem can be solved in polynomial time under the assumption that the parameter is constant, then we say that it is in . Recall that membership in additionally requires that the degree of the polynomial is a constant independent from the parameter. If a problem is -hard even for some constant value of the parameter, then we say that it is para--hard.

For details on parameterized complexity, we point to the books of Cygan et al. [12], Downey and Fellows [14], Flum and Grohe [21], and Niedermeier [31].

## 3 Shift Bribery

Let be a multiwinner rule. In the -Shift Bribery problem we are given an election with  candidates and  voters, a preferred candidate , a committee size , voter price functions (see below), and an integer , the budget. The goal is to ensure that belongs to at least one winning committee (according to the rule ),555Our approach is a natural extension of the non-unique winner model from the world of single-winner rules. Naturally, one might alternatively require that is a member of all winning committees or put an even more demanding goal that would involve other candidates. We refer to a brief discussion in the Conclusion section. and to achieve this goal we are allowed to shift  forward in the preference orders of the voters. However, each voter  has a price function , and if we shift  by  positions forward in the vote of , then we have to pay . We assume that the price functions are nondecreasing (i.e., it cannot cost less to shift our candidate farther than to shift her or him nearer) and that the cost of not shifting  is zero (i.e., for each ). Bredereck et al. [7] have considered several different families of price functions. In this paper we focus on two of them: unit price functions, where for each voter  it holds that , and all-or-nothing price functions, where for each voter  it holds that for each (where is some voter-dependent value) and .

A shift action is a vector

of natural numbers, that for each voter specifies by how many positions to shift . If is a shift action, then we write to denote the election obtained from  by shifting  an appropriate number of positions forward in each vote. If are the price functions of the  voters, then we write to denote the total cost of applying . For a shift action , we define and we call it the number of unit shifts in .

Formally, we define -Shift Bribery as follows.

###### Definition 4.

Let be a multiwinner voting rule. An instance  of -Shift Bribery consists of an election , a preferred candidate , a committee size , a collection of price functions for the voters, and an integer , the budget. We ask whether there is a shift action such that:

1. , and

2. there is a committee such that .

We refer to such a shift action as a successful shift action; we write to denote the cost of the least expensive successful shift action.

Following Bredereck et al. [7], we consider the most natural parameterizations by the number  of voters, by the number  of candidates, and by the minimum number  of unit shifts in a successful shift action.

Now, we formally defined all central concepts and problems studied in this work, using this, Table 1 summarizes our and some previous results. The reminder of this paper is structured as follows. In Section 4, we present findings applying to the multiwinner context as a whole. In Section 5, we present specific results for the voting rules SNTV, Bloc, and -Borda. In Section 6, we present our results for Chamberlin-Courant rules and their approximate variants. We conclude with a final discussion and an outlook in Section 7.

## 4 General Results

We start our discussion by providing several results that either apply to whole classes of multiwinner rules (including many of those that we focus on) or that are proven using general, easily adaptable techniques. These results form a baseline for our research regarding specific rules.

First, we note that for each of the rules that we study, Shift Bribery with unit price functions is in

when parameterized by the number of candidates. This result follows by applying the standard technique of modeling the problem through an integer linear program and invoking Lenstra’s theorem

[24]. We believe that, using the MILP technique of Bredereck et al. [8], it is also possible to generalize this result to all-or-nothing price functions.

Note that the following theorem does not mention SNTV and Bloc since, as we will see in the next section, for them the problem is even in .

###### Theorem 1.

Parameterized by the number of candidates, Shift Bribery with unit prices is in for -Borda, Approval-CC, Borda-CC, Greedy-Approval-CC, PTAS-CC, and Greedy-Borda-CC.

In order to prove Theorem 1, we introduce an algorithmic scheme similar to that of Dorn and Schlotter [13] for single-winner Swap Bribery. We will make use of the fact that integer linear programs (ILPs) can be solved in FPT time with respect to the number of (integer) variables (following a famous result by Lenstra [24] which was later improved by Kannan [23] and by Fredman and Tarjan [22]). We first introduce the algorithmic scheme and the basic ILP formulation. Then, we show how to extend the ILP such that the algorithmic scheme works for -Borda (by proving Lemma 1), for Approval-CC and Borda-CC (by proving Lemma 2), and for Greedy-Approval-CC, PTAS-CC, and Greedy-Borda-CC (by proving Lemma 3).

The idea of the algorithmic scheme is to guess the members of the winning committee , , , and to verify the guess by an ILP. More precisely, we try all possible winning committees in the outer loop of our algorithm and call the corresponding ILP for each of the (less than ) potential winning committees that contain . For the round-based rules (Greedy-Approval-CC, PTAS-CC, and Greedy-Borda-CC) we furthermore guess a function mapping each “position” in the committee to a specific candidate from . This allows to specify when each member joined the committee according to the round-based rules and can be realized with an additional factor of to the running time. For the ease of presentation let  denote the set containing the first  members according to the function , that is, .

Observe that there are different preference orders, and, by ordering them arbitrarily, we can consider the th preference order (for ).

For each and we create an integer variable which represents the number of voters which vote as the th preference order in the original election and vote as the th preference order in the bribed election. Based on these variables we add the following constraints for each , ensuring that each original vote is turned into exactly one bribed vote:

 ∑j∈[m!]Si,j=\#(i),

where # denotes the number of voters which vote as the th preference order in the original election. Then, we add the following constraint, ensuring that the cost of our bribery action does not exceed the budget:

 ∑i∈[m!],j∈[m!]Si,j⋅cost(i,j)≤B,

where is the budget needed to transform the th preference order to the th preference order (and, for formal correctness, equals if it is not possible at all by shifting only ).

For each we create an integer variable which represents the number of voters which vote as the th preference order in the bribed election. Based on the variables, we make sure that the  variables are correct, by adding, for each , the following constraint:

 Ni=∑j∈[m!]Sj,i.

This describes the basic ILP which will be extended in the proofs of the following lemmas.

###### Lemma 1.

Parameterized by the number of candidates, -Borda Shift Bribery is in FPT.

###### Proof.

To make  a member of the winning committee for -Borda we have to ensure that only the other members of the winner committee may have a larger Borda score than . Hence, for each , we add the following constraint to the basic ILP, ensuring that, in the bribed election,  has at least as much Borda score (based on the variables) as all candidates that are not in the winning committee:

 ∑i∈[m!]Ni⋅βi(p)≥∑i∈[m!]Ni⋅βi(c),

where is the Borda score of candidate  in the th preference order.

This finishes the description of the extended ILP. ∎

###### Lemma 2.

Parameterized by the number  of candidates, both Approval-CC Shift Bribery and Borda-CC Shift Bribery are in .

###### Proof.

To make  a member of the winning committee  for Approval-CC (respectively, Borda-CC) we have to ensure that no other committee has a larger Approval score (respectively, Borda score) than our guessed committee . Hence, for each other committee , we add the following constraint to the basic ILP, ensuring that, in the bribed election, the score of  (based on the  variables) is at least as high as the score of :

 ∑i∈[m!]ϕ(i,W)⋅Ni≥∑i∈[m!]ϕ(i,W′)⋅Ni,

where is the score given by a voter voting as the th preference order to the committee . Note that this can be computed in polynomial-time by selecting the right representative and taking the underlying scoring rule, that is, either Approval or Borda, into account.

This finishes the description of the extended ILP. ∎

###### Lemma 3.

Parameterized by the number  of candidates, Shift Bribery is in for Greedy-Approval-CC, PTAS-CC, and Greedy-Borda-CC.

###### Proof.

Since PTAS-CC is a special case of Greedy-Approval-CC it suffices to describe the extension of the ILP for Greedy-Approval-CC and Greedy-Borda-CC.

To make  a member of the winning committee  for Greedy-Approval-CC (respectively, Greedy-Borda-CC) we have to ensure that the candidate  (which joined to the committee in the th round) maximizes the Approval score (respectively, Borda score) among all possible extensions. Hence, for each round  and each we add the following constraint to the basic ILP, ensuring that, in the bribed election, the score of  is at least as large as the score of :

 ∑i∈[m!]ϕ(i,Wj)⋅Ni≥∑i∈[m!]ϕ(i,Wj−1∪{c})⋅Ni,

where is the score given by a voter voting as the th preference order to the committee .

This finishes the description of the extended ILP. ∎

As second general result, we note that for the parameterization by the number of voters we can provide a strong, general approximation scheme for candidate-monotone rules. Candidate monotonicity, a notion introduced by Elkind et al. [17], requires that if a member of a winning committee is shifted forward in some vote, then this candidate still belongs to some (possibly different) winning committee.

###### Theorem 2.

Consider parameterization by the number of voters. Let be a candidate-monotone multiwinner rule with an algorithm for Winner Determination. Then, for every positive constant number  there is an algorithm that, given an instance  of -Shift Bribery (for arbitrary price functions), outputs a successful shift action with cost at most .

###### Proof.

Bredereck et al. [7] show an algorithm (parameterized by the number of voters) that, given an instance  of Shift Bribery and a positive value , for each possible shift action tries a shift action such that for each we have , and the cost of is at most greater than that of . This algorithm also works for multiwinner rules. ∎

Among the rules considered in this work, only Greedy-Borda-CC, Greedy-Approval-CC, and PTAS-CC are not candidate-monotone (see the work of Elkind et al. [17] for the argument regarding Greedy-Borda-CC). Thus, the above result applies to all the remaining rules.

For the case of all-or-nothing prices, we can strengthen the above result to an exact algorithm.

###### Proposition 1.

Consider parameterization by the number of voters. Let be a candidate-monotone multiwinner rule with an algorithm for Winner Determination. Then, there is an algorithm for -Shift Bribery with all-or-nothing price functions.

###### Proof.

Since is candidate-monotone and we have all-or-nothing prices, for every vote where we shift the candidate  forward, we can shift  to the top. In effect, it suffices to try all subsets of voters: For each subset check whether shifting  forward in each vote from the subset ensures the victory of  without exceeding the budget. ∎

Using a very similar approach, we can solve Shift Bribery for those of our rules which are based on approval scores, even for arbitrary price functions (even the round-based ones). The trick is that, with approval scores, for each voter we either shift our candidate right to the first approved position or we do not shift him or her at all. Thus, again, trying all subsets of voters suffices.

###### Proposition 2.

There is an algorithm for Shift Bribery under Approval-CC, Greedy-Approval-CC, and PTAS-CC, for the parameterization by the number of voters and for arbitrary price functions.

Finally, using smart brute-force, we provide algorithms for Shift Bribery parameterized either by the number of voters or the number of unit shifts (for rules that can be efficiently computed in the given setting).

###### Proposition 3.

Consider parameterization by the number of voters. Then, for every multiwinner rule with an algorithm for Winner Determination, there is an algorithm for Shift Bribery and arbitrary price functions.

###### Proof.

For each voter, we guess the amount which the preferred candidate is shifted by. Since the maximum amount is , and we have voters, we have possibilities to check. For each possibility we check if the preferred candidate is a member of a winning committee in time. ∎

###### Proposition 4.

Consider parameterization by the number of unit shifts. Then, for every multiwinner rule with a polynomial-time algorithm for Winner Determination, there is an algorithm for Shift Bribery and arbitrary price functions.

###### Proof.

The idea of the proof is similar to that behind Proposition 3. Let be the number of unit shifts that we can perform and let be the number of voters. We can view a solution as a vector of length at most , where an entry in the th position specifies the number of voters in whose preference order we perform the th unit shifts. We try all such vectors and for each we test if the shift action it defines is within budget and ensures that the preferred candidate is in the winning committee. ∎

## 5 SNTV, Bloc, and k-Borda

We now move on to results specific to the voting rules SNTV, Bloc, and -Borda. These rules pick candidates with the highest -Approval, -Approval, and Borda scores, respectively, and, so, one might suspect that the efficient algorithms for corresponding single-winner rules would translate to the multiwinner setting. While this is the case for SNTV and Bloc, for -Borda the situation is more intricate. As a side effect of our research, we resolve the parameterized complexity of Borda-Shift Bribery, left open by Bredereck et al. [7].

We first show that Shift Bribery is polynomial-time solvable for SNTV and Bloc. We use the same algorithm for both SNTV and Bloc. Briefly put, the idea is to guess the final score of the preferred candidate and to compute the set of candidates that have higher scores. Then, it is easy to compute the cheapest way to ensure that all but of them, where is the committee size, have smaller score than the guessed score of , while ensuring that indeed obtains this guessed score.

###### Theorem 3.

SNTV-Shift Bribery and Bloc-Shift Bribery are both in (for arbitrary price functions).

###### Proof.

We use the same algorithm for both SNTV and Bloc. Consider an input instance with an election , where is the preferred candidate, and where the committee size is . Our algorithm proceeds as follows.

As first step, we guess the final score that would have after a successful bribery, denoted by . Since there are only polynomially many possibilities, we can simply branch into all possible values of to realize the first step. Then, we consider the set of those candidates whose score is greater than . It is clear that to ensure that is in some winning committee, we need to decrease the score of all but candidates from . If contains at most candidates, we do not need to decrease the scores of any candidates.

To this end, we sort the candidates in by the cost of decreasing their score (by appropriate shifts of ) to be equal to , and pick all of the candidates in , besides the most expensive ones. Since for each bribed vote one can decrease the score of exactly one candidate, this defines a shift action. If this shift action does not guarantee that has score , then we complement it by shifting to the first approved position in sufficiently many cheapest votes, to ensure that has score .

If the thus computed shift action is within budget, we accept. Otherwise, we try another guess of . If we try all possibilities without accepting, then we reject. ∎

The situation for -Borda is different. Shift Bribery is -hard for Borda due to Elkind et al. [16], so the same holds for -Borda. We show that Borda-Shift Bribery is -hard for parameterization by the number of voters, resolving a previously open case [7]. This result immediately implies the same hardness for all our Borda-based rules.

###### Theorem 4.

Parameterized by the number of voters, Borda Shift Bribery is -hard (even for unit price functions).

###### Proof.

We give a parameterized reduction from the Multicolored Independent Set problem. Let  be our input instance. Without loss of generality, we assume that the number of vertices of each color is the same and that there are no edges between vertices of the same color. We write to denote the set of ’s vertices, and to denote the set of ’s edges. Further, for every color , we write to denote the set of vertices of color . For each vertex , we write to denote the set of edges incident to . For each vertex , we write to denote its degree, i.e., and we let be the highest degree of a vertex .

We form an instance of Borda-Shift-Bribery as follows. We let the candidate set be

 C={p}∪V(G)∪E(G)∪F(G)∪D′∪D′′,

where , , and are sets of special dummy candidates. For each vertex , we let be a set of dummy candidates, and we let and . We will specify and later. For each vertex , we define the partial preference order to be . For each color , we define to be a partial preference order that ranks first all members of , then all vertex candidates of colors other than , then all edge candidates corresponding to edges that are not incident to a vertex of color , then all dummy vertices from , and finally all candidates from .

We use unit price functions and we set the budget to be . We set  and  to consist of  dummy candidates each.

We create the following voters:

1. For each color , we introduce four voters: voters and with the following preference orders:

 xi: S(v(i)1)≻S(v(i)2)≻⋯≻S(v(i)q)≻p≻R(i), x′i: ←−−−−S(v(i)q)≻←−−−−−S(v(i)q−1)≻⋯≻←−−−−S(v(i)1)≻p≻R(i),

and voters and whose preference orders are reverses of those of and , respectively, except that candidates from  are ranked last in their votes as well.

2. We create a voter  with the preference order

 z:F(G)≻V(G)≻E(G)≻D′≻p≻D′′,

and a voter with the preference order that is obtained from that of  by first reversing it, and then shifting each member of by one position forward, and shifting by positions back.

Let be the score of prior to executing any shift actions. The scores of the candidates in our election are as follows: each candidate in has score , and each candidate in has score at most .

We show that it is possible to ensure the victory of in our election by a bribery of cost at most  if and only if there is a multicolored independent set for of size .

For the “if” case, we show that if has a multicolored independent set, then there is a successful shift action of cost in our election. Let us fix a multicolored independent set for and, for each color , let be the vertex of color from this set. For each pair of voters , we shift so that in he or she ends up right in front of (or does not move if ), and in he or she ends up right in front of . This way, passes every vertex candidate from and every edge candidate from . This shift action costs for every pair of voters , so, in total, costs exactly . Further, clearly, it ensures that passes every vertex candidate so each of them has score . Finally, since we chose vertices from an independent set, every edge candidate also has score at most : If does not pass some edge  between vertices of colors  and  for a pair of voters , then certainly passes in the pair of votes because and are not adjacent.

For the “only if” case, we show that if there is a successful shift action for our instance, then there is a multicolored independent set for . We note that a shift action of cost gives score . Thus, for the shift action to be successful, it has to cause all candidates in to lose a point. We claim that a successful shift bribery has to use exactly unit shifts for every pair of voters , . Why is this so? Let us fix some color . Every successful shift action has to decrease the score of every vertex candidate and , are the only votes where can pass the vertex candidates from without exceeding the budget. If we spend less than units of budget on , then there will be some vertex candidates corresponding to a vertex from that did not pass (and, in effect, which does not lose a point), and so will not be a winner. Thus, we know that a successful shift action spends units of budget on every pair of voters . Further, we can assume that for each color  there is a vertex such that in candidate  is shifted to be right in front of and in candidate  is shifted to be right in front of . We call such a vertex selected. If for a given pair of voters neither of the vertices from  was selected, then there would be some vertex candidate in  that does not pass. If for some pair of voters vertex is selected, then in this pair of votes does not pass the edge candidates from . However, this means that in a successful shift action the selected vertices form an independent set of . If two vertices and were selected, , and if there were an edge connecting them, then would not pass the candidate  in either of the pairs of votes or . Since these are the only votes where can pass  without exceeding the budget, in this case would have points, would have points and would lose. ∎

In effect, we have the following corollary (we discuss other Borda-based rules later).

###### Corollary 1.

Parameterized by the number of voters, -Borda-Shift Bribery is -hard.

Corollary 1 shows that the approximation scheme from Theorem 2 can presumably not be replaced by an algorithm. By Proposition 1, we also know that -Borda-Shift Bribery is in for all-or-nothing prices and the parameterization by the number of voters.

The next result is, perhaps, even more surprising than Theorem 4: It turns out that -Borda-Shift Bribery is -hard also for the parameterization by the number of unit shifts, whereas Borda-Shift Bribery is in . To this end, we describe a parameterized reduction from Clique.

###### Theorem 5.

Parameterized by the number of unit shifts, -Borda Shift Bribery is -hard.

###### Proof.

We provide a parameterized reduction from the -complete Clique problem in which we are given a graph with and and we ask whether there is a set of pairwise adjacent vertices in .

Given an instance for the Clique problem, create an instance for -Borda Shift Bribery as follows. Set the budget , use unit price functions, and set the size of the committee . The candidate set is , where the sets and  are defined as follows. Let be a set of dummy candidates and for each edge from the graph let be a set of dummy candidates. Set . Define to contain dummy candidates.

We form the set of voters as follows:

1. For each edge from we introduce voter with preference order: and voter whose preference order is the reverse of that of  with candidates from shifted to the bottom positions.

2. We introduce two voters, and , where has preference order and has preference order .

All vertex candidates have the same score in this election, and we denote it by . Candidate has score , and all remaining candidates have score lower than (note that we can assume that has more than edges as otherwise it certainly does not contain a size- clique). Intuitively, shifting to the top positions in votes corresponding to a size- clique is the only way to ensure ’s victory

It remains to show the correctness of the construction. More precisely, we show that contains a clique of size if and only if there is a successful shift action for our instance of -Borda-Shift Bribery.

For the “only if” case, assume that there is a clique if size  in . Then, a successful bribery can shift to the front of all voters corresponding to the edges inside this clique. This gives additional points and causes each vertex from the clique to lose points. In effect, there are vertex candidates with score higher than that of and vertex candidates with the same score as . Since all other candidates already had lower scores,  belongs to at least one winning committee.

For the “if” case, note that can join some winning committee only if at least vertex candidates lose points each. Without exceeding the budget, can pass vertex candidates only in votes. Through simple arithmetic, we see that within a given budget we can shift to pass some vertex candidates in at most of these votes and, so, in each of them we can shift to the top position. That is, a successful shift action passes vertices corresponding to edges. This can lead to candidates losing at least points each (or, in fact, exactly points each) only if these edges form a size- clique. ∎

## 6 Chamberlin-Courant and Its Variants

We now move on to the Chamberlin-Courant (CC) rules and their approximate variants. These rules try to find a committee such that every voter is represented well by some member of the committee. Recall that Winner determination for Borda-CC and Approval-CC is NP-hard but can be solved efficiently for the approximate variants. To some extend, this difference in the computational complexity is also reflected by our finding for Shift Bribery.

Note that many results for the CC-based rules (see also Table 1) follow from our results from previous sections. For the parameterizations by the number of candidates, Theorem 1 gives results for all CC-based rules. For the parameterization by the number of voters, by Proposition 2 we have results for Approval-CC, Greedy-Approval-CC, and PTAS-CC. We inherit -hardness for Borda-CC and Greedy-Borda-CC from Theorem 4, since both rules coincide with the single-winner Borda rule in case of committee size .

###### Corollary 2.

Shift Bribery parameterized by the number of voters is -hard for Borda-CC and for Greedy-Borda-CC even for unit price functions.

By Theorem 2, we have that there is an approximation scheme for Borda-CC. However, since Theorem 2 strongly relies on candidate monotonicity of the rule, it does not apply to Greedy-Borda-CC. Indeed, we believe that there is no constant-factor approximation algorithm for Greedy-Borda-CC-Shift Bribery (parameterized by the number of voters). So far we could prove this only for the case of weighted elections, i.e., for the case where each voter has an integer weight and counts as separate voters for computing the result of the election (but not for the computation of the parameter). On the one hand, one could say that using weighted votes goes against the spirit of parameterization by the number of voters and, to some extent, we agree. On the other hand, however, all our results for parameterization by the number of voters (including the approximation scheme) do hold for the weighted case. By a parameterized reduction from the Multicolored Clique problem, we obtain the following.

###### Theorem 6.

Unless , Greedy-Borda-CC-Shift Bribery with weighted votes is not -approximable for any constant , even in time with respect to the number of voters and even for unit price functions.

###### Proof.

We first prove -hardness of the problem and then argue that this proof implies the claimed inapproximability result.

We give a reduction from the Multicolored Clique problem for the case of regular graphs which is -complete for the parameter solution size  (e.g. [26, Lemma 3.2]). To this end, let be our input graph and let be the size of the desired clique (and the number of vertex colors). We use the following notation. For each color , we let be the set of vertices from with color . For each vertex , we write to denote the set of edges incident to . Since is regular, we let be the common degree of all the vertices (i.e., for each vertex , ). For each pair of distinct colors , , we write to denote the set of edges between vertices of color and vertices of color .

We make the following observation regarding Greedy-Borda-CC. In each iteration it picks a candidate with the highest score, where this score is computed as follows: Let be the set of candidates already selected by Greedy-Borda-CC at this point. Consider candidate and voter , and let be the candidate from that ranks highest. Voter gives points to (i.e., the number of points by which adding to would increase the score of ’s representative). The score of a candidate in a given iteration is the sum of the scores it receives from all the voters.

We form an instance of Greedy-Borda-CC-Shift Bribery as follows.

The candidates. We let the candidate set be , where is the preferred candidate, is ’s direct competitor in the sense that either  or  will be the committee, is the “bar” candidate (see explanation below), and is a set of dummy candidates. Throughout the construction we will introduce many dummy candidates and we do not give them special names; at the end of the construction it will be clear that we add only polynomially many of them. We will ensure that , the bar candidate, is always chosen first into the committee, so—in essence—the scores of all other candidates can be computed relative to . So when we describe a preference order, we list only top parts of the voters’ preference orders, until candidate . Candidate  is ranked last in every vote in which we do not explicitly require otherwise.

We also use the following notation in the descriptions of the preference orders. For a number , by writing in a preference order we mean introducing new dummy candidates that are put in the following positions in this preference order, but that in every other preference order are ranked below (and, thus, after is selected receive no points from these voters).

The voters. We introduce the following voters, where , , , and are four large numbers such that is much bigger than , is much bigger than , and is much bigger than ; we will provide their exact values later. Each voter has weight one unless specified otherwise.

1. For each color , we introduce two vertex-score voters with the following preference orders:

 V(i)≻[N⋅(Tv−i)]≻b, ←−−V(i)≻[N⋅(Tv−i)]≻b,

and two vertex-selection voters with the following preference orders:

 V(i)≻p≻b, ←−−V(i)≻p≻b.
2. For each pair of distinct colors , , we introduce two edge-score voters with the following preference orders:

 E(i,j)≻[N⋅(Te−(i⋅h+j))]≻b, ←−−−−E(i,j)≻[N⋅(Te−(i⋅h+j))]≻b,

and two edge-selection voters with the following preference orders:

 E(i,j)≻p≻b, ←−−−−E(i,j)≻p≻b.

Each of the edge-selection voters has weight (and these are the only voters with non-unit weights).

3. For each color we introduce two verification voters with the following preference orders:

 p≻v(i)1≻E(v(i)1)≻⋯≻v(i)n≻E(v(i)n)≻b, p≻v(i)n≻←−−−−E(v(i)n)≻⋯≻v(i)1≻←−−−−E(v(i)1)≻b.
4. We introduce the following two voters, the -score voters, with the following preference orders:

 p′≻[N⋅Tp]≻b, p≻[N⋅Tp+h(n+1)(d+1)]≻b.
5. Let be the total weight of voters introduced so far (clearly, is polynomially upper-bounded in the input size of the Multicolored Clique instance ). We introduce pairs of voters with preference orders and . We refer to these voters as the bar-score voters.

We assume that the internal tie-breaking prefers to —we could modify the construction slightly if it were the other way round.

Committee size and budget. We set the committee size to be . We use unit prices for the voters and we set the budget .

We claim that for an appropriate choice of , , , and it is possible to ensure that is in a winning committee if and only if there is multicolored size- clique for . We now argue why this is the case.

The idea. The general idea is to show that every shift action (even the zero-vector, that means not bribing the voters) of costs at most  leads to a committee that contains

1. the bar vertex ,

2. for each color  one candidate corresponding to a vertex of color ,

3. for each color pair  one candidate corresponding to an edge incident to a vertex of color  and to a vertex of color

4. candidate  if the selected vertices and edges encode a multicolored clique; otherwise the committee contains .

Furthermore, any such combination of vertices and edges can be selected within the given budget, that is, there is a successful shift action if a multicolored clique of size  exists.

Correctness. Observe that due to the bar-score voters, irrespective how we shift within the budget, Greedy-Borda-CC will first choose . Thus, from this point on, we compute the score of all candidates relative to (and, in later rounds, the other selected members of the committee, but there is a limited number of such interactions).

We now describe the next rounds, first describing the situation as if were not shifted, and then indicate how it could be changed with appropriate shifts.

After the first iteration, when is selected, for each color , every vertex in has score:

 (2N⋅(Tv−i)+(n+1))vertex score voters+(2n+3)vertex-selection voters+((n+1)(d+1))% verification voters.

The points in the first bracket come from the vertex-score voters, in the second bracket from the vertex-selection voters, and in the last bracket from the verification voters. Further, since is much larger than and , every non-vertex candidate has significantly lower score.

Thus, in the next rounds, for each color , Greedy-Borda-CC adds into the committee one vertex candidate of color . Note that as soon as it picks some vertex candidate of color , the score of all the other vertex candidates of this color immediately drops by at least and, so, their score is much too low to be selected.

By shifting candidate in the vertex-selection votes, for each color and each vertex in  it is possible to ensure that exactly this vertex is selected (it suffices to ensure that every other vertex candidate of this color loses one point due to passing him or her). The costs of such shifts are at most in total.

In other words, we can assume that after these iterations Greedy-Borda-CC picks one vertex candidate of each color, and that by shift action of cost at most it is possible to choose precisely which ones.

In the next iterations, Greedy-Borda-CC picks one edge candidate for each pair of colors. Not counting the verification voters, for each pair of colors , , every edge candidate connecting vertices of colors and has score:

 (N(Te−(i⋅h+j))+|E(i,j)|+1)edge-score% voters+(ω(|E(i,j)|+2))edge-selection voters,

where the points from the first bracket come from the edge-score voters and the points in the second bracket come from the edge-selection voters. Further, every such candidate receives less than points from the verification voters.

Since is much larger than , and since by shifting forward in the votes of edge-selection voters it is possible to remove points from the scores of all but one edge candidate in each . Moreover, it is possible to precisely select for each which of its members is added to the committee with a shift action of total cost . Analogously to the case of vertices, note that whenever some candidate from is selected, the other ones lose so many points that they have no chance of being selected in any of the following iterations.

In the final iteration, the algorithm either selects or . Candidate has score , whereas the score of depends on the vertex and edge candidates that were so far introduced into the committee. If we disregarded all committee members selected after , would have score:

 N⋅Tp+h(n+1)(d+1).

For each color , however, loses points from the verification voters. This is true since some candidate from is in the committee, we compute ’s score relative to this vertex candidate and not relative to . If these were the only points that loses due to the committee members already selected, then—by tie-breaking— would win against . However, if for some pair of colors , , the committee contains some edge that connects vertices that are not both in the committee, then loses at least one more point from the verification voters (either for color or for color or for both) because at least one of these verification voters ranks ahead of all the vertex candidates from the committee. Then is selected. This means that ends up in the committee if and only if due to an appropriate shift action we select vertices and edges corresponding to a multicolored clique. This proves the correctness of the reduction for an appropriate choice of , , , and , which is discussed next.

The values of , , , and . While one could pick tight precise values, for the correctness of the proof it suffices to take, say, , , , and .

Finally, we finally discuss the inapproximability result that is implied by our reduction.

Inapproximability. Observe that, in fact, the above proof gives our inapproximability result. The reason is that for a given constant factor , we could increase by the same factor and it would be impossible for to pass the bar candidate in any of the votes, even if we were to spend times the necessary budget. In effect, for to succeed we would still have to find a multicolored clique. ∎

For the parameterization by the number of unit shift actions, both Borda-CC and Approval-CC are para--hard due to the hardness of Winner Determination.666The literature [25, 32] speaks of hardness of computing the score of a winning committee, but one can show that deciding whether a given candidate is in some winning committee is -hard as well. For Greedy-Approval-CC, PTAS-CC, and Greedy-Borda-CC we obtain -hardness results and inapproximability results.

###### Theorem 7.

Parameterized by the total number  of unit shifts, Shift Bribery is -hard even in case of unit prices for Greedy-Borda-CC, Greedy-Approval-CC, and PTAS-CC. Further, unless , in these cases the problem is not -approximable for any constant .

###### Proof.

First, we show the result for Greedy-Approval-CC for -Approval satisfaction function with (which includes PTAS-CC). Second, we show how the proof ideas can be adapted to obtain the same result for Greedy-Borda-CC.

### Greedy-Approcal-CC.

We reduce from the Set Cover problem which is -hard parameterized by the set cover size . Given an instance of Set Cover with denoting the given sets over the universe , we construct a Greedy-Approval-CC Shift Bribery instance as follows.

Important candidates. Our election will consist of important candidates: For each element  we create two element candidates  and . Analogously, we create two set candidates  and  for each set . Furthermore, we create the preferred candidate  and a candidate .

Dummy candidate. For each voter (to be specified later), we introduce up to further dummy candidates. The dummy candidates will not have any chance to be part of the committee, because each of them will only be approved once and there are enough important candidates that have at least two approvals no matter how one bribes the election. However, the dummy candidates intuitively allow some voter to approve any number , , of important candidates by approving the desired set of important candidates and some further dummy candidates which are exclusively approved by this voter.

We have basically everything needed to explain the rough idea of the construction.

The idea. In the unbribed election the candidates  and  for each and together with the candidate  are elected as committee. The decisive direct effect of successfully bribing the voters will be to decrease the score of at most  candidates . Doing this will replace the corresponding with in the committee. Furthermore, each  with for some replaced candidate  will then be replaced by . Finally our preferred candidate  will replace candidate  in the committee if and only if is replaced by the corresponding  for each .

Committee size and budget. As already indicated in the description of the idea, we set the budget equal to the size  of the set cover and the committee size to .

Next, we discuss the voters of the election that allow us to implement the above idea.

Specifying the voters. Observe that for Greedy-Approval-CC Shift Bribery, specifying the set of approved candidates, the last-ranked approved candidate, that is, the candidate at position , and the price for shifting the preferred candidate  to position  completely describes the influence of a voter to the unbribed and bribed election: Shifting  to any position greater than  will not change the score of any candidate in any step of Greedy-Approval-CC. Shifting  to some position will increase the score of  by one and decrease the score of the last-ranked approved candidate by one—independently how far beyond position  we shift . Hence, for each voter we simply say which important candidates this voter approves, which candidate among the approved candidates is ranked last, and the price of moving  the the first approved position.

The voters. The set of voters contains  many -voters,  many --voters, and  many -voters:

• For each set  there is one -voter that approves  (and some dummy candidates) such that it costs one to disapprove  but approve  instead.

• For each set  and element  there is one --voter that approves  only if and that approves approves  (and some dummy candidates) in any case.

• For each element  there is one -voter that approves  and .

There are further auxiliary voters that allow us to appropriately set the number of approvals for each candidate:

• For each there are voters that approve  and  (and some dummy candidates) and  voters that only approve  (and some dummy candidates).

• For each there are voters that approve  and  (and some dummy candidates) and