     # Algorithms for Destructive Shift Bribery

We study the complexity of Destructive Shift Bribery. In this problem, we are given an election with a set of candidates and a set of voters (each ranking the candidates from the best to the worst), a despised candidate d, a budget B, and prices for shifting d back in the voters' rankings. The goal is to ensure that d is not a winner of the election. We show that this problem is polynomial-time solvable for scoring protocols (encoded in unary), the Bucklin and Simplified Bucklin rules, and the Maximin rule, but is NP-hard for the Copeland rule. This stands in contrast to the results for the constructive setting (known from the literature), for which the problem is polynomial-time solvable for k-Approval family of rules, but is NP-hard for the Borda, Copeland, and Maximin rules. We complement the analysis of the Copeland rule showing W-hardness for the parameterization by the budget value, and by the number of affected voters. We prove that the problem is W-hard when parameterized by the number of voters even for unit prices. From the positive perspective we provide an efficient algorithm for solving the problem parameterized by the combined parameter the number of candidates and the maximum bribery price (alternatively the number of different bribery prices).

03/31/2022

### Group Control for Procedural Rules: Parameterized Complexity and Consecutive Domains

We consider Group Control by Adding Individuals (GCAI) for two procedura...
01/29/2021

### Probabilistic Inference of Winners in Elections by Independent Random Voters

We investigate the problem of computing the probability of winning in an...
08/28/2019

### Approximation and Hardness of Shift-Bribery

In the Shift-Bribery problem we are given an election, a preferred candi...
01/07/2016

### Complexity of Shift Bribery in Committee Elections

We study the (parameterized) complexity of SHIFT BRIBERY for multiwinner...
05/18/2021

### Fine-Grained View on Bribery for Group Identification

Given a set of agents qualifying or disqualifying each other, group iden...
02/15/2019

### Electing a committee with constraints

We consider the problem of electing a committee of k candidates, subject...
02/15/2019

### Electing a committee with dominance constraints

We consider the problem of electing a committee of k candidates, subject...

## 1 Introduction

We study the complexity of the destructive variant of the Shift Bribery problem. We consider the family of all (unary encoded) scoring protocols (including the Borda rule and all -Approval rules) and the Bucklin, Simplified Bucklin, Copeland, and Maximin rules. It turns out that for all of them—except for the Copeland rule—the problem can be solved in polynomial time. This stands in sharp contrast to the constructive case, where the problem is -hard  (and hard in the parameterized sense ) for the Borda, Copeland, and Maximin rules (however, Shift Bribery is in for the -Approval family of rules and the Simplified Bucklin and Bucklin rules ).

The Shift Bribery problem was introduced by Elkind et al.  to model (a kind of) campaign management problem in elections. The problem is as follows: We are given an election, that is, a set of candidates and a set of voters that rank the candidates from the most to the least desirable one, a preferred candidate , a budget , and the costs for shifting forward in voters’ rankings. Our goal is to decide if it is possible to ensure ’s victory by shifting forward, without exceeding the budget. In this paper we study the destructive variant of the problem, where the goal is to ensure that a given despised candidate does not win the election, by shifting him or her back in voters’ rankings (but, again, each shift comes at a cost and we cannot exceed the given budget).

Studying destructive variants of election problems, where the goal is to change the current winner (such as manipulation , control , and bribery [18, 25, 7, 37]), is a common practice in computational social choice, but our setting is somewhat special. So far, all the destructive variants of the problems were defined by changing the goal from “ensure the victory of the preferred candidate” to “preclude the despised candidate from winning,” but the set of available actions remained unaffected (e.g., in both the constructive and the destructive problem of control by adding voters, we can add some voters from a given pool of voters and in both the constructive and the destructive bribery problem, we can pay voters to change their votes in some way). In our case, we feel that it is natural to divert from this practice and change the ability of “shifting the distinguished candidate forward” to the ability of “shifting the distinguished candidate back”. Below we explain why.

If, when defining our destructive problem, we stuck with the “ability to shift forward,” as in the Constructive Shift Bribery problem, we would get the following problem: Ensure that a given despised candidate does not win the election by shifting him or her forward in some of the votes (without exceeding the budget). However, for a monotone voting rule, if a candidate is already winning an election, then shifting him or her forward certainly cannot preclude him or her from winning. This would make our problem interesting only for a relatively small set of nonmonotone rules.111Nonetheless, there are interesting nonmonotone rules, such as the single transferable rule (STV) and the Dodgson rule. It is also quite common for multiwinner rules to not be monotone (see the works of Elkind et al.  and Faliszewski et al. ), so studying this variant of the Shift Bribery problem for multiwinner voting rules may be interesting. Further, the problem certainly would not be modeling what one would intuitively think of as negative, destructive campaigning. Thus, while it certainly would be interesting to study how to exploit nonmonotonicity of rules such as STV and Dodgson (or various multiwinner rules) to preclude someone from winning, it would not be the most practical way of defining Destructive Shift Bribery.

