Frugal Bribery in Voting

04/30/2015 ∙ by Palash Dey, et al. ∙ ERNET India 0

Bribery in elections is an important problem in computational social choice theory. However, bribery with money is often illegal in elections. Motivated by this, we introduce the notion of frugal bribery and formulate two new pertinent computational problems which we call Frugal-bribery and Frugal- bribery to capture bribery without money in elections. In the proposed model, the briber is frugal in nature and this is captured by her inability to bribe votes of a certain kind, namely, non-vulnerable votes. In the Frugal-bribery problem, the goal is to make a certain candidate win the election by changing only vulnerable votes. In the Frugal-dollarbribery problem, the vulnerable votes have prices and the goal is to make a certain candidate win the election by changing only vulnerable votes, subject to a budget constraint of the briber. We further formulate two natural variants of the Frugal-dollarbribery problem namely Uniform-frugal-dollarbribery and Nonuniform-frugal-dollarbribery where the prices of the vulnerable votes are, respectively, all the same or different. We study the computational complexity of the above problems for unweighted and weighted elections for several commonly used voting rules. We observe that, even if we have only a small number of candidates, the problems are intractable for all voting rules studied here for weighted elections, with the sole exception of the Frugal-bribery problem for the plurality voting rule. In contrast, we have polynomial time algorithms for the Frugal-bribery problem for plurality, veto, k-approval, k-veto, and plurality with runoff voting rules for unweighted elections. However, the Frugal-dollarbribery problem is intractable for all the voting rules studied here barring the plurality and the veto voting rules for unweighted elections.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

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

1 Introduction

In a typical voting scenario, we have a set of candidates and a set of voters reporting their preferences or votes which are complete rankings of the candidates. A voting rule is a procedure that, given a collection of votes, chooses one candidate as the winner. A set of votes over a set of candidates along with a voting rule is called an election.

Activities that try to influence voter opinions, in favor of specific candidates, are very common during the time that an election is in progress. For example, in a political election, candidates often conduct elaborate campaigns to promote themselves among a general or targeted audience. Similarly, it is not uncommon for people to protest against, or rally for, a national committee or court that is in the process of approving a particular policy. An extreme illustration of this phenomenon is bribery — here, the candidates may create financial incentives to sway the voters. Of course, the process of influencing voters may involve costs even without the bribery aspect; for instance, a typical political campaign or rally entails considerable expenditure.

All situations involving a systematic attempt to influence voters usually have the following aspects: an external agent, a candidate that the agent wishes to win (or lose) the election, a budget constraint, a cost model for a change of vote, and knowledge of the existing election. The formal computational problem that arises from these inputs is the following: is it possible to make a distinguished candidate win the election in question by incurring a cost that is within the budget? This is the problem of bribery from a computational perspective. This question, with origins in [Faliszewski et al., 2006, Faliszewski et al., 2009a, Faliszewski et al., 2009b], has been subsequently studied intensely in computational social choice literature. In particular, bribery has been studied under various cost models, for example, uniform price per vote which is known as $Bribery [Faliszewski et al., 2006], nonuniform price per vote [Faliszewski, 2008], nonuniform price per shift of the distinguished candidate per vote which is called the Shift bribery, nonuniform price per swap of candidates per vote which is called the Swap bribery [Elkind et al., 2009]. The campaigning problem has also been studied for various vote models, for example, truncated ballots [Baumeister et al., 2012], soft constraints [Pini et al., 2013], CP-nets [Dorn and Krüger, 2014], combinatorial domains [Mattei et al., 2012] and probabilistic lobbying [Erdélyi et al., 2009]. The bribery problem has also been studied under voting rule uncertainty [Erdelyi et al., 2014]. Faliszewski et al. [Faliszewski et al., 2014] study the complexity of bribery in Bucklin and Fallback voting rules. Xia [Xia, 2012] studies destructive bribery, where the goal of the briber is to change the winner by changing minimum number of votes. Dorn et al. [Dorn and Schlotter, 2012] studies the parameterized complexity of the Swap Bribery problem and Bredereck et al. [Bredereck et al., 2014] explores the parameterized complexity of the Shift Bribery problem for a wide range of parameters. We recall again that the costs and the budgets involved in all the bribery problems above need not necessarily correspond to actual money traded between voters and candidates. They may correspond to any cost in general, for example, the amount of effort or time that the briber needs to spend for each voter.

1.1 Motivation and Contributions

In this work, we propose an unusual but effective cost model for the bribery problem. Even the most general cost models that have been studied in the literature fix absolute costs per voter-candidate combination, with no specific consideration to the voters’ opinions about the current winner. We introduce a model where a change of vote is relatively easier to effect if the change causes an outcome that the voter would find desirable. Indeed, if the currently winning candidate is, say, , and a voter is (truthfully) promised that by changing her vote from to , the winner of the election would change from to , then this is a change that the voter is likely to be happy to make. While the change does not make her favorite candidate win the election, it does improve the result from her point of view. Thus, given the circumstances (namely that of her least favorite candidate winning the election), the altered vote serves the voter better than the original one.

We believe this perspective of voter influence is somewhat more sophisticated than the existing models in the literature. The cost of a change of vote is proportional to the nature of the outcome that the change promises — the cost is low or nil if the change results in better outcome with respect to the voter’s original ranking, and high or infinity otherwise. A frugal agent only approaches voters of the former category, thus being able to effectively bribe with minimal or no money.

Formally, let be the winner of an election and let (other than ) the candidate whom the briber wishes to make the winner of the election. Now, the voters who prefer to will be reluctant to change their votes, and we call these votes non-vulnerable with respect to — we do not allow these votes to be changed by the briber, which justifies the frugal nature of the briber. On the other hand, if a voter prefers to , then it maybe very easy to convince her to change her vote if doing so makes win the election. We name these votes vulnerable with respect to . When is clear from the context, we simply call these votes non-vulnerable and vulnerable, respectively.

