Algorithms for the Coalitional Manipulation Problem
Michael Zuckerman∗
Ariel D. Procaccia†
Abstract
We investigate the problem of coalitional manipulation in elections,
which is known to be hard in a variety of voting rules. We
put forward efficient algorithms for the problem in Scoring rules,
Maximin and Plurality with runoff, and analyze their windows of
error. Specifically, given an instance on which an algorithm fails,
we bound the additional power the manipulators need in order
to succeed. We finally discuss the implications of our results
with respect to the popular approach of employing computational
hardness to preclude manipulation.
1 Introduction
Social choice theory is an extremely well-studied subfield
of economics. In recent years, interest in the computational
aspects of social choice, and in particular in the computational aspects of voting, has sharply increased. Among other
things, this trend is motivated by numerous applications of
voting techniques and paradigms to problems in artificial intelligence [15, 12, 10].
In an election, a set of voters submit their (linear)
preferences (i.e., rankings) over a set of candidates. The
winner of the election is designated by a voting rule, which
is basically a mapping from the space of possible preference
profiles into candidates. A thorn in the side of social choice
theory is formulated in the famous Gibbard-Satterthwaite
Theorem [13, 21]. This theorem states that for any voting
rule that is not a dictatorship, there are elections in which at
least one of the voters would benefit by lying. A dictatorship
is a voting rule where one of the voters—the dictator—
single-handedly decides the outcome of the election.
Since the 1970s, when this impossibility result was
established, an enormous amount of effort has been invested
in discovering ways to circumvent it. Two prominent and
well-established ways are allowing payments [22, 4, 14], or
restricting the voters’ preferences [17].
∗ School of Computer Science and Engineering, The Hebrew University
of Jerusalem, Jerusalem 91904, Israel, email: [email protected].
The author thanks Noam Nisan for a generous grant which supported this
work.
† School of Computer Science and Engineering, The Hebrew University
of Jerusalem, Jerusalem 91904, Israel, email: [email protected].
The author is supported by the Adams Fellowship Program of the Israel
Academy of Sciences and Humanities.
‡ School of Computer Science and Engineering, The Hebrew University
of Jerusalem, Jerusalem 91904, Israel, email: [email protected]
Jeffrey S. Rosenschein‡
In this paper, we wish to discuss a third path—the “path
less taken”, if you will—which has been explored by computer scientists. The Gibbard-Satterthwaite Theorem implies
that in theory, voters are able to manipulate elections, i.e.,
bend them to their advantage by lying. But in practice, deciding which lie to employ may prove to be a hard computational problem; after all, there are a superpolynomial number
of possibilities of ranking the candidates.
Indeed, Bartholdi et al. [2] put forward a voting rule
where manipulation is NP-hard. In another important paper,
Bartholdi and Orlin [1] greatly strengthened the approach by
proving that the important Single Transferable Vote (STV)
rule is hard to manipulate.
This line of research has enjoyed new life in recent years
thanks to the influential work of Conitzer, Lang and Sandholm [7].1 The foregoing paper studied the complexity of
coalitional manipulation. In this setting, there is a coalition of potentially untruthful voters, attempting to coordinate
their ballots so as to get their favorite candidate elected. The
authors further assume that the votes are weighted: some voters have more power than others. Conitzer et al. show that
in a variety of prominent voting rules, coalitional manipulation is NP-hard, even if there are only a constant number
of candidates (for more details, see Section 2). This work
has been extended in numerous directions, by various authors [16, 20, 5, 8]; Elkind and Lipmaa [9], for example,
strengthened the abovementioned results about coalitional
manipulation by employing cryptographic techniques.
In short, computational complexity is by now a
well-established method of circumventing the GibbardSatterthwaite Theorem. Unfortunately, a shortcoming of the
results we mentioned above is that they are worst-case hardness results, and thus provide a poor obstacle against potential manipulators. Recent work regarding the average-case
complexity of manipulation have argued that manipulation
with respect to many worst-case-hard-to-manipulate voting
rules is easy in practice [6]. In particular, Procaccia and
Rosenschein [19, 18] have established some theoretical results regarding the tractability of the coalitional manipulation problem in practice. The matter was further discussed
by Erdelyi et al. [11]. In spite of this, the question of the
tractability of the manipulation problem, and in particular of
1 Historical note: although we cite the JACM 2007 paper, this work
originated in a AAAI 2002 paper.
277
~ = hm − 1, m − 2, . . . , 0i,
consider are: Borda, where α
~ = h1, 1, . . . , 1, 0i.
and Veto, where α
the coalitional manipulation problem, in practical settings is
still wide-open.
Our Approach and Results. We wish to convince
that, indeed, the coalitional manipulation problem can be
efficiently solved in practice, but our approach differs from
all previous work. We present efficient heuristic algorithms
for the problem which provide strong theoretical guarantees.
Indeed, we characterize small windows of instances on
which our algorithms may fail; the algorithms are proven to
succeed on all other instances.
Specifically, we prove the following results regarding
three of the most prominent voting rules (in which coalitional
manipulation is known to be NP-hard even for a constant
number of candidates):
• Maximin. For any two distinct candidates x and y, let
N(x, y) be the number of voters who prefer x to y. The
maximin score of x is S (x) = miny,x N(x, y).
• Copeland. For any two distinct candidates x and y, let
C(x, y) = +1 if N(x, y) > N(y, x) (in this case we say
that x beats y in their pairwise election), C(x, y) = 0
if N(x, y) = N(y, x), and C(x, y) = −1 if N(x, y) <
N(y, x). The Copeland score of candidate x is S (x) =
P
y,x C(x, y).
• Plurality with runoff. In this rule, a first round eliminates all candidates except the two with the highest plurality scores. The second round determines the winner
between these two by their pairwise election.
Theorem.
1. In the Borda rule, if it is possible to find a manipulation
In some settings the voters are weighted. A weight
for an instance with certain weights, Algorithm 2 will
succeed when given an extra manipulator with maximal function is a mapping w : S → N. When voters are
weighted, the above rules are applied by considering a voter
weight.
of weight l to be l different voters.
2. In the Plurality with Runoff rule, if it is possible to find
D 2.1.
a manipulation for an instance with certain weights, Al1. In the C C W Mgorithm 3 will succeed when given an extra manipulator
 (CCWM) problem, we are given a set C of canwith maximal weight.