### 1.1 Related Work

In recent years, Constructive Shift Bribery received quite some attention. The problem was defined by Elkind et al. , as a simplified variant of Swap Bribery (which itself received some attention, for example, in the works of Bredereck et al. , Dorn and Schlotter , Faliszewski et al. , Knop et al. , and papers regarding combinatorial domains, such as those of Mattei et al.  and Dorn and Krüger ; importantly, Shiryaev et al.  studied a variant of Destructive Swap Bribery and we comment on their work later). Elkind et al.  have shown that Constructive Shift Bribery is -hard for the Borda, Copeland, and Maximin voting rules, but polynomial-time solvable for the -Approval family of rules. They also gave a -approximation algorithm for the case of Borda, which was later generalized to the case of all scoring rules by Elkind and Faliszewski . Chen et al.  considered parametrized complexity of Constructive Shift Bribery, and have shown a varied set of results (in general, parametrization by the number of positions by which the preferred candidate is shifted tends to lead to FPT algorithms, parametrization by the number of affected voters tends to lead to hardness results, and parametrization by the available budget gives results between these two extremes). Recently, Bredereck et al.  studied the complexity of Combinatorial Shift Bribery, where a single shift action can affect several voters at a time. Their paper is quite related to ours, because it was the first one in which shifting a candidate backward was possible (albeit as a negative side effect, since the authors studied the constructive setting). Very recently, Maushagen et al.  studied both constructive and destructive shift bribery (using our model with backward shifts) for the case of round-based rules such as STV (there referred as Hare), Coombs, Baldwin, and Nanson.

Shift Bribery belongs to the family of bribery-related problems, that were first studied by Faliszewski et al.  (see also the work of Hazon et al.  for a similar problem), and that received significant attention within computational social choice literature (see the survey of Faliszewski and Rothe ). Briefly put, in the regular Bribery problem the goal is to ensure that a given candidate is a winner of an election by modifying—in an arbitrary way—up to votes, where is part of the input. Many types of bribery problems were already studied, including—in addition to Swap and Shift BriberySupport Bribery , Extension Bribery [2, 19], and others (e.g., in judgment aggregation , and in the setting of voting in combinatorial domains [27, 12, 26]). However, from our point of view the most interesting variant of the problem is Destructive Bribery, first studied by Faliszewski et al.  and also, independently, by Magrino et al.  and Cary  under the name Margin of Victory (this problem was also studied by Xia  and Dey and Narahari ). The idea behind Margin of Victory is that it can be very helpful in validating election results: If it is possible to change the election result by changing (bribing) relatively few votes, then one may suspect that—possibly—the election was tampered with. Bribery problems are also related to lobbying problems [8, 3, 30].

A variant of Destructive Swap Bribery was studied by Shiryaev et al.  in their work on testing how robust are winners of given elections. They presented an analysis of the case where every swap has a unit price and they showed that the problem is easy for scoring protocols and for the Condorcet rule.222The authors’ definition of the Condorcet rule slightly differs from a standard one usually seen in the literature. They assume that if there is no unique Condorcet winner the rule returns the whole set of candidates instead of an empty set (well established as a return value for this case in the literature.) This work is very closely related to ours, but the definition of the problem is somewhat different (more general types of swaps but less general price functions). Very recently Bredereck et al.  studied an analogous setting (Destructive Swap Bribery with unit prices) for the case of multiwinner voting rules.

### 1.2 Our Contribution.

We believe that Destructive Shift Bribery is worth studying for three main reasons. First, it simply is a natural variant of the Constructive Shift Bribery problem and as the constructive variant received significant attention, we feel that it is interesting to know how the destructive variant behaves (indeed, the work of Maushagen et al.  is a sign that the destructive setting also attracts attention). Second, it models natural negative campaigning actions, aimed at decreasing the popularity of a given candidate. Third, it serves a similar purpose as the Margin of Victory problem [25, 37]: If it is possible to preclude a given candidate from winning through a low-cost destructive shift bribery, then it can be taken as a signal that the election might have been tampered with, or that some agent performed a possibly illegal form of campaigning. Below we summarize the main contributions of this paper:

1. We define the Destructive Shift Bribery problem and justify why a definition that diverts from the usual way of defining destructive election problems is appropriate in this case.

2. We show that Destructive Shift Bribery is a significantly easier problem than constructive shift bribery. To this end, we show polynomial time algorithms for Destructive Shift Bribery for all scoring rules with unary encoded scores (including the Borda rule and -Approval family of rules), Simplified Bucklin, Bucklin, and Maximin.

3. We show that in spite of our easiness results, there still are voting rules for which the problem is computationally hard. We exemplify this by proving -hardness and -hardness (for several parameters) for the case of Copeland family of rules.