The computational problem is to determine whether there are ways to make the candidate win the election by changing only those votes that are vulnerable with respect to . We call this problem Frugal-bribery. Note that there is no money involved in the Frugal-bribery problem. We also extend this basic model to a more general setting where each vulnerable vote has a certain nonnegative integer price which may correspond to the effort involved in approaching these voters and convincing them to change their votes. We also allow for the specification of a budget constraint, which can be used to model, for example, time constraints. This leads us to define the Frugal-$Bribery problem, where we are required to find vulnerable votes with a total cost that is within the budget; such that these votes can be changed in some way to make win the election. Note that the Frugal-$Bribery problem can be either uniform or nonuniform depending on whether the prices of the vulnerable votes are all identical or different. If not mentioned otherwise, the prices of the vulnerable votes will be assumed to be nonuniform. We remind that the briber is not allowed to change the non-vulnerable votes in both the Frugal-bribery and the Frugal-$Bribery problems.

We study and derive several interesting results on the computational complexity of the Frugal-bribery and the Frugal-$bribery problems with both uniform and nonuniform prices in unweighted as well as weighted elections for many commonly used voting rules. We believe that these problems are important as well as natural specializations of the $Bribery problem and their study has both theoretical and practical impact. The specific contributions of this paper are summarized below.

Unweighted Elections

We have the following results for unweighted elections.

  • The Frugal-bribery problem is in for the -approval, Bucklin, and plurality with runoff voting rules. Also, the Frugal-$bribery problem is in for the plurality and veto voting rules. In contrast, the Frugal-$bribery problem is in -complete () for the Borda, maximin, Copeland, and STV voting rules [Lemma 3].

  • The Frugal-bribery problem is in for the Borda voting rule [Theorem 1]. The Frugal-$bribery is in for the -approval for any constant [Theorem 2], -veto for any constant [Theorem 3], and a wide class of scoring rules [Theorem 5] even if the price of every vulnerable vote is either or . Moreover, the Uniform-frugal-$bribery is in for the Borda voting rule even if all the vulnerable votes have uniform price of and the budget is [Theorem 6].

  • The Frugal-$bribery problem is in for the -approval, Bucklin, and plurality with runoff voting rules when the budget is a constant [Theorem 4].

Weighted Elections

We have the following results for weighted elections.

  • The Frugal-bribery problem is in for the maximin and Copeland voting rules when we have only three candidates [Lemma 6], and for the plurality voting rule for any number of candidates [Theorem 7].

  • The Frugal-bribery problem is in for the STV [Theorem 11], plurality with runoff [Corollary 1], and every scoring rule except the plurality voting rule [Lemma 7] for three candidates. The Frugal-$bribery problem is in for the plurality voting rule even for three candidates [Theorem 8].

  • The Frugal-bribery problem is in for the maximin [Theorem 9], Bucklin [Theorem 12], and Copeland [Theorem 10] voting rules when we have only four candidates.

We summarize the results in the Table 1.

Voting Rule Unweighted Weighted
Frugal-bribery Frugal-$bribery Frugal-bribery Frugal-$bribery
Plurality
Lemma 1

Lemma 2

Theorem 7

Theorem 8
Veto
Lemma 1

Lemma 2

Lemma 7

Lemma 7
-approval
Lemma 1

Theorem 2

Lemma 7

Lemma 7
-veto
Lemma 1

Theorem 3

Lemma 7

Lemma 7
Borda
Theorem 1

Theorem 5

Lemma 7

Lemma 7
Plurality with runoff
Lemma 1
?
Corollary 1

Corollary 1
Maximin ?
Lemma 3

Theorem 9

Theorem 9
Copeland ?
Lemma 3

Theorem 10

Theorem 10
STV ?
Lemma 3

Theorem 11

Theorem 11
Table 1: - The result holds for . - The result holds for . - The result holds for a much wider class of scoring rules. - The results do not hold for the plurality voting rule. ?- The problem is open.

1.2 Related Work

The pioneering work of Faliszewski et al. [Faliszewski et al., 2006] defined and studied the $Bribery problem wherein the input is a set of votes with prices for each vote and the goal is to make some distinguished candidate win the election, subject to a budget constraint of the briber. The Frugal-$bribery problem is the $Bribery problem with the restriction that the price of every non-vulnerable vote is infinite. Also, the Frugal-bribery problem is a specialization of the Frugal $Bribery problem. Hence, whenever the $Bribery problem is computationally easy in a setting, both the Frugal-bribery and the Frugal $Bribery problems are also computationally easy (see Proposition 1 for a more formal proof). However, the $Bribery problem is computationally intractable in most of the settings and this leaves the computational complexity status of the Frugal-bribery and the Frugal-$bribery problems open in corresponding settings. Hazon et al. [Hazon et al., 2013] introduced and studied persuasion and -persuasion problems where an external agent suggests votes to vulnerable voters which is beneficial for the vulnerable voters as well as the external agent. It turns out that the persuasion and the -persuasion problems Turing reduce111For Turing reductions, we refer to [Rogers and Rogers, 1967] to the Frugal-bribery and the Frugal-$bribery problems respectively (see Proposition 2). Therefore, the polynomial time algorithms we propose in this work imply polynomial time algorithms for the persuasion variants. On the other hand, since the reduction in Proposition 2 from persuasion to frugal bribery is a Turing reduction, the existing results for the persuasion problems do not imply results for the corresponding frugal bribery variants.

2 Preliminaries