didates, with a distinguished candidate p ∈ C, a set of
3. In the Maximin rule, if it is possible to find a manipuweighted voters S that already cast their votes (these
lation for an instance with certain weights, Algorithm 1
are the truthful voters), and weights for a set of voters
will succeed when given two copies of the set of manipT that still have not cast their votes (the manipulators).
ulators.
We are asked whether there is a way to cast the votes in
T such that p wins the election.
Structure of the Paper. In Section 2, we describe the
2. C C U M
major voting rules and formulate the coalitional manipula(CCUM) problem is a special case of CCWM problem
tion problem. In Section 3, we present and analyze our alwhere all the weights equal 1.
gorithms in three subsections: Borda, Plurality with Runoff,
and Maximin. Finally, we discuss our results in Section 4.
R 2.1. We implicitly assume in both questions that
2 Voting Rules and Manipulation Problems
An election consists of a set C = {c1 , . . . , cm } of candidates
and a set S = {v1 , . . . , v|S | } of voters. The voters provide a
total order on the candidates. To put it differently, each voter
submits a ranking of the candidates. The voting setting also
includes a voting rule, which is a function from the set of all
possible combinations of votes to C.
We shall discuss the following voting rules (whenever
the voting rule is based on scores, the candidate with the
highest score wins):
~ = hα1 , . . . , αm i be a vector of non• Scoring rules. Let α
negative integers such that α1 ≥ α2 ≥ . . . ≥ αm . For
each voter, a candidate receives α1 points if it is ranked
first by the voter, α2 if it is ranked second, etc. The
score sα~ of a candidate is the total number of points
the candidate receives. The scoring rules which we will
the manipulators have full knowledge about the other votes.
Unless explicitly stated otherwise, we also assume that ties
are broken adversarially to the manipulators, so if p ties with
another candidate, p loses.
T 2.1. ([7]) The CCWM problem in all the abovementioned voting rules is NP-complete, even when the number of candidates is constant.
Throughout this paper we will use the convention that
|C| = m, |S | = N and |T | = n. Whenever the voting rule
is based on scores, we will denote by S S , j (c) the score of
candidate c from the voters in S and the first j voters of
T (fixing some order on the voters of T ). Whenever it is
clear from the context that S is fixed, we will use simply
S j (c) for the same. Also, for G ⊆ C, 0 ≤ j ≤ n we will
write S j (G) = {S j (g) | g ∈ G}. For two lists A, B (ordered
multisets, possibly with multiplicities), we denote by A + B
the list which is obtained after B is appended to A.
278
N, |W| = |T | = n. It is enough to show that if there is
a manipulation for the set T , then for the same instance
with manipulator voters T 0 = T + {v} with weights list
W 0 = W + {w}, where w ≥ 1 is any integer, there is also
a manipulation, and the rest will follow by induction. Let
~ = hα1 , . . . , αm i be the scores vector of the rule. Let XS
α
be the preference orders of the voters in S , and XT be the
preference orders of voters in T that make p win. Fix some
order on the voters in T . By definition, for all c ∈ C \ {p},
S n (c) < S n (p). Let the additional voter of T 0 rank p at
the first place, and report some arbitrary order on the other
R 3.1. We refer to an iteration of the main for loop in candidates. Then for all c ∈ C \{p}, S n+1 (p) = S n (p)+wα1 >
S n (c) + wα1 ≥ S n+1 (c). Hence, p wins.
line 4 of the algorithm as a stage of the algorithm.
3 Results
We begin our contribution by presenting a general greedy
algorithm for the coalitional manipulation problem. Some of
our main results concern this algorithm or its restriction to
scoring rules.
The greedy algorithm is given as Algorithm 1. It
works as follows: the manipulators, according to descending
weights, each rank p first and rank the other candidates in a
way that minimizes their maximum score. This algorithm is
a generalization of the one that appeared in [3].
We will use the fact that for many voting rules, if
there exists a manipulation for a coalition of manipulators
with weights list W, then there exists a manipulation for a
coalition of manipulators with weights list W 0 where W 0 ⊇
W. Normally, if the coalition is too small then there is no
manipulation, and this is indeed what the algorithm will
report. On the other hand, if the coalition is large enough,
then the greedy algorithm will find the manipulation. So
there remains a window of error, where for some coalitions
there could exist a manipulation, but the algorithm may
not find it. We are interested in bounding the size of
this window. We first formulate the monotonicity property
described above.
D 3.1. In the context of the CCWM problem, a
voting rule is said to be monotone in weights if it satisfies
the following property: whenever there is a manipulation
making p win for manipulator set T with weights list W,
there is also a manipulation making p win for manipulator
set T 0 with weights list W 0 , where T 0 ⊇ T , W 0 ⊇ W.
Monotonicity in weights is a prerequisite for the type
of analysis we wish to present. However, not all the basic
voting rules have this property. In particular, the prominent
Copeland rule does not possess this property (see the full
version of the paper [23] for an example).
3.1 Borda In this subsection, we analyze the performance
of Algorithm 1 with respect to the important Borda voting
rule. Note that, in the context of scoring rules, Algorithm 1
reduces to Algorithm 2. This algorithm first appeared in
Procaccia and Rosenschein [19]. In this specific instantiation
of Algorithm 1, we do not require sorting the manipulators’
weights, as this does not play a part in our analysis.
L 3.1. Scoring rules are monotone in weights.
We are now ready to present our theorem regarding the
Borda rule.
T 3.1. In the Borda voting rule, let C be a set of
candidates with p ∈ C a preferred candidate, S a set of
voters who already cast their votes. Let W be the weights
list for the set T . Then:
1. If there is no ballot making p win the election, then
Algorithm 2 will return false.
2. If there exists a ballot making p win the election, then
for the same instance with weights list W +{w01 , . . . , w0k },
P
where k ≥ 1, ki=1 w0i ≥ max(W), Algorithm 2 will
return true.
A key notion for the proof of the theorem is the definition of the set GW . Let W be list of weights; we define GW as follows. Run the algorithm n + 1 stages with
the weights W + {w}, where w is an arbitrary weight. Let
G0W = argmaxg∈C\{p} {S 0 (g)}, and, by induction, for s =
s
s−1
1, 2, . . . : GW
= GW
∪ {g | g was ranked after some g0 ∈
s−1
GW at some stage l, 1 ≤ l ≤ n + 1}. Finally, let GW =
s
∪0≤sGW
. The definition is independent of the weight w, as
this weight is used only at stage n + 1, so it does not impact
the preferences of the voters, and thus it does not impact GW .
From the definition, G0W ⊆ G1W ⊆ . . . ⊆ C \ {p}. Furthermore,
as |C \ {p}| = m − 1, it follows that there exists 0 ≤ s0 ≤ m − 2
s0
s0 +1
s0
s.t. GW
= GW
, and thus GW = GW
= Gm−2
W .
L 3.2. Given W, the candidates in GW were ranked at
each stage l, 1 ≤ l ≤ n + 1 at |GW | last places, i.e., they were
always granted the points |GW | − 1, . . . , 0.
Proof. If, by way of contradiction, there exists c ∈ C \ GW
that was ranked at some stage at one of the last |GW | places,
then there is g ∈ GW that was ranked before c at that stage.
s
s+1
Let s ≥ 0 such that g ∈ GW
. By definition, c ∈ GW
⇒c∈
GW , a contradiction.
Proof. Let C be the candidates; p ∈ C is the preferred
candidate, S is the set of truthful voters, and W are the L 3.3. For all c ∈ C \ GW , it holds that S n (c) ≤
weights for the manipulators T . Denote |C| = m, |S | = ming∈GW {S n (g)}.
279
Algorithm 1 Decides CCWM
1: procedure G(C, p, XS , W)
|W| = |T | = n
2:
sort(W)
3:
X←φ
4:
for j = 1, . . . , n do
5:
P j ← (p)
6:
for t = 2, . . . , m do
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
. XS is the set of preferences of voters in S , W is the list of weights for voters in T ,
. Sort the weights in descending order
. Will contain the preferences of T
. Iterate over voters by descending weights
. Put p at the first place of the j-th preference list
. Iterate over places of j-th preference list
. Evaluate the score of each candidate if j would put it at the next available place
Pick c ∈ argminc∈C\P j {Score of c from XS ∪ X ∪ {P j + {c}}}
P j = P j + {c}
. Add c to j’s preference list
end for
X ← X ∪ {P j }
end for
XT ← X
if argmaxc∈C {Score of c based on XS ∪ XT } = {p} then
return true
. p wins
else
return false
end if
end procedure
Proof. Suppose for contradiction that there are c ∈ C \ GW last |GW | places, it follows that
and g ∈ GW , s.t. S n (c) > S n (g). Then at stage n + 1, c would
s
|GX
n
W |−1
X
have been ranked after g. Let s ≥ 0 s.t. g ∈ GW
. Then
1 X
s+1
S 0 (g) +
wj
i)
q(W) =
(
c ∈ GW ⇒ c ∈ GW , a contradiction.
|GW | g∈G
j=1
i=0
W
(3.2)
1 X 0
L 3.4. Given W, |W| = n, let GW be as before. Denote
≤
S n (g) =: q0 (XT )
|G
|
W
by q(W) the average score of candidates in GW after n
g∈GW
P
stages: q(W) = |G1W | g∈GW S n (g). Then:
Combining together (3.1) and (3.2) we get that S n0 (p) ≤
1. If S n (p) ≤ q(W) then there is no manipulation that q0 (XT ). There is at least one g ∈ GW such that S n0 (g) ≥ q0 (XT )
makes p win the election, and the algorithm will return (since q0 (XT ) is the average of the scores), hence S n0 (p) ≤
S n0 (g), and so p will not win when XT is applied.
false.
Also note that Algorithm 2 returns true only if it constructs
a (valid) ballot that makes p win, and so for the case
2. If S n (p) > maxg∈GW {S n (g)}, then there is a manipulaS
(p)
≤
q(W) the algorithm will return false.
n
tion that makes p win, and the algorithm will find it.
We now prove part 2 of the lemma. If S n (p) >
maxg∈GW {S n (g)}, then by Lemma 3.3 for all c ∈ C \ {p},
Proof. We first prove part 1. Denote W = {w1 , . . . , wn }. We S (p) > S (c), and so the algorithm will find the manipun
n
have the set GW , and we suppose that S n (p) ≤ q(W). Let lation.
us consider any ballot XT of votes in T , and let S n0 (c) be
the scores of the candidates c ∈ C implied by this ballot L 3.5. Let G , q(W) be as before. Then for w ≥ 1,
W
(including also all the votes in S ). As in Algorithm 2, p q(W + {w}) − q(W) ≤ w m−2 .
2
was placed at the top of the preference of each voter in T ; it
follows that
s
Proof. First, GW ⊆ GW+{w} , because for all s ≥ 0, GW
⊆
s
G
.
Now,
for
all
g
∈
G
\
G
,
g
was
not
ranked
in
W+{w}
W
n
W+{w}
X
the first n + 1 stages after any candidate in GW , and so for all
(3.1)
S n (p) = S 0 (p) +
w j (m − 1) ≥ S n0 (p)
g0 ∈ GW , S n (g) ≤ S n (g0 ), and hence
j=1
On the other hand, since by Lemma 3.2, in Algorithm 2 the
candidates of GW were ranked by all the voters in T at the
280
1
X
|GW+{w} | g∈G
W+{w}
S n (g) ≤
1 X
S n (g0 ) = q(W)
|GW | g0 ∈G
W
Algorithm 2 Decides CCWM in Scoring rules
1: procedure S--G(C, p, S 0 (C), W) . S 0 (C) is the list of scores of candidates distributed by voters in S ,
W is the list of weights for voters in T , |W| = |T | = n
2:
for j = 1, . . . , n do
. Go over voters in T
3:
S j (p) = S j−1 (p) + w j α1
. Put p at the first place of the j-th preference list
4:
Let t1 , t2 , . . . , tm−1 s.t. ∀l, S j−1 (ctl−1 ) ≤ S j−1 (ctl )
5:
j votes p ct1 . . . ctm−1
6:
for l = 1, . . . , m − 1 do
. Update the scores
7:
S j (ctl ) = S j−1 (ctl ) + w j αl+1
8:
end for
9:
end for
10:
if argmaxc∈C {S n (c)} = {p} then
. p wins
11:
return true
12:
else
13:
return false
14:
end if
15: end procedure
Case 1: j > 1. In this case g was ranked before g0 at
stage j − 1. So we have:
Now we can proceed:
q(W + {w}) =
=
1
X
|GW+{w} | g∈G
1
S n+1 (g)
W+{w}
X
|GW+{w} | g∈G
S n (g) +
W+{w}
w
|GW+{w}
X|−1
|GW+{w} |
i=0
i
(3.3)
S j−1 (g) ≥ S j−1 (g0 )
(3.4)
S j−2 (g) ≤ S j−2 (g0 )
Denote αd (h) := m − (place of h ∈ C at the preference
list of voter d). Further, denote by wd the weight of voter
d (so at stage d, h gets wd αd (h) points). g was ranked bem−2
fore g0 at stage j − 1, and hence α j−1 (g) > α j−1 (g0 ). De= q(W) + w
note l = α j−1 (g) − α j−1 (g0 ), and w := w j−1 . Let g0 =
2
g0 , g1 , . . . , gl = g be the candidates that got at stage j − 1 the
And so, q(W + {w}) − q(W) ≤ w m−2
points wα j−1 (g0 ), w(α j−1 (g0 ) + 1), . . . , w(α j−1 (g0 ) + l), respec2 .
tively. Our purpose is to show that {S j−1 (g0 ), . . . , S j−1 (gl )}
We will prove in Lemmas 3.6 – 3.9 that for any weights is w-dense, and therefore w -dense. By definition of the
max
list W, |W| = n: maxg∈GW {S n (g)} − q(W) ≤ max(W) m−2
2 . First algorithm,
we need to show that the scores of candidates in GW are not
scattered too much. We will need the following definition:
(3.5)
S j−2 (g0 ) ≥ S j−2 (g1 ) ≥ . . . ≥ S j−2 (gl )
m−2
≤ q(W) +
w X
i
m − 1 i=0
D 3.2. For an integer w ≥ 0, a finite non-empty Denote ut = S j−2 (gt ) + wα j−1 (g0 ) for 0 ≤ t ≤ l. Then
set of integers A is called w-dense if when we sort the set
in nonincreasing order b1 ≥ b2 ≥ . . . ≥ bk (such that (3.6)
For all 0 ≤ t ≤ l, S j−1 (gt ) = ut + wt
{b1 , . . . , bk } = A), it holds that for all 1 ≤ j ≤ k − 1,
So we need to show that {ut + wt | 0 ≤ t ≤ l} is w-dense. It is
b j+1 ≥ b j − w.
enough to show that:
L 3.6. Let W be a list of weights, |W| = n. Let GW =
(a) For all 0 ≤ t ≤ l, if ut + wt < u0 , then there exists
s
s
s−1
∪0≤sGW
, as before. Then for all s ≥ 1 and g ∈ GW
\ GW
t < t0 ≤ l s.t. ut + wt < ut0 + wt0 ≤ ut + w(t + 1), and
s−1
0
there exist g ∈ GW , X ⊆ C \ {p} (maybe X = φ) and j,
0 ≤ j ≤ n, s.t. {S j (g), S j (g0 )} ∪ S j (X) is wmax -dense, where (b) For all 0 ≤ t ≤ l, if u + wt > u , then there exists
t
0
wmax = max(W).
0 ≤ t0 < t s.t. u + w(t − 1) ≤ u 0 + wt0 < u + wt.
t
s
s−1
GW
\GW
.
t
Proof. Let s ≥ 1 and g ∈
By definition there exist Proof of (a): From (3.5) we get
s−1
g0 ∈ GW
and 1 ≤ j ≤ n + 1 minimal s.t. g was ranked after
g0 at stage j. We distinguish between two cases:
(3.7)
u0 ≥ . . . ≥ ul
281
t
Also from (3.3) and (3.6) we have u0 ≤ ul + wl. Let
0 ≤ t ≤ l − 1 s.t. ut + wt < u0 . Let us consider the sequence
ut +wt, ut+1 +w(t+1), . . . , ul +wl. Since ut +wt < u0 ≤ ul +wl,
it follows that there is a minimal index t0 , t < t0 ≤ l
s.t. ut + wt < ut0 + wt0 . Then ut0 −1 + w(t0 − 1) ≤ ut + wt,
and thus
Denote Z1 := {g0 , g1 } ∪ X10 . Similarly, if g1 < G0W , then there
s−2
exist g2 ∈ GW
and X20 s.t. {S n (g1 ), S n (g2 )} ∪ S n (X20 ) is wmax dense. Denote Z2 := {g1 , g2 } ∪ X20 , etc. Thus, we can build a
sequence of sets Z1 , . . . , Z s+1 , s.t. for all 1 ≤ t ≤ s + 1, S n (Zt )
is wmax -dense, g = g0 ∈ Z1 and for each 1 ≤ t ≤ s there exists
s−t
gt ∈ G W
s.t. gt ∈ Zt ∩ Zt+1 , and in particular, g s ∈ G0W .
It is easy to see that for two w-dense sets A, A0 , if
0
0
(3.8)
ut −1 + wt ≤ ut + w(t + 1)
A∩A0 , φ then A∪A0 is also w-dense, and hence we get Zg :=
S s+1
0
t=1 Zt is wmax -dense. Note that S 0 (G W ) is wmax -dense, and
From (3.7) ut0 ≤ ut0 −1 , and then
hence there exists Ẑ, G0W ⊆ Ẑ ⊆ C \ {p} s.t. S n (Ẑ) is wmax S
0
0
dense. From this we conclude that {S n (g) | g ∈ Ẑ ∪ g∈GW Zg }
(3.9)
ut0 + wt ≤ ut0 −1 + wt
S
is wmax -dense. By Lemma 3.3, for all h ∈ Ẑ ∪ g∈GW Zg , if
Combining (3.8) and (3.9) together, we get ut0 + wt0 ≤ h < GW , then S n (h) ≤ ming∈GW {S n (g)}, and hence S n (GW ) is
ut + w(t + 1). This concludes the proof of (a). The proof a also wmax -dense.
of (b) is similar.
L 3.9. Let W be a list of weights, |W| = n, wmax =
Case 2: j = 1. In this case s ≥ 2, because otherwise,
max(W). Let GW be as before, and denote q(W) =
if s = 1, then g0 ∈ G0W ; therefore S 0 (g) ≥ S 0 (g0 ) =
1 P
g∈GW S n (g), as before. Then maxg∈GW {S n (g)} − q(W) ≤
s−2
0
0
|G
W|
maxh∈C\{p} {S 0 (h)} ⇒ g ∈ GW , a contradiction. g < GW ,
m−2
s−1
because otherwise, by definition g ∈ GW
. Therefore there wmax 2 .
s−2
00
0
exists g ∈ GW s.t. g was ranked after g00 at some stage Proof. Sort the members of GW by their scores after the
j0 , i.e., S j0 −1 (g0 ) ≥ S j0 −1 (g00 ). g has never been ranked n-th stage, i.e., GW = {g1 , . . . , g|GW | } s.t. for all 1 ≤ t ≤
s−1
after g00 (because otherwise g ∈ GW
), and it follows that |GW | − 1, S n (gt ) ≥ S n (gt+1 ). Denote for 1 ≤ t ≤ |GW |,
00
S j0 −1 (g) ≤ S j0 −1 (g ), and we have S j0 −1 (g) ≤ S j0 −1 (g0 ). ut = S n (g1 ) − wmax (t − 1), and let U = {u1 , . . . , u|GW | }. |U| =
Let j0 be minimal s.t. S j0 (g) ≤ S j0 (g0 ). As at stage 1 g |GW |, max U = S n (g1 ) = maxg∈GW {S n (g)}. By Lemma 3.8,
was ranked after g0 , it holds that S 0 (g) ≥ S 0 (g0 ). If it is easy to see that for all 1 ≤ t ≤ |GW |, S n (gt ) ≥ ut .
P W|
j0 = 0 then S 0 (g) = S 0 (g0 ), and hence {S 0 (g), S 0 (g0 )} is Consequently, q(W) ≥ |G1 | |G
t=1 ut , hence maxg∈GW {S n (g)} −
W
0-dense, and therefore wmax -dense. Otherwise it holds that q(W) = u − q(W) ≤ u − 1 P|GW | u = w |GW |−1 ≤
1
1
max 2
t=1 t
|GW |
S j0 −1 (g) > S j0 −1 (g0 ), and as in Case 1, we can prove that
m−2
.
w
max 2
{S j0 (g), S j0 (g0 )} ∪ S j0 (X) is wmax -dense for some X ⊆ C \ {p}.
Now we are ready to prove Theorem 3.1.
Proof. Regarding part 1, Algorithm 2 returns true only if it
L 3.7. Let W be a list of weights, |W| = n, wmax =
constructs a (valid) ballot that makes p win, and thus if there
max(W). Let H ⊆ C \ {p} s.t. S j (H) is wmax -dense for some
is no ballot making p win, Algorithm 2 will return false.
0
0
0
0 ≤ j ≤ n. Then there exists H , H ⊆ H ⊆ C \ {p} s.t. S n (H )
We now prove part 2 of the theorem. Suppose that there
is wmax -dense.
exists a ballot making p win for weights list W, |W| = n.
Pk
0
0
0
0
Proof. We have H ⊆ C \ {p} and 0 ≤ j ≤ n, s.t. S j (H) Let W := W + {w1 , . . . , wk } for k ≥ 1, i=1 wi ≥ max(W).
is wmax -dense. Denote H j := H. Define inductively for By Lemma 3.4, S n (p) > q(W). From Lemma 3.5 we get by
t = j, j + 1, . . . , n − 1: Ht+1 = {g ∈ C \ {p} | minh∈Ht {S t (h)} ≤ induction that
k
X
S t (g) ≤ maxh∈Ht {S t (h)}}. Of course, for all t, Ht ⊆ Ht+1 .
m−2
q(W 0 ) ≤ q(W) +
w0i ·
It is easy to see that if for some j ≤ t ≤ n − 1, S t (Ht ) is (3.10)
2
i=1
wmax -dense, then S t+1 (Ht+1 ) is also wmax -dense. So we get by
induction that S n (Hn ) is wmax -dense, and H ⊆ Hn ⊆ C \ {p}. By Lemma 3.9 and (3.10) we get:
m−2
max {S n+k (g)} ≤ q(W 0 ) + max(W 0 ) ·
g∈GW 0
2
L 3.8. Let W be a list of weights, |W| = n, wmax =
k
X
m−2
max(W). Let GW be as before. Then the set S n (GW ) is wmax ≤ q(W 0 ) +
w0i ·
dense.
2
i=1
s
s−1
Proof. Let g = g0 ∈ GW . If g < G0W , then g ∈ GW
\ GW
s−1
for some s ≥ 1. By Lemma 3.6 there exist g1 ∈ GW and
X1 ⊆ C \ {p} s.t. {S j (g0 ), S j (g1 )} ∪ S j (X1 ) is wmax -dense for
some 0 ≤ j ≤ n. By Lemma 3.7 there exists X10 , X1 ⊆
X10 ⊆ C \ {p}, s.t. {S n (g0 ), S n (g1 )} ∪ S n (X10 ) is wmax -dense.
282
≤ q(W) +
k
X
w0i · (m − 2)
i=1
< S n (p) +
k
X
i=1
w0i · (m − 1) = S n+k (p)
and hence, by Lemma 3.4 the algorithm will find a ballot Proof. Let 0 ≤ j ≤ n − 2. Let g , p be any candidate.
making p win for set T 0 with weights W 0 , and will return By definition S j (g) ≤ f ( j). We would like to show that
true. This completes the proof of Theorem 3.1.
S j+2 (g) ≤ f ( j) + max{w j+1 , w j+2 }.
If S j+1 (g) ≤ f ( j), then S j+2 (g) ≤ S j+1 (g)+w j+2 ≤ f ( j)+
For an example where there is a manipulation for max{w j+1 , w j+2 }, and we are done. So let us assume now that
weights list W, but the algorithm will find a manipulation S j+1 (g) > f ( j). Define a directed graph G = (V, E), where
only for weights list W + {w0 }, see the full version of the V = {g} ∪ {x ∈ C \ {p} | x was ranked after g at stage j + 1},
paper [23].
and (x, y) ∈ E iff y ∈ MIN j (x). There is at least one outgoing
edge from g in E, since otherwise there was g0 ∈ MIN j (g)
3.2 Maximin In this subsection, we show that Algo- that voter j+1 put before g, and then S j+1 (g) = S j (g) ≤ f ( j),
rithm 1 also does well with respect to the Maximin rule.
a contradiction. In addition, for all x ∈ V \{g}, there is at least
one outgoing edge from x in E, because otherwise there was
L 3.10. Maximin is monotone in weights.
x0 ∈ MIN j (x) that was ranked before g at stage j + 1, and
then Algorithm 1 would have ranked x before g (after x0 )
The remaining monotonicity Lemmas are deferred to the since then S j+1 (x) = S j (x) ≤ f ( j) < S j+1 (g), which is again
full version of the paper [23].
a contradiction.
For x ∈ V, denote by V(x) all the vertices y in V s.t. there
T 3.2. In the Maximin rule, let C be the set of candi- exists a directed path from x to y. Denote by G(x) the subdates with p ∈ C the preferred candidate, and S the set of graph of G induced by V(x). It is easy to see that G(g)
voters who already cast their votes. Let W be the weights list contains at least one circle. Let U be one such circle. Let
for the set T . Then:
g0 ∈ U be the vertex that was picked first among the vertices
of U at stage j + 1. Let g00 be the vertex before g0 in the
1. If there is no ballot making p win the election, then
circle: (g00 , g0 ) ∈ U. Since g00 was ranked after g0 at stage
Algorithm 1 will return false.
j + 1, it follows that S j+1 (g00 ) = S j (g00 ) ≤ f ( j).
Suppose by way of contradiction that S j+2 (g) > f ( j) +
2. If there is a ballot making p win the election, then for
∗
max{w
0
0
j+1 , w j+2 }. g was ranked by j + 2 at place t . Then
the same instance with weights list W s.t. W ⊇ W + W
00
∗
< t , since otherwise
(i.e., W 0 contains two copies of W), Algorithm 1 will g was ranked by j + 2 at place
∗
when
we
had
reached
the
place
t
,
we
would pick g00 (with
return true.
00
score S j+2 (g ) ≤ f ( j) + w j+2 < S j+2 (g)) instead of g—a
contradiction.
Let us introduce some more notation. For candidates
Denote by X1 all the vertices in V(g) that have an
g, g0 ∈ C and 0 ≤ j ≤ n we denote by N j (g, g0 ) the total
outgoing
edge to g00 in G(g). For all x ∈ X1 , g00 ∈ MIN j (x),
weight of the voters after j stages (including the voters in S )
00
that prefer g over g0 . So S j (g) = ming0 ∈C\{g} N j (g, g0 ). We i.e., S j (x) = N j (x, g ). All x ∈ X1 were ranked by j + 2
before g, since otherwise, if there was x ∈ X1 , s.t. until
also denote for g ∈ C, 0 ≤ j ≤ n:
the place t∗ it still was not added to the preference list,
then when evaluating its score on place t∗ , we would get:
MIN j (g) = {h ∈ C \ {g} | N j (g, h) = S j (g)}.
S j+2 (x) ≤ N j+2 (x, g00 ) = N j+1 (x, g00 ) ≤ N j (x, g00 ) + w j+1 =
Fixing the set C, p ∈ C, and an order on the weights list S j (x) + w j+1 < S j+2 (g), and so we would put x instead of g.
W, we denote by f ( j) the maximal score of p’s opponents Denote by X2 all the vertices in V(g) that have an outgoing
edge to some vertex x ∈ X1 . In the same manner we can
distributed by Algorithm 1 after j stages:
show that all the vertices in X2 were ranked at stage j + 2
f ( j) = max S j (g).
before g. We continue this way backwards on the path in
g∈C\{p}
G(g) from g00 to g, and we get that one vertex before g on
In Algorithm 1, p is always placed at the top of each that path, say g0 , was ranked by j + 2 before g. Thus,
preference, and so with each voter its score grows by the
weight of this voter. In our next lemma we will put forward
an upper bound on the growth rate of the scores of p’s
opponents.
S j+2 (g) ≤ N j+2 (g, g0 ) = N j+1 (g, g0 ) ≤ N j (g, g0 ) + w j+1
= S j (g) + w j+1 ≤ f ( j) + max{w j+1 , w j+2 }
< S j+2 (g),
L 3.11. Consider Algorithm 1 applied to the Maximin a contradiction.
rule. Denote by w j the weight of the j-th voter processed
We are now ready to prove Theorem 3.2.
by the algorithm. Then for all 0 ≤ j ≤ n − 2, f ( j + 2) ≤
f ( j) + max{w j+1 , w j+2 }.
Proof. We prove part 1. Algorithm 1 returns true only if it
283
constructs a (valid) ballot that makes p win, and thus if there in X that put g at the top of their preferences). We also use
P
is no ballot making p win, Algorithm 1 will return false.
NX (g, g0 ) = v∈U wv , where U is the set of all the voters in
We now prove part 2. Suppose that there exists a ballot X that prefer g to g0 , and wv is the weight of voter v. Finally,
ZT making p win for weights list W = {w1 , . . . , wn }. Let for g, g0 ∈ C we denote g g0 if a tie between g and g0 is
S 0j (g) be the scores implied by ZT . Then:
broken in favor of g.
n
X
f (0) < S n0 (p) ≤ S 0 (p) +
(3.11)
R 3.2. In Algorithm 3 we do not rely on the assumption that for all g , p, g p.
wi
i=1
Let W = W + W + X, where X is some list of weights
(possibly empty). We need to show that S |W 0 | (p) >
f (|W 0 |). In Algorithm 1, after sorting the weights of
W 0 , the equal weights of two copies of W will be adjacent, i.e., the order of weights in W 0 will be of the
form: x1 , . . . , xq1 , w1 , w1 , xq1 +1 , . . . , xq2 , w2 , w2 , . . . , wn , wn ,
xqn +1 , . . . , x|X| . By Lemma 3.11, one can prove by induction
that:
0
(3.12)
f (|W 0 |) ≤ f (0) +
|X|
X
xi +
i=1
n
X
T 3.3. In the Plurality with runoff rule, let C be the
set of candidates with p ∈ C the preferred candidate, S the
set of voters who already cast their votes. Let W be the
weights list for the set T , and let u ≥ 0 be the error window.
Then:
wi
i=1
And so by (3.11) and (3.12) we have:
S |W 0 | (p) = S 0 (p) +
|X|
X
xi + 2
n
X
i=1
> f (0) +
|X|
X
i=1
xi +
In the next theorem we prove the correctness of Algorithm 3, and analyze its time complexity. We will see that for
getting an exact answer (u = 0), we will need running time
which is polynomial in max(W) and the rest of the input.
As the weights in W are specified in binary representation,
this requires exponential time. However when the size of
the error window increases, the complexity decreases, so for
max(W)
) the complexity of the algorithm is polynou = Ω( log(max(W))
mial in its input.
1. If there is no ballot making p win the election, then
Algorithm 3 will return false.
wi
i=1
n
X
2. If there is a ballot making p win the election, then for
the same problem with voter set T 0 = T +{vn+1 , . . . , vn+l }
with weights list W 0 = W + {wn+1 , . . . , wn+l }, where
P
l ≥ 0, lj=1 wn+ j ≥ u, Algorithm 3 will return true.
wi
i=1
≥ f (|W 0 |)
3. On input C, p, XS , WS , W, u, where |C| = m, |S | =
N, |W| = n, u is an integer, s.t. 0 ≤ u ≤ max(W),
the running time of Algorithm 3 is polynomial in
m, N, log(max(WS )), n and max(W)
u+1 .
3.3 Plurality with Runoff In this subsection we present
a heuristic algorithm for the CCWM problem in Plurality
with runoff. The algorithm receives as a parameter a size of
window 0 ≤ u ≤ max(W) where it can give a wrong answer.
The proof of the theorem is given in the full version of
Its running time depends on the size of its input and on u (see the paper [23].
below). We begin by noting:
L 3.12. Plurality with runoff is monotone in weights.
We will now give an informal description of the algorithm. We go over all the candidates other than p. To each
candidate g we try to assign the voters with minimal total
weight, such that if these voters place g first, g continues
to the second round; the rest of the voters rank p first. If
we succeeded in this way to make g and p survive the first
round, and in the second round p beats g, then we found a
valid ballot for making p win the election. If no candidate g
was found in this way, then we report that there is no ballot.
A formal description of this algorithm, Algorithm 3, is
given at the end of this paper. The following additional
notations are required. Denote by βX (g) the plurality score
of g from voter set X (i.e., the sum of weights of the voters
4 Discussion
We would first like to discuss the application of our results to
unweighted coalitional manipulation (the CCUM problem).
It is known that this problem is tractable when the number
of candidates is constant [7]. However, to the best of our
knowledge there are no results regarding the complexity
of the problem when the the number of candidates is not
constant. We conjecture that CCUM in Borda and Maximin
is NP-complete.
In the context of unweighted manipulation, one can
consider the following optimization problem (call it CCUO,
where “O” stands for Optimization): given the votes of the
truthful voters, find the minimum number of manipulators
needed in order to make p win. Then, our theorems almost
directly imply the following corollary:
284
C 4.1.
1. Algorithm 2 approximates CCUO in Borda up to an
additive factor of 1.
2. Algorithm 1 is a 2-approximation algorithm for CCUO
in Maximin.
On the other hand, we have the following results:
C 4.2. Algorithm 3 efficiently solves the CCUM
problem in Plurality with runoff.
T 4.1. Algorithm 2 efficiently solves the CCUM
problem in Veto.
Corollary 4.2 is a special case of Theorem 3.3, where
the error window is u = 0, the number of additional voters is
l = 0, and all the weights equal 1. The proof of Theorem 4.1
is given in the full version of the paper [23]. We deduce
that CCUM, and thus CCUO, in the Plurality with runoff and
Veto rules are in P.
We now turn to a brief and informal discussion regarding the implications of our results with respect to solving
the weighted coalitional manipulation problem, CCWM, in
practice. Our theorems imply that our algorithms err on
only very specific configurations of the voters’ weights. Intuitively, this means that if one looks at some (reasonable)
distribution over the instances of the CCUM problem (such
that weights are randomly selected), the probability of hitting
the window of error is extremely small.
Procaccia and Rosenschein [19] show that Algorithm 2
has a small chance of mistake with respect to a junta distribution—which is arguably especially hard—over the instances
of CCWM in scoring rules. This result uses a very loose
analysis regarding the algorithm’s window of error. Our result regarding Borda is far stronger, since the window of error is much more accurately characterized. However, since
the result in Procaccia and Rosenschein deals with scoring
rules in general, neither result subsumes the other.
References
[1] J. Bartholdi and J. Orlin. Single transferable vote resists
strategic voting. Social Choice and Welfare, 8:341–354,
1991.
[2] J. Bartholdi, C. A. Tovey, and M. A. Trick. The computational
difficulty of manipulating an election. Social Choice and
Welfare, 6:227–241, 1989.
[3] J. Bartholdi, C. A. Tovey, and M. A. Trick. Voting schemes
for which it can be difficult to tell who won the election.
Social Choice and Welfare, 6:157–165, 1989.
[4] E. H. Clarke. Multipart pricing of public goods. Public
Choice, 11:17–33, 1971.
[5] V. Conitzer and T. Sandholm. Universal voting protocol
tweaks to make manipulation hard. In IJCAI, pages 781–788,
2003.
[6] V. Conitzer and T. Sandholm. Nonexistence of voting rules
that are usually hard to manipulate. In AAAI, pages 627–634,
2006.
[7] V. Conitzer, T. Sandholm, and J. Lang. When are elections
with few candidates hard to manipulate? Journal of the ACM,
54(3):1–33, 2007.
[8] E. Elkind and H. Lipmaa. Hybrid voting protocols and hardness of manipulation. In ISAAC, Lecture Notes in Computer
Science, pages 206–215. Springer-Verlag, 2005.
[9] E. Elkind and H. Lipmaa. Small coalitions cannot manipulate
voting. In FC, Lecture Notes in Computer Science. SpringerVerlag, 2005.
[10] E. Ephrati and J. S. Rosenschein. A heuristic technique for
multiagent planning. Annals of Mathematics and Artificial
Intelligence, 20:13–67, 1997.
[11] G. Erdelyi, L. A. Hemaspaandra, J. Rothe, and H. Spakowski.
On approximating optimal weighted lobbying, and frequency
of correctness versus average-case polynomial time. Technical report, arXiv:cs/0703097v1, 2007.
[12] S. Ghosh, M. Mundhe, K. Hernandez, and S. Sen. Voting for
movies: the anatomy of a recommender system. In AGENTS,
pages 434–435, 1999.
[13] A. Gibbard. Manipulation of voting schemes. Econometrica,
41:587–602, 1973.
[14] T. Groves. Incentives in teams. Econometrica, 41:617–631,
1973.
[15] T. Haynes, S. Sen, N. Arora, and R. Nadella. An automated
meeting scheduling system that utilizes user preferences. In
AGENTS, pages 308–315, 1997.
[16] E. Hemaspaandra, L. A. Hemaspaandra, and J. Rothe. Anyone but him: The complexity of precluding an alternative. Artificial Intelligence, 171(5–6):255–285, 2007.
[17] H. Moulin. On strategy-proofness and single peakedness.
Public Choice, 35:437–455, 1980.
[18] A. D. Procaccia and J. S. Rosenschein. Average-case
tractability of manipulation in voting via the fraction of manipulators. In AAMAS, pages 718–720, 2007.
[19] A. D. Procaccia and J. S. Rosenschein. Junta distributions
and the average-case complexity of manipulating elections.
Journal of Artificial Intelligence Research, 28:157–181, 2007.
[20] A. D. Procaccia, J. S. Rosenschein, and A. Zohar. Multiwinner elections: Complexity of manipulation, control and
winner-determination. In IJCAI, pages 1476–1481, 2007.
[21] M. Satterthwaite. Strategy-proofness and Arrow’s conditions: Existence and correspondence theorems for voting procedures and social welfare functions. Journal of Economic
Theory, 10:187–217, 1975.
[22] W. Vickrey. Counter speculation, auctions, and competitive
sealed tenders. Journal of Finance, 16(1):8–37, 1961.
[23] M. Zuckerman, A. D. Procaccia, and J. S. Rosenschein. Algorithms for the coalitional manipulation problem. Technical
report 2007-116, Leibniz Center for Research in Computer
Science, The Hebrew University of Jerusalem, 2007.
285
Algorithm 3 Decides CCWM in Plurality with runoff with desired accuracy
1: procedure P--(C, p, XS , WS , W, u) . XS is the set of preferences of voters in S , WS are the weights
of voters in S , W = {w1 , . . . , wn } are the weights of voters in T , u is the size of error window
2:
for g in C \ {p} do
. Go over candidates in C \ {p}
3:
if there exists g0 ∈ argmaxg0 ∈C\{p} βS (g0 ), g0 , g s.t. g0 g then
4:
λg ← maxg0 ∈C\{p} βS (g0 ) − βS (g) + 1
5:
else
6:
λg ← maxg0 ∈C\{p} βS (g0 ) − βS (g)
7:
end if
P
8:
if λg > ni=1 wi then
. If we cannot make g pass to the next round
9:
continue
. Go to the next candidate in the main loop
10:
end if
11:
x ← ---(W, λg , u)
P
P
12:
. x ∈ {0, 1}n minimizes { nj=1 w j x j | nj=1 w j x j ≥ λg , ∀ j, x j ∈ {0, 1}}
13:
All the voters j s.t. x j = 1 vote g . . .
. Order of candidates except g is arbitrary
14:
All the voters j s.t. x j = 0 vote p . . .
15:
if ∃g0 ∈ C \ {p, g} s.t. βS (g0 ) > βS (p) + βT (p)
16:
or βS (g0 ) = βS (p) + βT (p) and g0 p then
17:
continue
. p does not pass to next round
18:
end if
19:
if NS ∪T (p, g) > NS ∪T (g, p) or NS ∪T (p, g) = NS ∪T (g, p) and p g then
20:
return true
. p beats g in the second round
21:
else
22:
continue
23:
end if
24:
end for
25:
return false
. No appropriate g was found
26: end procedure
27:
28:
29:
30:
31:
32:
33:
34:
procedure ---(W, λg , u)
. W = {w1 , . . . , wn } are the weights of voters in T , λg is the
minimum total sum of desired weights, u is the size of error window
Check that 0 ≤ u ≤ max(W)
u
+1
k ← 2n
P w P
P
Solve by dynamic prog.: max{ nj=1 kj x j | nj=1 w j x j ≤ nj=1 w j − λg , ∀ j, x j ∈ {0, 1}}
Let x ∈ {0, 1}n be the vector that maximizes the above sum
return ~1 − x
. ~1 is the vector of n 1-s
end procedure
286