The paper is organized as follows. In Section 2, we formally define elections, present the voting rules used in the paper, define our problem, and briefly review necessary notions regarding parametrized complexity. In Section 3, we present our results, with one subsection for each of the studied rules. We conclude in Section 4 with an overview of our work, tables of results, and suggestions for future research.

## 2 Preliminaries

For each positive integer , by we mean the set . We assume that the reader is familiar with standard notions regarding algorithms and complexity theory, as presented in the textbook of Papadimitriou .

### 2.1 Elections and Election Rules

An election is a pair , where is a set of candidates and is a multiset of voters. Each voter is associated with his or her preference order , that is, a strict ranking of the candidates from the best to the worst (according to this voter). For example, we may have election with and , where has preference order . If is a candidate and is a voter, we write to denote the position of in ’s ranking (e.g., in the preceding example we would have ). Given an election and two distinct candidates and , by we mean the number of voters who prefer to .

An election rule is a function that given an election outputs a set of tied election winners (typically, we expect to have a single winner, but due to symmetries in the profile it is necessary to allow for the possibility of ties). We use the unique-winner model, that is, we require a candidate to be the only member of to be considered ’s winner (see the works of Obraztsova et al. [32, 33] for various other tie-breaking mechanisms and algorithmic consequences of implementing them; indeed, there are situations where the choice of the tie-breaking rule affects the complexity of election-related problems).

We consider the following voting rules (for the description below, we consider election with candidates; for each rule we describe the way it computes candidates’ scores, so that the candidates with the highest score are the winners, unless explicitly stated otherwise):

Scoring protocols.

A scoring protocol is defined through vector

of nonincreasing, nonnegative integers. The -score of a candidate is defined as . The most popular scoring protocols include the family of -Approval rules (for each , -Approval scoring protocol is defined through a vector of ones followed by zeros) and the Borda rule, defined by vector . The -Approval rule is known as Plurality.

Bucklin and Simplified Bucklin.

A Bucklin winning round is the smallest value such that there is a candidate whose -Approval score is greater or equal to (in other words, if there is a candidate ranked among top positions by a strict majority of the voters). All candidates whose -Approval score is at least this value are the winners under the Simplified Buckling rule. The Bucklin score of a candidate is his or her -Approval score, where is the Bucklin winning round of the election. The candidates with the highest Bucklin score are the Bucklin winners (note that the set of Bucklin winners is a subset of the set of Simplified Bucklin winners).

Copeland.

Let , , be a rational number. The Copeland score of a candidate is defined as:

 |{d∈C∖{c}:NE(c,d)>NE(d,c)}|+α|{d∈C∖{c}:NE(c,d)=NE(d,c)}|.

In other words, candidate receives one point for each candidate whom he or she defeats in their head-to-head contest (i.e., for each candidate over whom is preferred by a majority of the voters) and points for each candidate with whom ties their head-to-head contest.

Maximin.

The Maximin score of candidate is defined as .

We write to denote the score of candidate in election (the election rule will always be clear from the context).

###### Definition 1.

For election , a Condorcet winner is a candidate who defeats all the other candidates in head-to-head contests. We call an election rule Condorcet-consistent if, for every possible election , it selects a Condorcet winner when one exists.

Among all the rules we consider only Maximin and Copeland are Condorcet-consistent. However, even though they both share this property, the results we obtained show that they differ significantly when considered from our problem’s perspective.

### 2.2 Destructive Shift Bribery

The Destructive Shift Bribery problem for a given election rule is defined as follows. We are given an election , a despised candidate (typically, the current election winner), a budget (a nonnegative integer), and the prices for shifting backward for each of the voters (see below). The goal is to ensure that is not the unique -winner of the election by shifting him or her backward in the voters’ preference orders without exceeding the budget.

We model the “prices for shifting backward” as destructive shift-bribery price functions. Let us fix an election , with , , and let the despised candidate be . Let be some voter and let . Function is a destructive shift-bribery price function for voter if it satisfies the following conditions:

1. ,

2. for each two , , it holds that for , and

3. for

For each , we interpret value as the price of shifting back by positions in ’s preference order. Value is used for the cases where shifting back by positions is impossible (due to ’s position in the vote). We assume that in each instance, the price functions are encoded by simply listing their values for all arguments for which they are not .

For our hardness results, we focus on the case of unit price functions, where, for each voter, shifting the despised candidate backward by positions costs units of the budget. Sometimes we also consider all-or-nothing price functions, where for each voter there is a value (which can also be set to ) such that the cost of shifting the despised candidate positions backward always costs , irrespective of (except for , where the cost is zero by definition).

###### Example 1.

Let us consider an instance of Destructive Shift Bribery for the Borda rule with the following election:

 v1: b≻a≻c≻d, v2: d≻b≻a≻c, v3: d≻c≻a≻b, v4: d≻a≻b≻c.