Let be the set of all voters and the set of all candidates. Each voter ’s vote is a preference over the candidates which is a complete order over . For example, for two candidates and , means that the voter prefers to . In the paper, whenever we do not specify any order among a set of candidates while describing a vote, the statement/proof is correct in whichever way we fix the order among them. We denote the set of all complete orders over by . Hence, denotes the set of all -voters’ preference profiles . We denote the set by , by , and by , for any integer . Let denote the disjoint union of sets. A map is called a voting correspondence. A map is called a tie breaking rule. A commonly used tie breaking rule is the lexicographic tie breaking rule where ties are broken according to a predetermined preference . A voting rule is , where denotes composition of mappings. In many settings, the voters may have positive integer weights. Such an election is called a weighted election. To compute the winner of a weighted election, we replace each vote by as many copies of the vote as its weight and then we apply a voting rule. We assume the elections to be unweighted, if not stated otherwise. Given an election , we can construct a directed weighted graph , called the weighted majority graph, from . The set of vertices in is the set of candidates in . For any two candidates and , the weight of the edge is , where is the number of voters who prefer to . A candidate is called the Condorcet winner in an election if for every other candidate . A voting rule is called Condorcet consistent if it selects the Condorcet winner as the winner of the election whenever it exists. A voting rule is called monotonic if improving winner’s position in any vote without changing the ordering among other candidates does not change the winner. Some examples of common voting correspondences are as follows.

  • Positional scoring rules : A collection of

    -dimensional vectors

    with and for every naturally defines a voting rule - a candidate gets score from a vote if it is placed at the position, and the score of a candidate is the sum of the scores it receives from all the votes. The winners are the candidates with maximum score. Scoring rules remain unchanged if we multiply every by any constant and/or add any constant . Hence, we assume without loss of generality that for any score vector , there exists a such that and for all . We call such a a normalized score vector. If is for and otherwise, then, we get the -approval voting rule. For the -veto voting rule, is for and otherwise. -approval is called the plurality voting rule and -veto is called the veto voting rule.

  • Maximin: The maximin score of a candidate is . The winners are the candidates with maximum maximin score.

  • Copeland: Given , the Copeland score of a candidate is . The winners are the candidates with maximum Copeland score. If not mentioned otherwise, we will assume to be zero.

  • Bucklin: A candidate ’s Bucklin score is the minimum number such that more than half of the voters rank in their top positions. The winners are the candidates with lowest Bucklin score.

  • Plurality with runoff: The top two candidates according to the plurality scores are selected first. The pairwise winner of these two candidates is selected as the winner of the election. This rule is often called the runoff voting rule.

  • Single Transferable Vote: In Single Transferable Vote (STV), a candidate with the least plurality score is dropped from the election and its votes are transferred to the next preferred candidate. If two or more candidates receive the least plurality score, then a tie breaking rule is used. The candidate that remains after rounds is the winner.

Among the above voting correspondences along with any arbitrary lexicographic tie-breaking rule, the scoring rules, maximin, Copeland, and Bucklin voting rules are monotonic and only the maximin and the Copeland voting rules are Condorcet consistent.

2.1 Problem Definition

Given an election and a particular candidate, we define the notion of vulnerable votes as follows.

Definition 1.

(Vulnerable votes)
Given a voting rule , a set of candidates , a profile of votes , and a distinguished candidate in , we say a vote is -vulnerable if .

We note that the definition of vulnerable votes require elections to have exactly one winner. For this reason, we explicitly mention a tie-breaking rule in all our proofs. Recall that, whenever the distinguished candidate is clear from the context, we drop it from the notation. With the above definition of vulnerable votes, we next define the Frugal-bribery problem. Intuitively, the problem is to determine whether a particular candidate can be made winner by changing only the vulnerable votes.

Definition 2.

(-Frugal-bribery)
Given a voting rule , a set of candidates , a preference profile , and a distinguished candidate in , determine whether there is a way to make win the election by changing only the vulnerable votes.

The Frugal-bribery problem is extended to the Frugal-$bribery problem below which involves prices for the vulnerable votes.

Definition 3.

(-Frugal-$bribery)
Given a voting rule , a set of candidates , a preference profile , a distinguished candidate in , a finite budget , and a price function , determine if there is a way to make win the election by changing only the vulnerable votes subject to budget constraint . If the prices of all vulnerable votes are the same then we call the problem uniform-Frugal-$bribery. Otherwise, we call it nonuniform-Frugal-$bribery.

The above problems are specializations of the well studied $Bribery problem. Also, the Coalitional-Manipulation problem [Bartholdi III et al., 1989, Conitzer et al., 2007], one of the classic problems in computational social choice theory, turns out to be a special case of the Frugal-$bribery problem [see Proposition 1]. For the sake of completeness, we include the definitions of these problems here.

Definition 4.

