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 wellstudied for singlewinner 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 shortlisted 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 shortlisting 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 ChamberlinCourant 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 polynomialtime computable, this is not the case for the ChamberlinCourant 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 ChamberlinCourant 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, hardtocompute 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 singlewinner elections, Shift Bribery is a relatively easy problem. Specifically, it is polynomialtime solvable for the Approval rules. For the Borda rule, for which it is hard, there are a good polynomialtime 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):

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 singlewinner setting).

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 Approvalbased 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 singlewinner 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 singlewinner 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 singlewinner 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 polynomialtime, , 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.^{3}^{3}3There 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 ChamberlinCourant 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 (highestscoring committees win); BordaCC uses Borda scores, ApprovalCC 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].
GreedyBordaCC is a approximation algorithm for the BordaCC 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 BordaCC.) The algorithm starts with an empty set and executes iterations, in each one adding to the candidate that maximizes the BordaCC score of .^{4}^{4}4If 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. GreedyBordaCC always outputs a unique winning committee.
GreedyApprovalCC works in the same way, but uses Approval scores instead of Borda scores. It is a approximation algorithm for ApprovalCC. We refer to ApprovalGreedyCC for (where is Lambert’s W function; is ) as PTASCC; it is the main part of Skowron et al.’s [35] polynomialtime approximation scheme for BordaCC.
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 fixedparameter 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 polynomialtime manyone 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 pairwisedistinct 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 parahard.
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 ),^{5}^{5}5Our approach is a natural extension of the nonunique winner model from the world of singlewinner 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 allornothing price functions, where for each voter it holds that for each (where is some voterdependent 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:

, and

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.
voting rule  Winner  Shift Bribery  
Determination  #candidates ()  #voters ()  #shifts ()  


Approval  
Borda  (0/1pr.), AS,  
and h (Thm. 4)  

SNTV  (Thm. 3)  
Bloc  
Borda  (Thm. 1)  (0/1pr.) (Prop. 1),  h (Thm. 5)  
BordaCC  h,  AS (Thm. 2), and  h  
, and  h (Cor. 1+Cor. 2)  
ApprovalCC  (Prop. 2)  
GreedyApprovalCC  h (Thm. 7)  
PTASCC  
GreedyBordaCC  h (Cor. 2) 
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 ChamberlinCourant 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 allornothing 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, ApprovalCC, BordaCC, GreedyApprovalCC, PTASCC, and GreedyBordaCC.
In order to prove Theorem 1, we introduce an algorithmic scheme similar to that of Dorn and Schlotter [13] for singlewinner 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 ApprovalCC and BordaCC (by proving Lemma 2), and for GreedyApprovalCC, PTASCC, and GreedyBordaCC (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 roundbased rules (GreedyApprovalCC, PTASCC, and GreedyBordaCC) 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 roundbased 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:
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:
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:
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:
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 ApprovalCC Shift Bribery and BordaCC Shift Bribery are in .
Proof.
To make a member of the winning committee for ApprovalCC (respectively, BordaCC) 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 :
where is the score given by a voter voting as the th preference order to the committee . Note that this can be computed in polynomialtime 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 GreedyApprovalCC, PTASCC, and GreedyBordaCC.
Proof.
Since PTASCC is a special case of GreedyApprovalCC it suffices to describe the extension of the ILP for GreedyApprovalCC and GreedyBordaCC.
To make a member of the winning committee for GreedyApprovalCC (respectively, GreedyBordaCC) 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 :
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 candidatemonotone 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 candidatemonotone 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 GreedyBordaCC, GreedyApprovalCC, and PTASCC are not candidatemonotone (see the work of Elkind et al. [17] for the argument regarding GreedyBordaCC). Thus, the above result applies to all the remaining rules.
For the case of allornothing prices, we can strengthen the above result to an exact algorithm.
Proposition 1.
Consider parameterization by the number of voters. Let be a candidatemonotone multiwinner rule with an algorithm for Winner Determination. Then, there is an algorithm for Shift Bribery with allornothing price functions.
Proof.
Since is candidatemonotone and we have allornothing 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 roundbased 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 ApprovalCC, GreedyApprovalCC, and PTASCC, for the parameterization by the number of voters and for arbitrary price functions.
Finally, using smart bruteforce, 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 polynomialtime 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 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 singlewinner 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 BordaShift Bribery, left open by Bredereck et al. [7].
We first show that Shift Bribery is polynomialtime 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.
SNTVShift Bribery and BlocShift 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 BordaShift 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 Bordabased 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 BordaShiftBribery as follows. We let the candidate set be
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:

For each color , we introduce four voters: voters and with the following preference orders:
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.

We create a voter with the preference order
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 Bordabased rules later).
Corollary 1.
Parameterized by the number of voters, BordaShift 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 BordaShift Bribery is in for allornothing prices and the parameterization by the number of voters.
The next result is, perhaps, even more surprising than Theorem 4: It turns out that BordaShift Bribery is hard also for the parameterization by the number of unit shifts, whereas BordaShift 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:

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.

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 BordaShift 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 ChamberlinCourant and Its Variants
We now move on to the ChamberlinCourant (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 BordaCC and ApprovalCC is NPhard 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 CCbased 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 CCbased rules. For the parameterization by the number of voters, by Proposition 2 we have results for ApprovalCC, GreedyApprovalCC, and PTASCC. We inherit hardness for BordaCC and GreedyBordaCC from Theorem 4, since both rules coincide with the singlewinner Borda rule in case of committee size .
Corollary 2.
Shift Bribery parameterized by the number of voters is hard for BordaCC and for GreedyBordaCC even for unit price functions.
By Theorem 2, we have that there is an approximation scheme for BordaCC. However, since Theorem 2 strongly relies on candidate monotonicity of the rule, it does not apply to GreedyBordaCC. Indeed, we believe that there is no constantfactor approximation algorithm for GreedyBordaCCShift 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 , GreedyBordaCCShift 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 GreedyBordaCC. 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 GreedyBordaCC 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 GreedyBordaCCShift 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.

For each color , we introduce two vertexscore voters with the following preference orders:
and two vertexselection voters with the following preference orders:

For each pair of distinct colors , , we introduce two edgescore voters with the following preference orders:
and two edgeselection voters with the following preference orders:
Each of the edgeselection voters has weight (and these are the only voters with nonunit weights).

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

We introduce the following two voters, the score voters, with the following preference orders:

Let be the total weight of voters introduced so far (clearly, is polynomially upperbounded 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 barscore voters.
We assume that the internal tiebreaking 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 zerovector, that means not bribing the voters) of costs at most leads to a committee that contains

the bar vertex ,

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

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

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 barscore voters, irrespective how we shift within the budget, GreedyBordaCC 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:
The points in the first bracket come from the vertexscore voters, in the second bracket from the vertexselection voters, and in the last bracket from the verification voters. Further, since is much larger than and , every nonvertex candidate has significantly lower score.
Thus, in the next rounds, for each color , GreedyBordaCC 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 vertexselection 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 GreedyBordaCC 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, GreedyBordaCC 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:
where the points from the first bracket come from the edgescore voters and the points in the second bracket come from the edgeselection 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 edgeselection 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:
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 tiebreaking— 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 BordaCC and ApprovalCC are parahard due to the hardness of Winner Determination.^{6}^{6}6The 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 GreedyApprovalCC, PTASCC, and GreedyBordaCC 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 GreedyBordaCC, GreedyApprovalCC, and PTASCC. Further, unless , in these cases the problem is not approximable for any constant .
Proof.
First, we show the result for GreedyApprovalCC for Approval satisfaction function with (which includes PTASCC). Second, we show how the proof ideas can be adapted to obtain the same result for GreedyBordaCC.
GreedyApprocalCC.
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 GreedyApprovalCC 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 GreedyApprovalCC Shift Bribery, specifying the set of approved candidates, the lastranked 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 GreedyApprovalCC. Shifting to some position will increase the score of by one and decrease the score of the lastranked 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
Comments
There are no comments yet.