We take to be the despised candidate, and assume that we have unit price functions. In this election, candidate wins with points, and the second-best candidate, , has points. However, if we shifted two positions back in ’s preference order, then ’s score would decrease to and ’s score would increase to . Thus, would no longer be the unique winner. In consequence, for we have a “yes”-instance of Destructive Shift Bribery. On the other hand, shifting back by one position only (in whichever vote) cannot preclude from winning. So, for we have a “no”-instance.

### 2.3 Parameterized Complexity

In the theory of parameterized complexity, the goal is to study the computational difficulty of problems with respect to both their input length, as in classic computational complexity theory, and some additional “parameters.” For example, for Destructive Shift Bribery problem, the parameters may be the numbers of voters or candidates in the input election, the budget values, the maximum numbers of shifts available for a bribery etc. (we take the parameters to be numbers). For a parameter , we say that a problem parametrized by is fixed-parameter tractable (is in ) if there is an algorithm that solves it in time , where is the length of the encoding of a given instance and is an arbitrary computable function (that depends on the parameter value only). Intuitively, if a problem is in for some parameter , then we can hope that its instances where is small can be solved efficiently.

Parametrized complexity theory also offers a theory of intractability. In particular, it is widely believed that if a problem is -hard with respect to some parameter , then there is no algorithm for this problem for this parametrization. The original definition of the class is quite involved and it is currently common to define the class by providing one of its complete problems (Clique parametrized by the size of the clique is the most common example) and the notion of a parametrized reduction. In our case the situation is even simpler: All our -hardness proofs give polynomial-time many-one reductions from well-known -hard problems and guarantee that the values of the parameters in the reduced-to instances depend only on the values of the parameter in the reduced-from instances (in other words, our proofs do not use full power of parametrized reductions).

We point readers interesting in more detailed treatments of parametrized complexity theory to the textbooks of Niedermeier  and Cygan et al. .

## 3 Results

In this section we present our main results. We show polynomial-time algorithms for the -Approval family of rules, the Borda rule, all scoring protocols (provided that they are encoded in unary or that the destructive shift bribery price functions are encoded in unary), the Bucklin family of rules, and the Maximin rule. For the Copeland family of rules, we prove -hardness and several results regarding its parameterized complexity.

As a warm-up, we start with an observation regarding an upper bound of the complexity of the Destructive Shift Bribery problem.

###### Observation 1.

The Destructive Shift Bribery problem is in for every voting rule for which winner determination is in .

###### Proof.

Given an instance of the problem, we guess in which votes to shift the despised candidate and by how many positions. Then we check if the cost of these shifts does not exceed the budget and if implementing them ensures that the despised candidate is not the unique winner of the election. ∎

Every voting rule that we consider in this paper is polynomial-time computable and, thus, Observation 1 guarantees that the Destructive Shift Bribery problem for each of our rules is in (in particular, all our -hardness proofs in fact show -completeness).

### 3.1 The k-Approval Family of Rules

We start with the -Approval family of rules. In this case, our algorithm is very simple: If is the despised candidate then in each vote we should either not shift at all or shift him or her from one of the top positions (where each candidate receives a single point) to the -st position (where he or she would receive no points), in consequence also shifting the candidate previously at the -st position one place forward (to receive a point). Choosing which action to do for each particular voter is easy via the following greedy/brute-force algorithm (our algorithm is based on a similar idea as that of Elkind et al.  for the constructive case).

###### Theorem 1.

For each , the Destructive Shift Bribery problem for the -Approval rule is in .

###### Proof.

Let be the input election with and , let be the despised candidate, let be the budget, and let be the destructive shift-bribery price functions for the voters. Our algorithm works as follows.

For every candidate , we test if it is possible to guarantee that the score of is at least as high as that of , by spending at most units of budget, as follows:

1. We partition the voters into three groups, , , and , such that: contains exactly the voters that rank on the -st position and that rank above , contains the remaining voters that rank among top positions, and contains the other remaining voters.

2. We guess two numbers, and , such that and .

3. We pick voters from for whom shifting to the -st position is least expensive and we pick voters from for whom shifting to the -st position is least expensive. We shift to the -st position in the chosen votes.

4. If is not the unique winner in the resulting election and the total cost of performed shifts is smaller than or equal to budget , then we accept. Otherwise, we either try a different candidate or different values of and . After trying all possible combinations, we reject.

The algorithm runs in polynomial time: It requires trying at most different candidates and different values of and . All the other parts of the algorithm require polynomial time (in fact, a careful implementation can achieve running time ).