(-$Bribery[Faliszewski et al., 2009a]
Given a voting rule , a set of candidates , a preference profile , a distinguished candidate in , a price function , and a budget , determine if there a way to make win the election.

Definition 5.

(Coalitional-Manipulation[Bartholdi III et al., 1989, Conitzer et al., 2007]
Given a voting rule , a set of candidates , a preference profile of truthful voters, an integer , and a distinguished candidate in , determine if there exists a voter preference profile such that the candidate wins uniquely (does not tie with any other candidate) in the profile .

We denote an arbitrary instance of the Coalitional-Manipulation problem by . The following proposition shows the relationship among the above problems.

Proposition 1.

For every voting rule, Frugal-bribery 222The notation denotes that the problem polynomial time many-to-one reduces to problem  [Garey and Johnson, 1979]. uniform-Frugal-$bribery nonuniform-Frugal-$bribery $Bribery. Also, Coalitional-Manipulation nonuniform-Frugal-$bribery.

Proof.

Given a Frugal-bribery instance, we construct a Uniform-frugal-$bribery instance by defining the price of every vulnerable vote to be zero and the budget to be zero. Clearly, the two instances are equivalent. Hence, Frugal-bribery Uniform-frugal-$bribery.

Uniform-frugal-$bribery Nonuniform-frugal-$bribery $Bribery follows from the fact that Uniform-frugal-$bribery is a specialization of Nonuniform-frugal-$bribery which in turn is a specialization of $Bribery.

Given a Manipulation instance, we construct a Nonuniform-frugal-$bribery instance as follows. Let be the distinguished candidate of the manipulators and be any arbitrary but fixed ordering of the candidates given in the Manipulation instance. Without loss of generality, we can assume that does not win if all the manipulators vote (Since, this is a polynomially checkable case of Manipulation). We define the vote of the manipulators to be , the distinguished candidate of the campaigner to be , the budget of the campaigner to be zero, the price of the manipulators to be zero and the price of the rest of the vulnerable votes to be one. Clearly, the two instances are equivalent. Hence, Manipulation Nonuniform-frugal-$bribery. ∎

We can also establish the following relationship between the persuasion (respectively -persuasion) problem [Hazon et al., 2013] and the Frugal-bribery (respectively Frugal-$bribery) problem. The persuasions differ from the corresponding frugal bribery variants in that the briber has her own preference order, and desires to improve the outcome of the election with respect to her preference order. The following proposition is immediate from the definitions of the problems.

Proposition 2.

For every voting rule, there is a Turing reduction from Persuasion (respectively -persuasion) to Frugal-bribery (respectively Frugal-$bribery).

Proof.

Given an algorithm for the Frugal-bribery problem, we iterate over all possible distinguished candidates to have an algorithm for the persuasion problem.

Given an algorithm for the Frugal-$bribery problem, we iterate over all possible distinguished candidates and fix the price of the corresponding vulnerable votes to be one to have an algorithm for the -persuasion problem. ∎

3 Unweighted Elections

We present the results for unweighted elections below.

Lemma 1.

The Frugal-bribery problem is in for the -approval voting rule for any , Bucklin, and plurality with runoff voting rules.

Proof.

The Manipulation problem is in for these voting rules [Xia et al., 2009]. Hence, the result follows from Proposition 1. ∎

Lemma 2.

The Frugal-$bribery problem is in for the plurality and veto voting rules.

Proof.

The $Bribery problem is in for the plurality [Faliszewski et al., 2006] and veto [Faliszewski, 2008] voting rules. Hence, the result follows from Proposition 1. ∎

Lemma 3.

The Frugal-$bribery problem is in for Borda, maximin, Copeland, and STV voting rules.

Proof.

The Manipulation problem is in for the above voting rules. Hence, the result follows from Proposition 1. ∎

Next, we show that the Frugal-$bribery problem for the -approval for any constant , -veto for any constant , and a class of scoring rules are in . To this end, we reduce from the Exact Cover by 3-Sets (X3C) problem, which is known to be [Garey and Johnson, 1979]. The X3C problem is defined as follows.

Definition 6.

(X3C Problem)
Given a universe and subsets with does there exist an index set with such that ? We denote an arbitrary instance of X3C by .

We now prove that the Frugal-bribery problem is in for the Borda voting rule, by a reduction from X3C. We first provide an informal road map for the proof. To begin with, we would like to define a collection of votes with one vote for every set in the X3C instance. The candidate set will have a candidate for every element in the universe; and two additional candidates and , and more dummy candidates as we need them in the construction.

The votes corresponding to the sets are engineered to have the following properties: first, they are vulnerable, and second, they have the preferred candidate, say , at the top position. Now, the winning candidate, say , is designed to have a Borda score that is more than the score of the preferred candidate, and is also placed in the fifth-last position of all these votes. In particular, a vote corresponding to a set will have the following form, where the elements of the universe are arranged in an arbitrary but fixed order:

Since is already on the top of all of these votes, a campaigner has no hope of increasing the score of . Also, the most that the campaigner can decrease the score of is by four per vote, given the structure of the Borda score vector and the fact that is at the fifth position from the bottom. Therefore, it will suffice if is “pushed to the bottom” in votes. Note that every time is pushed to the bottom, the scores of the elements participating in increase. However, a solution may, in general, indulge in changing more than votes. To ensure that this does not happen, we use additional elements to force a score difference of exactly one between and the candidates corresponding to the elements of the universe. This ensures that a valid solution cannot afford to increase the score of any candidate corresponding to the universe by more than one; and therefore only votes are affected. The sets corresponding to the affected votes must form a set cover for the same reason. The challenge is to ensure that we achieve these properties using only non-vulnerable votes. We are now ready to describe the details.

Theorem 1.

The Frugal-bribery problem is in for the Borda voting rule.

Proof.

The problem is clearly in . To show -hardness, we reduce an arbitrary instance of X3C to Frugal-bribery. Let be an instance of X3C.

We define a Frugal-bribery instance as follows. Let be the universe size . The candidate set is , where . Let us fix any arbitrary order among the candidates in . For any subset , let be the ordering among the candidates in as defined in and the reverse order of . For each , we add two votes and as follows.

Let be any arbitrary mutually disjoint subsets of with . We now add the following two votes and .

The distinguished candidate is . The tie-breaking rule is “”. Hence, the winner is and thus only the votes in are vulnerable. We claim that the two instances are equivalent. Suppose there exists an index set with such that . We replace the votes with which is defined as follows.

The final score of is the same as the final scores of and every candidate in and more than the score of every candidate in . This makes win the election due to the tie-breaking rule.

To prove in the other direction, suppose the Frugal-bribery instance is a Yes instance. Notice that, the only vulnerable votes are for every . We assume without loss of generality, that candidate is placed at the first position in all the changed votes. The votes and ensure that the score of must decrease by for to win. Hence, there must be at least votes that are changed since each vote change can reduce the score of by at most . Also, in each vote where the position of has been changed, the score of from that vote must increase, since otherwise, there will be at least one candidate whose score must increase by two contradicting the fact that wins the election. However, the score of can increase by at most . Hence, there will be exactly votes where ’s score decreases and thus in all those votes, must come at the last position. We claim that the ’s corresponding to the changed votes must form an exact set cover. Indeed, otherwise, there will be a candidate in whose score does not increase and thus there will be some other candidate in whose score increases by at least two contradicting the fact that wins the election. ∎

The following Lemma has been used before (Lemma 4.2 in [Baumeister et al., 2011]) and we will use it in subsequent proofs.

Lemma 4.

Let be a set of candidates and a normalized score vector of length . Then, for any given , there exists and a voting profile such that the -score of is for all , and the score of candidates is less than . Moreover, the number of votes is , where denotes the absolute value of .

Note that, the number of votes used in Lemma 4 is polynomial in if and are polynomials in for every , which indeed is the case for all our proofs that use Lemma 4. Hence, the reductions in the proofs that use Lemma 4 run in polynomial amount of time. We now show the results for various classes of scoring rules.

Theorem 2.

The Frugal-$bribery problem is in for the -approval voting rule for any constant , even if the price of every vulnerable vote is either or .

Proof.

The problem is clearly in . To show -hardness, we reduce an arbitrary instance of X3C to Frugal-$bribery. Let be an instance of X3C. We define a Frugal-$bribery instance as follows. The candidate set is , where . For each , we add a vote as follows.

By Lemma 4, we can add many additional votes to ensure the following scores (denoted by ).

The tie-breaking rule is “”. The winner is . The distinguished candidate is and thus all the votes in are vulnerable. The price of every is and the price of every other vulnerable vote is . The budget is . We claim that the two instances are equivalent. Suppose there exists an index set with such that . We replace the votes with as follows.

This makes the score of not less than the score of any other candidate and thus wins.

To prove the result in the other direction, suppose the Frugal-$bribery instance is a Yes instance. Then notice that there will be votes in where the candidate should not be placed within the top positions since and the budget is . We claim that the ’s corresponding to the ’s that have been changed must form an exact set cover. Indeed, otherwise, there will be a candidate , whose score never decreases which contradicts the fact that wins the election since . ∎

Next, we have a similar result for the -veto voting rule.

Theorem 3.

The Frugal-$bribery problem is in for the -veto voting rule for any constant , even if the price of every vulnerable vote is either or .

Proof.

The problem is clearly in . To show -hardness, we reduce an arbitrary instance of X3C to Frugal-$bribery. Let be any instance of X3C. We define a Frugal-$bribery instance as follows. The candidate set is , where . For each , we add a vote as follows.

By Lemma 4, we can add many additional votes to ensure the following scores (denoted by ).

The tie-breaking rule is “”. The winner is . The distinguished candidate is and thus all the votes in are vulnerable. The price of every is one and the price of any other vote is . The budget is . We claim that the two instances are equivalent. Suppose there exists an index set with such that . We replace the votes with as follows.

The score of each decreases by and their final scores are , since the score of is not affected by this change. Also the final score of each is since forms an exact set cover. This makes win the election.

To prove the result in the other direction, suppose the Frugal-$bribery instance is a Yes instance. Then notice that there will be exactly votes in , where every , should come in the last positions since and the budget is . Notice that, candidates in must not be placed within top positions since , for every . Hence, in the votes that have been changed, and all the candidates in must occupy the last positions. We claim that the ’s corresponding to the ’s that have been changed must form an exact set cover. If not, then, there must exist a candidate and two votes and such that, both and have been replaced by and and the candidate was present within the last positions in both and . This makes the score of at least the score of which contradicts the fact that wins. ∎

However, the following result shows a polynomial time algorithm for the Frugal-$bribery problem for the -approval, Bucklin, and plurality with runoff voting rules, when the budget of the campaigner is a constant.

Theorem 4.

The Frugal-$bribery problem is in for -approval, Bucklin, and plurality with runoff voting rules if the budget is a constant.

Proof.

Let the budget be a constant. Then, at most many vulnerable votes whose price is not zero can be changed since the prices are assumed to be in . Notice that, we may assume, without loss of generality, that all the vulnerable votes whose price is zero will be changed. We iterate over all the many possible vulnerable vote changes and we can solve each one in polynomial amount of time since the Manipulation problem is in for these voting rules[Xia et al., 2009]. ∎

We show that the Frugal-$bribery problem is in for a wide class of scoring rules as characterized in the following result.

Theorem 5.

For any positional scoring rule with score vectors , if there exists a polynomial function such that, for every and in the score vector , there exists a satisfying the following condition:

then the Frugal-$bribery problem is in for even if the price of every vulnerable vote is either or .

Proof.

Since the scoring rules remain unchanged if we multiply every by any constant and/or add any constant , we can assume the following without loss of generality.

The problem is clearly in . To show -hardness, we reduce an arbitrary instance of X3C to Frugal-$bribery. Let be an instance of X3C. We define a Frugal-$bribery instance as follows. The candidate set is , where . For each , we add a vote as follows.

By Lemma 4, we can add many additional votes to ensure the following scores (denoted by ).

The tie-breaking rule is “”. The distinguished candidate is . The price of every is and the price of every other vulnerable vote is . The budget is . We claim that the two instances are equivalent. In the forward direction, there exists an index set such that . We replace the votes with as follows.

This makes the score of at least one more than the score of every other candidate and thus wins.

To prove the result in the other direction, suppose there is a way to make win the election. Notice that, the candidates in cannot change their positions in the changed votes and must occupy the last positions due to their score difference with . Now, we claim that there will be exactly votes where the candidate must be placed at the position since and the budget is . We claim that the ’s corresponding to the changed votes must form an exact set cover. If not, then there must exist a candidate whose score has increased by at least two contradicting the fact that wins the election. ∎

For the sake of concreteness, an example of a function , stated in Theorem 5, that works for the Borda voting rule is . Theorem 5 shows that the Frugal-$bribery problem is intractable for the Borda voting rule. However, the following theorem shows the intractability of the uniform-Frugal-$bribery problem for the Borda voting rule, even in a very restricted setting.

Theorem 6.

The uniform-Frugal-$bribery problem is in for the Borda voting rule, even when all the vulnerable votes have a price of and the budget is .

Proof.

The problem is clearly in . To show -hardness, we reduce an arbitrary instance of the Manipulation problem for the Borda voting rule with two manipulators to an instance of the uniform-Frugal-$bribery problem for the Borda voting rule. Let be an arbitrary instance of the Manipulation problem for the Borda voting rule. The corresponding Frugal-$bribery instance is as follows. The candidate set is . For each vote , we add a vote . Corresponding to the two manipulators’, we add two more votes , where is an arbitrary but fixed order of the candidates in . We add more votes to ensure the following score differences ( and are the score functions for the Manipulation and the uniform-Frugal-$bribery instances respectively).

This will be achieved as follows. For any two arbitrary candidates and , the following two votes increase the score of by one more than the rest of the candidates except whose score increases by one less. This construction has been used before [Xia et al., 2010, Davies et al., 2011].

Also we can ensure that candidate is always in positions and the candidate never immediately follows in these new votes. The tie-breaking rule is “”. The distinguished candidate is . The price of every vulnerable vote is one and the budget is two. We claim that the two instances are equivalent. Suppose the Manipulation instance is a Yes instance. Let be the manipulators’ votes that make win. In the Frugal-$bribery instance, we replace by for . This makes win the election. On the other hand, since in all the vulnerable votes except and , the candidate never immediately follows candidate , changing any of these votes can never make win the election since and the budget is two. Hence, the only way can win the election, if at all possible, is by changing the votes and . Let a vote replaces for . We can assume, without loss of generality, that and are at the first and the second positions respectively in both and . Let be the order restricted only to the candidates in . This makes winner of the Manipulation instance since, for every . ∎

4 Weighted Elections

Now, we turn our attention to weighted elections.

Lemma 5.

The following results follow immediately from the literature [Conitzer et al., 2007] and Proposition 1.

  • The Frugal-bribery problem is in for the maximin and the Copeland voting rules for three candidates.

  • The Frugal-bribery problem is in for any scoring rule except plurality for three candidates.

Lemma 6.

The Frugal-bribery problem is in for the maximin and the Copeland voting rules for three candidates.

Proof.

The Manipulation problem is in for the maximin, Copeland voting rules for three candidates [Conitzer et al., 2007]. Hence, the result follows from Proposition 1. ∎

Lemma 7.

The Frugal-bribery problem is in for any scoring rule except plurality for three candidates.

Proof.

The same proof for Theorem 6 of [Conitzer et al., 2007] would work here. ∎

Theorem 7.

The Frugal-bribery problem is in for the plurality voting rule.

Proof.

Let be the distinguished candidate of the campaigner. The greedy strategy of just replacing every vulnerable vote by solves the problem due to the monotonicity property of the plurality voting rule. ∎

The Partition problem, which is known to be [Garey and Johnson, 1979], is defined as follows.

Definition 7.

(Partition Problem)
Given a finite multi-set of positive integers with , does there exist a subset such that ? An arbitrary instance of Partition is denoted by .

We define another problem which we call -Partition as below and prove that it is also . We will use this fact in the proof of Theorem 11.

Definition 8.

(-Partition Problem)
Given a finite multi-set of positive integers with , does there exist a subset such that ? An arbitrary instance of -Partition is denoted by .

Lemma 8.

-Partition problem is in .

Proof.

The problem is clearly in . To show -hardness, we reduce the Partition problem to it. Let be an arbitrary instance of the Partition problem. We can assume, without loss of generality, that , since otherwise the instance is trivially a no instance. The corresponding -Partition problem instance is defined by , where . We claim that the two instances are equivalent. Suppose, the Partition instance is a Yes instance and thus there exists a set such that . This gives a solution to the -Partition instance. To prove the result in the other the other direction, suppose there is a set such that . This gives a solution to the Partition problem instance since . ∎

We now present the hardness results in weighted elections. We start with the plurality voting rule below.

Theorem 8.

The Frugal-$bribery problem is in for the plurality voting rule for three candidates.

Proof.

The problem is clearly in . We reduce an arbitrary instance of Partition to an instance of Frugal-$bribery for the plurality voting rule. Let with and , be an arbitrary instance of the Partition problem. The candidates are and . We will add votes in such a way that makes win the election. The distinguished candidate is . For every , there is a vote of both weight and price . There are two votes of weight (we do not need to define the price of this vote since it is non-vulnerable) and of both weight and price . The tie-breaking rule is “”. We define the budget to be . We claim that the two instances are equivalent.

Suppose there exists a such that . We change the votes corresponding to the weights in to . This makes win the election with a score of . To prove in the other direction, for to win, its score must increase by at least . Also, the prices ensure that ’s score can increase by at most . Hence, ’s score must increase by exactly by and the only way to achieve this is to increase its score by changing the votes corresponding to the weights in . Thus, can win only if there exists a such that . ∎

Next we show the hardness result for the maximin voting rule.

Theorem 9.

The Frugal-bribery problem is in for the maximin voting rule for four candidates.

Proof.

The problem is clearly in . We reduce an arbitrary instance of Partition to an instance of Frugal-bribery for the maximin voting rule. Let with and , be an arbitrary instance of the Partition problem. The candidates are and . For every , there is a vote of weight . There is one vote , one , and one each of weight . The tie-breaking rule is “”. The distinguished candidate is . Let us call the set of votes corresponding to the weights in and the rest of the votes . Notice that, only the votes in are vulnerable. We claim that the two instances are equivalent.

Suppose there exists a such that . We change the votes corresponding to the weights in to . We change the rest of the votes in to . The maximin score of every candidate is and thus due to the tie-breaking rule, wins the election.

On the other hand, suppose there is a way to change the vulnerable votes, that is the votes in , that makes win the election. Without loss of generality, we can assume that all the votes in place at top position. First notice that the only way could win is that the vertices and must form a cycle in the weighted majority graph. Otherwise, one of and will be a Condorcet winner and thus the winner of the election. Now, we show that the candidate must defeat the candidate . If not, then must defeat my a margin of since the maximin score of is fixed at . Also, must defeat by a margin of , otherwise the maximin score of will be more than . This implies that all the votes in must be which makes defeat . This is a contradiction since the vertices and must form a cycle in the weighted majority graph. Hence must defeat with a margin of . This forces every vote in to prefer over . Hence, without loss of generality, we assume that all the votes in are either or , since whenever is right after , we can swap and and this will only reduce the score of without affecting the score of any other candidates. If the total weight of the votes in is more than , then , thereby making the maximin score of more than the maximin score of . If the total weight of the votes in is less than then, , thereby making the maximin score of more than the maximin score of . Thus the total weight of the votes in should be exactly which corresponds to a partition of . ∎

We turn our attention to the Copeland voting rule next.

Theorem 10.

The Frugal-bribery problem is in for the Copeland voting rule for four candidates, whenever .

Proof.

The problem is clearly in . We reduce an arbitrary instance of Partition to an instance of Frugal-bribery for the Copeland voting rule. Let with and , be an arbitrary instance of the Partition problem. The candidates are and . For every , there is a vote of weight . There are two votes and each of weight . The tie-breaking rule is “”. The distinguished candidate is . Let us call the set of votes corresponding to the weights in be and the rest of the votes be . Notice that, only the votes in are vulnerable. We claim that the two instances are equivalent.

Suppose there exists a such that . We change the votes corresponding to the weights in to . We change the rest of the votes in to . This makes win the election with a Copeland score of two.

On the other hand, suppose there is a way to change the votes in that makes win the election. Without loss of generality, we can assume that all the votes in place at top position. We will show that one of the three pairwise elections among and must be a tie. Suppose not, then must lose to both and , otherwise wins the election due to the tie-breaking rule. Now, consider the pairwise election between and . If defeats , then wins the election due to the tie-breaking rule. If defeats , then wins the election again due to the tie-breaking rule. Hence, one of the pairwise elections among and must be a tie. Without loss of generality suppose and ties. Then the total weight of the votes that prefer to in must be which constitutes a partition of . ∎

We now show the hardness result for the STV voting rule.

Theorem 11.

The Frugal-bribery problem is in for the STV voting rule for three candidates.

Proof.

The problem is clearly in . We reduce an arbitrary instance of -Partition to an instance of Frugal-bribery for the STV voting rule. Let with and , be an arbitrary instance of the -Partition problem. The candidates are and . For every , there is a vote of weight . There is a vote of weight and a vote of weight . The tie-breaking rule is “”. The distinguished candidate is . Let us call the set of votes corresponding to the weights in and the rest of the votes be . Notice that, only the votes in are vulnerable. We claim that the two instances are equivalent.

Suppose there exists a such that . We change the votes corresponding to the weights in to . We do not change the rest of the votes in . This makes win the election.

To prove the other direction, suppose there is a way to change the votes in that makes win the election. First notice that, can win only if qualifies for the second round. Hence, the total weight of the votes in that put at the first position must be at least . On the other hand, if the total weight of the votes in that put at the first position is strictly more than , then does not qualify for the second round and thus cannot win the election. Hence the total weight of the votes in that put at the first position must be exactly equal to which constitutes a -Partition of . ∎

For three candidates, the STV voting rule is the same as the plurality with runoff voting rule. Hence, we have the following corollary.

Corollary 1.

The Frugal-bribery problem is in for the plurality with runoff voting rule for three candidates.

Next we show, that the Frugal-bribery problem for the Bucklin voting rule is in .

Theorem 12.

The Frugal-bribery problem is in for the Bucklin voting rule for four candidates.

Proof.

The problem is clearly in . We reduce an arbitrary instance of Partition to an instance of Frugal-bribery for the Bucklin voting rule. Let with and , be an arbitrary instance of the Partition problem. The candidates are and . For every , there is a vote of weight . There are two votes and each of weight . The tie-breaking rule is “”. The distinguished candidate is . Let denotes the set of votes corresponding to the weights in and the rest of the votes be . Notice that, only the votes in are vulnerable. We claim that the two instances are equivalent.

Suppose there exists a such that . We change the votes corresponding to the weights in to . We change the rest of the votes in to . This makes win the election with a Bucklin score of three.

To prove the result in the other direction, suppose there is a way to change the votes in that makes win the election. Without loss of generality, we can assume that all the votes in place at the first position. First notice that the Bucklin score of is already fixed at three. In the votes in , the candidate can never be placed at the second position since that will make the Bucklin score of to be two. Also the total weight of the votes in that place in their second position can be at most . The same holds for . Hence, the total weight of the votes that place in their second position will be exactly equal to which constitutes a partition of . ∎

From Proposition 1, Lemma 7, Theorem 8 to 12 , and Corollary 1, we get the following corollary.

Corollary 2.

The uniform-Frugal-$bribery and the nonuniform-Frugal-$bribery problems are in for the scoring rules except plurality, STV, and the plurality with runoff voting rules for three candidates and for the maximin, Copeland, and Bucklin voting rules for four candidates.

5 Conclusion

We have proposed and studied a sophisticated model of bribery in this work. It turns out that the problems studied in this paper present interesting connections to two of the best studied problems in computational social choice theory, namely Manipulation and $Bribery. We believe that our work has practical appeal as well while it is interesting, on its own, from a purely theoretical point of view.

A potential and natural direction for future work is to study these problems under various other settings. One obvious setting is to restrict the campaigner’s knowledge about the votes and/or the candidates who will actually turn up. The uncertainty can also arise from the voting rule that will eventually be used among a set of voting rules. Also, studying these problems when the pricing model for vulnerable votes is similar to swap bribery would be another interesting future direction. However, it is not very clear whether a swap bribery like pricing model has any practical motivation in the setting of bribery without money.

References

  • [Bartholdi III et al., 1989] Bartholdi III, J., Tovey, C. A., and Trick, M. A. (1989). Voting schemes for which it can be difficult to tell who won the election. Social Choice and Welfare (SCW), 6(2):157–165.
  • [Baumeister et al., 2012] Baumeister, D., Faliszewski, P., Lang, J., and Rothe, J. (2012). Campaigns for lazy voters: Truncated ballots. In Proceedings of the 11th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 577–584. International Foundation for Autonomous Agents and Multiagent Systems.
  • [Baumeister et al., 2011] Baumeister, D., Roos, M., and Rothe, J. (2011). Computational complexity of two variants of the possible winner problem. In The 10th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 853–860. International Foundation for Autonomous Agents and Multiagent Systems.
  • [Bredereck et al., 2014] Bredereck, R., Chen, J., Faliszewski, P., Nichterlein, A., and Niedermeier, R. (2014). Prices matter for the parameterized complexity of shift bribery. In

    International Conference on Artificial Intelligence (AAAI)

    .
  • [Conitzer et al., 2007] Conitzer, V., Sandholm, T., and Lang, J. (2007). When are elections with few candidates hard to manipulate? Journal of the ACM (JACM), 54(3):14.
  • [Davies et al., 2011] Davies, J., Katsirelos, G., Narodytska, N., and Walsh, T. (2011). Complexity of and algorithms for Borda manipulation. In Proceedings of the International Conference on Artificial Intelligence (AAAI), pages 657–662.
  • [Dorn and Krüger, 2014] Dorn, B. and Krüger, D. (2014). On the hardness of bribery variants in voting with CP-Nets. arXiv preprint arXiv:1410.5186.
  • [Dorn and Schlotter, 2012] Dorn, B. and Schlotter, I. (2012). Multivariate complexity analysis of swap bribery. Algorithmica, 64(1):126–151.
  • [Elkind et al., 2009] Elkind, E., Faliszewski, P., and Slinko, A. (2009). Swap bribery. In

    Proceedings of the 2nd International Symposium on Algorithmic Game Theory (SAGT 2009)

    , pages 299–310. Springer.
  • [Erdélyi et al., 2009] Erdélyi, G., Fernau, H., Goldsmith, J., Mattei, N., Raible, D., and Rothe, J. (2009). The complexity of probabilistic lobbying. In Algorithmic Decision Theory, pages 86–97. Springer.
  • [Erdelyi et al., 2014] Erdelyi, G., Hemaspaandra, E., and Hemaspaandra, L. A. (2014). Bribery and voter control under voting-rule uncertainty. In Proceedings of the 13th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 61–68. International Foundation for Autonomous Agents and Multiagent Systems.
  • [Faliszewski, 2008] Faliszewski, P. (2008). Nonuniform bribery. In Proceedings of the 7th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 1569–1572. International Foundation for Autonomous Agents and Multiagent Systems.
  • [Faliszewski et al., 2006] Faliszewski, P., Hemaspaandra, E., and Hemaspaandra, L. A. (2006). The complexity of bribery in elections. In International Conference on Artificial Intelligence (AAAI), volume 6, pages 641–646.
  • [Faliszewski et al., 2009a] Faliszewski, P., Hemaspaandra, E., and Hemaspaandra, L. A. (2009a). How hard is bribery in elections? Journal of Artificial Intelligence Research (JAIR), 35(2):485.
  • [Faliszewski et al., 2009b] Faliszewski, P., Hemaspaandra, E., Hemaspaandra, L. A., and Rothe, J. (2009b). Llull and Copeland voting computationally resist bribery and constructive control. Journal of Artificial Intelligence Research (JAIR), 35(1):275.
  • [Faliszewski et al., 2014] Faliszewski, P., Reisch, Y., Rothe, J., and Schend, L. (2014). Complexity of manipulation, bribery, and campaign management in bucklin and fallback voting. In Proceedings of the 13th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 1357–1358. International Foundation for Autonomous Agents and Multiagent Systems.
  • [Garey and Johnson, 1979] Garey, M. R. and Johnson, D. S. (1979). Computers and Intractability, volume 174. freeman New York.
  • [Hazon et al., 2013] Hazon, N., Lin, R., and Kraus, S. (2013). How to change a group’s collective decision? In Proceedings of the 23rd International Joint Conference on Artificial Intelligence (IJCAI), pages 198–205.
  • [Mattei et al., 2012] Mattei, N., Pini, M. S., Venable, K. B., and Rossi, F. (2012). Bribery in voting over combinatorial domains is easy. In Proceedings of the 11th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 1407–1408. International Foundation for Autonomous Agents and Multiagent Systems.
  • [Pini et al., 2013] Pini, M. S., Rossi, F., and Venable, K. B. (2013). Bribery in voting with soft constraints. In International Conference on Artificial Intelligence (AAAI).
  • [Rogers and Rogers, 1967] Rogers, H. and Rogers, H. (1967). Theory of recursive functions and effective computability, volume 126. McGraw-Hill New York.
  • [Xia, 2012] Xia, L. (2012). Computing the margin of victory for various voting rules. In Proceedings of the 13th ACM Conference on Electronic Commerce (EC), pages 982–999. ACM.
  • [Xia et al., 2010] Xia, L., Conitzer, V., and Procaccia, A. D. (2010). A scheduling approach to coalitional manipulation. In Proceedings of the 11th ACM conference on Electronic Commerce (EC), pages 275–284. ACM.