To show correctness of the algorithm we start with an observation that it is never beneficial to shift below position . Further, an optimal solution, after which some candidate has at least as high a score as , can consist solely of actions that shift backward from one of the top positions to the -st one, in effect either promoting to the -th position (shifts in voter group ), or promoting some other candidate (shifts in voter group ). We guess how many shifts of each type to perform and execute the least costly ones. ∎

### 3.2 The Borda Rule and All Scoring Rules

Next we consider the Borda rule. We also obtain a polynomial-time algorithm, but this time we resort to dynamic programming. After proving Theorem 2 below, we will show that our algorithm generalizes to all scoring protocols (provided that either the scores are encoded in unary or the price functions are encoded in unary).

###### Theorem 2.

The Destructive Shift Bribery problem for the Borda rule is in .

###### Proof.

Let be the input election with and , let be the despised candidate, let be the budget, and let be the destructive shift-bribery price functions for the voters. As in the case of the proof of Theorem 1, we give an algorithm that first guesses some candidate and then checks if it is possible to ensure—by shifting backward without exceeding budget —that has at least as high a score as . The algorithm performing this test is based on dynamic programming.

We fix to be the candidate that we want to have a score at least as high as . Further, for each and , we set to be if ranks  among first  positions below , and we set it to be otherwise. Finally, we write to denote the difference between the scores of and , that is, (it must be that ; otherwise we could accept immediately since would not be the unique winner of the election).

For each and each positive integer , we define to be the smallest cost for shifting backward in the preference orders of the voters from the set , so that, if is the resulting election, it holds that:

 s−(scoreE′(d)−scoreE′(c))≥k.

In other words, is the lowest cost of shifting backward in the preference orders of voters from the set so that the relative score of with respect to increases by at least points. Our goal is to compute ; if it is at most then it means that we can ensure that has at least as high a score as by spending at most units of the budget. We make the following observation.

###### Observation 2.

Shifting candidate backward by some positions decreases the score of by points and, if passes , increases the score of by one point. In effect, relative to , gains, respectively, or points.

Now, we can express function as follows. We have that and for each positive we have (for technical reasons, whenever , we take ). For each and , we have:

 f(j,k)=mink′≤kf(j−1,k−(k′+A(j,k′))+ρj(k′).

To explain the formula, we observe that:

1. The minimum is taken over the value ; gives the number of positions by which we shift backward in vote .

2. When we shift backward by positions, relative to , candidate gains points.

3. The cost of this shift is .

Based on these observations, we conclude that the formula is correct. It is clear that using this formula and standard dynamic programming techniques, we can compute in polynomial time with respect to and . This means that we can test in polynomial time, for a given candidate , if it is possible to ensure that ’s score is at least as high as that of .

Our algorithm for Destructive Shift Bribery for Borda simply considers each candidate and tests if, within budget , it is possible to ensure that has at least as high a score as . If this test succeeds for some , we accept. Otherwise we reject. ∎

A careful inspection of the above proof shows that there is not much in it that is specific to the Borda rule (as opposed to other scoring protocols). Indeed, there are only the following two dependencies:

1. The fact that the difference between the scores of candidate and candidate (value ) can be bounded by a polynomial of the number of voters and the number of candidates (dynamic programming requires us to store a number of values of the function that is proportional to , so it is important that this value is polynomially bounded).

2. The way we compute the increase of the score of , relative to , in the recursive formula for .

Since it is easy to modify the formula for to work for an arbitrary scoring protocol , we have the following corollary (the assumption about unary encoding of the input scoring protocol ensures that the first point in the above list of dependencies is not violated).

###### Corollary 1.

There exists an algorithm that, given as input a scoring protocol (for  candidates) encoded in unary and an instance of the Destructive Shift Bribery problem (with the same number of candidates), tests in polynomial time if is a “yes”-instance for the voting rule defined by the scoring protocol .

What can we do if, in fact, our scoring protocol is impractical to encode in unary (e.g., if our scoring protocol is of the form )? In this case, it is easy to show the following result.

###### Corollary 2.

There exists an algorithm that, given as input a scoring protocol (for candidates) and an instance of the Destructive Shift Bribery problem (with the same number of candidates), with price functions encoded in unary, tests in polynomial time if is a “yes”-instance for the voting rule defined by the scoring protocol .

To prove this result, we use the same argument as before, but now function has slightly different arguments: is the maximum increase of the score of , relative to , that one can achieve by spending at most units of budget (using such “dual” formulation is standard for bribery problems and was applied, for example, by Faliszewski et al. [17, Theorem 3.8] in the first paper regarding the complexity of bribery problems).

On the other hand, if both the scoring protocol and the price functions are encoded in binary, and the scoring protocol is part of the input, then the problem is -complete by a reduction from the Partition problem.

###### Definition 2.

In the Partition problem, we are given a sequence of positive integers and we ask if it can be partitioned into two subsequences whose elements sum up to the same value.

###### Theorem 3.

The Destructive Shift Bribery problem is -complete if both the scoring protocol and the price functions are encoded in binary, and the scoring protocol is part of the input.

###### Proof.

Consider an instance of the Partition problem with sequence and let be the sum of the elements from . Without loss of generality, we assume that for each we have . We also assume that is even and that (for an instance is polynomial-time solvable, for we get a “no”-instance of Partition). We form an instance of Destructive Shift Bribery as follows:

1. We introduce candidates , , and dummy candidates .

2. We form a scoring vector such that , for each we have , and for all we have . By our assumptions regarding the sequence , we have that is a legal scoring vector.

3. Our election consists of votes, each representing an element of . For each element  we construct vote by placing candidate on the first position and candidate on the -st position. We fill the remaining places among the top positions in vote with candidates from the set in an arbitrary way. Then we complete vote by placing the remaining candidates on positions in an arbitrary order.

4. We set the budget to be . For every voter , we define bribery function such that , for each we have , and for all other possible values of .

We illustrate this construction in the example below.

###### Example 2.

Consider a Partition instance with sequence . Our reduction forms an election with candidate set and votes . The scoring protocol is and budget is . The preference orders of the voters are:

 v1: p1≻d≻c11≻c21≻c31≻c41≻c51≻… v2: p2≻c12≻d≻c22≻c32≻c42≻c52≻… v3: p3≻c13≻c23≻d≻c33≻c43≻c53≻… v4: p4≻c14≻c24≻c34≻d≻c44≻c54≻… v5: p5≻c15≻c25≻c35≻c45≻d≻c55≻…

For every voter , its bribery function has the following values: , for , and for all other possible values of .

The unique winner of the election constructed by our reduction is , with score . For each candidate , we have , and for all we have . Scores of the candidates cannot change due to shifting backward within budget, because either they are ranked ahead of or they are ranked too far behind (so it is impossible to shift behind them within budget). Similarly, no dummy candidate can achieve a score larger than . Thus to prevent from winning the election, one has to decrease his or her score at least by (so that the candidates have at least as high scores as has).

We observe that by bribing some voter , we are not able to decrease candidate ’s score by a value grater than the number of units of budget spent. Moreover, the budget is , which is also the number of points by which ’s initial score has to be reduced. Hence, if we choose to bribe some voter , then we have to shift backward to the -nd position, decreasing his or her score by points at the same time. Together, these observations mean that in a successful bribery we have to reduce ’s score by a sum of some elements . Further, this sum has to equal exactly . Therefore, there exists a solution to the created Destructive Shift Bribery instance if and only if there exists a solution to the initial Partition instance.

The reduction is computable in polynomial time and (by Observation 1) the Destructive Shift Bribery problem belongs to , which means that the problem is -complete. ∎

### 3.3 The Bucklin Family of Rules

We continue our analysis of the Destructive Shift Bribery problem by considering the Bucklin and Simplified Bucklin rules. We find that for both rules our problem is polynomial-time solvable (via a dynamic programming approach). Before presenting our solution, it is helpful to define some additional notation. For election , we denote the -Approval score of some candidate by . For some fixed , we frequently use the term -Approval point referring to any single point a candidate gets during the computation of his or her -Approval score. Consequently, for some fixed , a candidate may lose or gain a -Approval point as an effect of a shift action of some voter. We use to denote the strict majority threshold for voters .

###### Theorem 4.

The Destructive Shift Bribery problem for the Bucklin rule is in .

###### Proof.

Let us fix budget and election , where and . We also have shift-bribery prices functions . Without loss of generality, we assume that is the despised candidate.

To prove our theorem, we give an algorithm which first guesses candidate and the Bucklin winning round and, then, checks whether is able to preclude from being the unique winner of the election while ensuring that is the Bucklin winning round (or the Bucklin winning round is even earlier). We start by defining an appropriate helper function, then we show that we can solve our problem using this function, and eventually we show that this function is polynomial-time computable.

For each candidate and each , we define the following function . For each and each , we let be the lowest cost of bribing at most first voters so that , , and . In other words, the function gives the cost of setting up the scores of candidate and in round (and just before round , for ).

To check whether there is a successful bribery (i.e., one that ensures that is not a unique winner of the election) of cost at most , it suffices to check if there is candidate , , round number , and values such that:

1. ,

2. ,

3. , and

. Condition (1) guarantees that does not win in any round prior to , Condition (2) ensures that is the largest possible Bucklin winning round, and Condition (3) imposes that is not a unique winner if is the Bucklin winning round (note that the actual winning round number might be smaller than but then certainly does not win). If such a set of values exists, then we accept. Otherwise we reject.

The above algorithm requires computing values of at most functions . Thus, to show that the algorithm runs in polynomial time, it suffices to show that the values of the functions are polynomial-time computable, which we now do.

We compute values using dynamic programming. For each , if prior to any bribery we have , , and . Otherwise, we have . To compute for , we express it using a recursive formula. To present this formula compactly, for each voter and each , , we define:

1. Function such that for each we have if candidate is ranked below the -th position after he or she is shifted backward by positions, and we have otherwise.

2. Function such that for each , we have if after shifting candidate backward by positions, candidate is ranked among top positions, and we have otherwise.

Using this notation, we express function as follows:

 fki(w,p,q,q′)= minj∈{0}∪[k]{fki(w−1,p−Gkw(i,j),q−Lkw(i,j),r−Lk−1w(j))+ρw(j)}

Intuitively, for given and , the above formula checks all possible values of ,333For function it is never necessary to shift to position lower than , which is why we consider . for which we shift backward by positions in vote , and uses shifts in the preceding votes to fulfill the function’s definition. This formula, together with standard dynamic programming techniques, allows us to compute the values of function in polynomial time. This completes the proof. ∎

By slightly changing the function presented in the above proof and using a similar algorithm, we obtain an algorithm for the Simplified Bucklin rule.

###### Theorem 5.

The Destructive Shift Bribery problem for the Simplified Bucklin rule is in .

###### Proof.

We adjust the proof of Theorem 4 to match the case of the Simplified Bucklin rule. For this rule, the exact score of a candidate in the Bucklin winning round is not taken into account while determining the winners (provided that it is greater than the majority of the voters). Therefore, we can simplify function from the proof of Theorem 4 by removing parameter . Consequently, we remove the constraint associated with parameter  while checking for a successful bribery. The rest of the proof remains the same, so Destructive Shift Bribery for the Simplified Bucklin rule is in as well. ∎

### 3.4 The Copeland Rule

Let us now move on to the case of Copeland family of rules. We show that irrespective of the choice of , , the Destructive Shift Bribery problem is -complete for Copeland. We also show -hardness of the problem for parametrizations by the budget, the number of voters, and the number of bribed voters. On the other hand, an FPT algorithm for the parametrization by the number of candidates was given by Knop et al.  (formally, they did not study Destructive Shift Bribery, but it is immediate to see that their proof extends to this setting). To show our hardness results, we use reductions from one of the classic -complete problems, Clique (which is also -hard for the parameterization by the clique size).

###### Definition 3.

In the Clique problem we are given a graph and an integer . We ask whether it is possible to find a -clique, that is, a size- set of pairwise adjacent vertices, in the given graph.

We use the following notation in the proofs in this section. By putting some set in a preference order, we mean listing the contents of the set in an arbitrary but fixed order. To denote the reversed order we use (e.g., for set , writing in a preference order could mean ; then, putting in a preference order would mean ).

###### Theorem 6.

For each (rational) value of , , the Destructive Shift Bribery problem for the Copeland rule is -complete and W-hard for the parameterization by the budget value and for the parameterization by the number of affected of voters.

###### Proof.

Since winner determination for Copeland is in , by Observation 1 we see that our problem is in and it remains to show its -hardness. We give a reduction from Clique.

Let us fix some arbitrary value of and an instance of Clique with a given graph and an integer . We construct an instance of Destructive Shift Bribery with an election , unit bribery prices and budget . Let the set of candidates be (members of and are both vertices and edges in and corresponding candidates in our election). Sets , , and contain dummy candidates, where and consist of candidates each, and consists of candidates. We introduce the following voters:

1. For each edge , we introduce two voters with the following preference orders:

 1 vote: d≻u≻v≻e≻L≻L′≻p≻E(G)∖{e}≻V(G)∖{u,v}≻S 1 vote: ←S≻←−−−−−−−−−−V(G)∖{u,v}≻←−−−−−−−−E(G)∖{e}≻p≻←L′≻←L≻e≻v≻u≻d.
2. We introduce voters with the following preference orders:

 k−2 votes: E(G)≻d≻L≻S≻p≻L′≻V(G), k−2 votes: p≻L′≻d≻L≻V(G)≻S≻E(G), 1 vote: S≻p≻d≻L′≻V(G)≻L≻E(G).
3. We introduce voters with the following preference orders:

Note that the number of voters is odd, so the value of

is irrelevant.

We present the scores of the candidates, prior to bribery, in Table 1 (for some candidates we only provide upper bounds on their scores; to verify the values in the table, it is helpful to note that the preference orders of the pairs of voters in the first group are reverses of each other, and thus one can disregard them when calculating scores). We see that candidate is the winner.

By shifting backward without exceeding the budget, we can only change the outcome of head-to-head contests between and the candidates from and . All the other candidates are either ranked too far away from or, as in the case for and , has too large advantage over them. For each candidate , we have , and for each , we have . Thus, for to lose a head-to-head contest against a candidate , has to be shifted behind in at least votes, and to lose a head-to-head contest against a candidate , has to be shifted behind in at least one vote (note that the scores of candidates in and are so low that after a shift bribery that does not exceed the budget, neither of them can be a winner).

Candidate has the second highest score in our election and we have . Hence, to prevent from being a winner, we need to lower ’s score by at least . If our graph contains a clique of size that consists of edges , then for each voter from the first group that corresponds to one of these edges we shift backward by three positions. This costs units of budget. Candidate loses one point for each edge from the clique and one point for each vertex from the clique (because passes each of them exactly times). Altogether, loses points and ceases to be the unique winner.

For the other direction, assume that there is a shift bribery of cost at most that ensures that is not the unique winner. By the observations from the previous paragraphs, we can assume that the bribery affects voters in the first group only (and for each pair of voters there, it affects the first one). We claim that the bribery has to shift behind edge candidates in the first group of voters. To see why this is the case, assume that it shifts behind (distinct) edge candidates, where is a positive integer smaller or equal to . To make lose points, we need to shift backwards behind at least vertex candidates at least times. That means that altogether the number of unit shifts that we need to make is at least:

 3((k2)−x)passing edge candidates+(k+x)(k−1)total number of unit shiftsneeded to pass vertex candidates−2((k2)−x)unit shifts for passing vertex % candidates,accounted for while passing edge candidates.

This value is equal to:

 (k2)−x+(k+x)(k−1) =(k2)−x+k(k−1)+x(k−1) =3(k2)−x+x(k−1)=3(k2)+x(k−2),

which is greater than for and . Since we can assume that without loss of generality, we see that a successful shift bribery that does not exceed the budget has to guarantee that passes exactly edge candidates. One can verify that this leads to passing vertex candidates times each only if these edges form a size- clique.

Clique is -hard for the parameter . As our budget is a function of and the number of affected voters is exactly , our reduction shows -hardness with respect to the budget and with respect to the number of affected voters. ∎

The problem remains hard also for the parametrization by the number of voters.

###### Theorem 7.

Parameterized by the number of voters, the Destructive Shift Bribery problem is -hard, even for the case of unit prices.

###### Proof.

We give a parameterized reduction from the Multicolored Independent Set problem, where we are given a graph with each vertex colored with one out of colors, and we ask if there is a size- subset of vertices such that every vertex has a different color and for each two , there is no edge in the graph. We assume without loss of generality that the number of vertices of every color is the same, there are no edges between vertices of the same color, and there exists at least one vertex with non-zero degree among vertices of each color. Let be the number of vertices of each color. We denote the maximum degree among vertices of graph by . Let be the degree of vertex , and let be the set of edges adjacent to a given vertex . By we mean the set of all vertices of color .

For each color , we introduce vertex candidates . We represent every edge in the input graph with one edge candidate. For each vertex candidate , by we denote the set of edge candidates representing the edges incident to in graph . We write to denote the set of all vertex and edge candidates. If for some and , , we add the set of filler candidates of size . We write to denote the union of all the sets of filler candidates for all the vertices. We introduce sets of dummy candidates with elements each (note that ); namely, these sets are , , , and . We write to denote and to denote . Lastly, we add candidates , and . To specify voters in a compact form, for every color we introduce partial preference order:

 Pi=vi1≻Ei1≻Fi1≻vi2≻⋯≻vi3≻⋯≻viq≻Eiq≻Fiq.

For a given , we write to denote an arbitrary but fixed order over all the vertex, edge and filler candidates not ranked in . The constructed election consists of the following votes:

1. For each color we construct votes:

 oi: d≻Pi≻Di≻D−i≻P−i≻p≻q≻D′≻D′′≻D′′′, o′i: d≻←Pi≻←−Di≻D−i≻P−i≻p≻q≻D′≻D′′≻D′′′.

We add votes and with the reversed preference order of, respectively, and .

2. We introduce seven votes as follows:

 u1: p≻F≻D≻q≻D′≻←−D′′≻Gc≻D′′′≻d, u2: d≻←−D′′≻←−Gc≻D′′′≻←−D′≻D≻q≻p≻F, u3: p≻q≻d≻←−D′≻D′′′≻D≻F≻D′′≻Gc, u4: Gc≻d≻D′′≻F≻D≻p≻q≻D′′′≻D′, u5: d≻D′′′≻F≻Gc≻D′′≻D≻p≻q≻D′, u6: q≻p≻D≻D′′≻d≻←−−D′′′≻D′≻F≻Gc, u7: q≻D′≻Gc≻d≻p≻F≻D≻D′′≻D′′′.

Our election admits unit prices, and the budget is .

We show the scores of the candidates (prior to bribery) in Table 2. For example, candidate wins head-to-head contests with all the candidates in , , , and , which accounts for the first points. Candidate also wins with all the edge, vertex, and filler candidates, which gives additional points. Finally, wins with  but not with .