Algorithms and Computational Complexity

Abstract

In this chapter, we discuss computational problems related to ABC rules and algorithms that solve these problems. We start by discussing the computational complexity of ABC rules. As many ABC rules are computationally difficult, a thorough algorithmic analysis is paramount to a practical application of these rules.

In this chapter, we discuss computational problems related to ABC rules and algorithms that solve these problems. We start by discussing the computational complexity of ABC rules. As many ABC rules are computationally difficult, a thorough algorithmic analysis is paramount to a practical application of these rules. We consider algorithmic techniques such as integer linear programming, fixed-parameter algorithms, approximation algorithms, and algorithms for structured domains. Moreover, we discuss computational questions related to proportionality and to strategic voting.

5.1 Computational Complexity

How computationally expensive is it to find a winning committee according to a given ABC rule? Clearly, this question is of major importance for the practical use of an ABC rule. Here, we distinguish only two types of complexity: ABC rules that are computationally easy, i.e., computable in polynomial time, and ABC rules that are computationally expensive, i.e., those that are ${{\textrm{NP}}}$-hard. Note that this is only a coarse dichotomy; we discuss its implications further below.

Let us first consider the class of Thiele methods. Out of the three most prominent Thiele methods, two are ${{\textrm{NP}}}$-hard (CC and PAV) and one is computable in polynomial time (AV). A polynomial-time algorithm for AV is straightforward: for each alternative c we compute its approval score ${{\textrm{score}_{{{\textrm{AV}}}}}}(A, c) = |\{i\in N: c\in A(i)\}|$ and select the k alternatives with the largest scores. To be able to claim ${{\textrm{NP}}}$-hardness of an ABC rule $\mathcal {R}$, we have to fix a decision problem; we choose the following for rules based on scores: given an approval profile, is there a committee with $\mathcal {R}$-score at least s? The ${{\textrm{NP}}}$-hardness of CC has been shown by Procaccia et al. [55]; the ${{\textrm{NP}}}$-hardness of PAV by Skowron et al. [59] and Aziz et al. [1] (for different decision problems). A more general result shows that a large class of Thiele methods is ${{\textrm{NP}}}$-hard:

Theorem 5.1

([59, Theorem 5]) Let $w:\mathbb N\rightarrow \mathbb R$ be a non-decreasing function for which $w(i)-w(i-1)> w(i+1)-w(i)$ for some $i\in \mathbb N$. Given an approval profile profile A, a committee size k, and a bound s, it is ${{\textrm{NP}}}$-hard to decide whether there exists a committee of size k with a w-score of at least s, i.e., ${{\textrm{score}_{w}}}(A, W) \ge s$.

Note that this theorem does not apply to AV, which is indeed polynomial-time computable. Interestingly, a similar result also holds for 2D-Euclidean preferences. We say that an approval profile is 2D-Euclidean if the voters and the candidates can be represented in the two-dimensional Euclidean space so that for each voter i the following holds: if i approves a candidate c, then she also approves all candidates that are closer to i than c. The following theorem applies, e.g., to PAV and CC.

Theorem 5.2

(Godziszewski et al. [36]) Let $w:\mathbb N\rightarrow \mathbb R$ be a non-linear and concave function. Given a 2D-Euclidean approval profile profile A, a committee size k, and a bound s, it is ${{\textrm{NP}}}$-hard to decide if there is a k-size committee with a w-score of at least s.

Winning committees of sequential and reverse sequential Thiele methods can be computed in polynomial time; this follows immediately from their definitions. The same holds for Greedy Monroe, seq-Phragmén, the Method of Equal Shares, and SAV. In contrast, appropriate decision problems for Monroe’s rule [55], lexical-Phragmén [15], and MAV [40] are ${{\textrm{NP}}}$-complete. The ${{\textrm{NP}}}$-hardness for MAV also holds for 2D-Euclidean preferences [36]. These complexity results are summarised in Table 3.1.

To conclude, the complexity classification discussed here should not be misunderstood in implying that ${{\textrm{NP}}}$-hard ABC rules are impractical and should be avoided. There is a wide range of algorithmic techniques available to solve ${{\textrm{NP}}}$-hard problems, and many disciplines in computer science encounter (and routinely solve) computationally hard problems. Instead the message here is the following: When using a polynomial-time computable rule, even very large instances can be expected to be solved quickly. For ${{\textrm{NP}}}$-hard rules, a more thorough analysis is necessary to determine how large instances can be solved (cf. Sect. 5.2).

5.2 How to Compute Winning Committees?

The arguably most central algorithmic question is: how to compute winning committees for an ABC voting rule? Clearly, the answer significantly differs from rule to rule. Rules that can be computed in polynomial time generally do not require sophisticated algorithms. In particular, algorithms for AV, SAV, as well as for sequential and reverse sequential Thiele methods follow immediately from their corresponding definitions. Algorithms for Phragmén’s sequential rule and the Method of Equal Shares are slightly more involved but also do not require more than a careful adaption of the corresponding mathematical definitions. (Note that for seq-Phragmén it is more convenient to implement its discrete formulation.) For rules that are ${{\textrm{NP}}}$-hard to compute, we discuss four algorithmic methods in the following: integer linear programs, fixed-parameter algorithms, approximation algorithms, and algorithms for structured domains.

5.2.1 Integer Linear Programs (ILPs)

The most common approach to compute ${{\textrm{NP}}}$-hard ABC rules is to employ integer linear program (ILP) solvers, such as Gurobi or CPLEX. These are fast, general purpose solvers used for hard optimisation problems. To use such a solver, one has to encode an ABC rule as a integer linear program, i.e., a system of linear inequalities constraining a linear expression that is maximised or minimised. We will see two examples of ILPs in the following. Several ILPs (including these two) are available in the abcvoting Python library [38].

The ILP displayed in Fig. 5.1 shows how PAV can be expressed in such a form. This particular ILP formulation for PAV is taken from Peters and Lackner [51]. Two types of variables are used here: $x_{i,\ell }$ intuitively encodes that voter i approves at least $\ell$ candidates in the committee, and $y_c$ encodes that candidate c is contained in the winning committee. Given an election instance (A, k), this ILP maximises the PAV-score expressed in (5.1). Further it ensures that exactly k candidates are selected with Eq. (5.4) and that $x_{i,\ell }$ indeed encodes that voter i approves at least $\ell$ candidates in the committee with Eq. (5.5). Note that it can occur that $x_{i,\ell }=0$ and $x_{i,\ell +1}=1$, but this is never an optimal solution since $\frac{1}{\ell }> \frac{1}{\ell +1}$. It is easy to see that this ILP can be adapted for computing other Thiele methods by adjusting the optimisation goal in (5.1). Another ILP formulation is due to Skowron et al. [59]. This ILP is applicable to a larger class of multi-winner rules (OWA rules).

Fig. 5.1

An ILP for computing PAV

Fig. 5.2

An ILP for computing MAV

As a second example of an ILP encoding, we present one for MAV in Fig. 5.2. Here, $y_{c}$ encodes whether candidate c is contained in the winning committee, $d_{i,c}$ encodes whether voter i disagrees with the decision of whether c is in the committee or not, and D is the maximum Hamming distance between a voter and the chosen committee. Constraints (5.6) and (5.7) fix the value of $d_{i,c}$, i.e.,

$$\begin{aligned} d_{i,c}={\left\{ \begin{array}{ll}0 &{} \text {if }(c\in A(i)\text { and }y_c=1) \text { or } (c\notin A(i)\text { and }y_c=0),\\ 1 &{} \text {otherwise.}\end{array}\right. } \end{aligned}$$

Then, $\sum _{c\in C} d_{i,c}$ is the Hamming distance between the committee defined by $y_c$ and A(i). Due to Constraint (5.8), these sums are $\le D$ for all voters. Hence, by minimising D, we minimise the maximum distance.

Lastly, for Monroe’s rule, Pottho and Brams [54] discuss ILP formulations, and for lexical-Phragmén an ILP is due to Brill et al. [15].

5.2.2 Fixed-Parameter Algorithms

Fixed-parameter algorithms have received some attention for ABC rules. The main idea is to identify a parameter of the problem (ideally one that is small in practice) and search for algorithms that require only polynomial time when this parameter is constant. A fixed-parameter tractable (FPT) algorithm for a parameter p is one with a runtime of $O(f(p)\cdot \textrm{poly}(m,n))$, where f is an arbitrary, typically exponential function. Let us mention three natural parameters in the context of multi-winner elections: the number of candidates (m), the committee size k, and the number of voters n.

Let us first discuss the parameter m, i.e., the number of candidates. As there are ${m \atopwithdelims ()k}\le m^m$ committees, it is possible to consider each possible committee in an FPT algorithm. This bound gives trivial (and uninteresting) FPT results for most NP-hard rules. For example, for w-Thiele methods one can compute ${{\textrm{score}_{w}}}(A, W)$ for each committee W and pick those with maximum score. An interesting exception is Monroe, where it is not immediately obvious how to compute the Monroe score of a given committee in polynomial time. This is achievable via a reduction to the min-cost max-flow problem, described by Procaccia et al. [55].

For the parameter committee size k, most results are negative: First, Betzler et al. [9] show for Monroe and CC that it is $\mathrm {W[2]}$-hard to verify whether a committee exists with at least a certain Monroe-/CC-score. These hardness results continue to hold even if the number of unrepresented voters is used as an additional parameter [9]. Second, Misra et al. [48] show an analogous W[2]-hardness result for MAV. Third, Aziz et al. [1] show for all Thiele methods with $2w(1)>w(2)$ that testing whether a committee is winning is $\mathrm {coW[1]}$-hard.¹ All these results imply that one cannot hope for an FPT algorithm computing these ABC rules, i.e., it is unlikely that an algorithm exists with a runtime of, e.g., $O(2^k\cdot \textrm{poly}(m,n))$.

The parameter n, the number of voters, is a natural choice if multi-winner elections are conducted in small groups and leads to interesting algorithms. Betzler et al. [9] show that CC and Monroe can be solved in time $n^n\cdot \textrm{poly}(m,n)$. In a similar vein, Faliszewski et al. [32] show an FPT result with respect to n for a large class of multi-winner voting rules (including Thiele methods). Their algorithm is based on mixed integer linear programming and Lenstra’s result [41] that (mixed) integer linear programs can be solved in FPT time with the number of variables as parameter.² The results from Faliszewski et al. [32] have been substantially generalised by Bredereck et al. [13], including an FPT result for Thiele methods with weighted voters.

Moreover, Betzler et al. [9] provide a thorough and detailed parameterized complexity analysis for CC and Monroe for further parameters (e.g., the number of unrepresented voters) but find mostly hardness results. Yang and Wang [64] give an overview of further parameterized results; however, the concrete results announced in this short paper are not published yet.

To conclude, let us report on a positive result for MAV: MAV can be computed in time $O(d^{2d})$, where d is the optimal MAV-score, as shown by Misra et al. [48].³ This runtime is essentially optimal subject to a standard complexity theoretic assumption, as shown by Cygan et al. [22].

5.2.3 Approximation Algorithms

The most natural approximation algorithm for Thiele methods are their sequential variants, as described in Sect. 2.3. Sequential w-Thiele provides a very good approximation of w-Thiele [44, 59]; this follows directly from a more general approximation result for submodular set functions by Nemhauser et al. [49].

Theorem 5.3

(Lu and Boutilier [44] and Skowron et al. [59]) Sequential w-Thiele is a 0.63-approximation algorithm for w-Thiele. More specifically, Sequential w-Thiele achieves a w-score of at least $1- (1 - \nicefrac 1 k)^k \ge 1 - \nicefrac {1}{e}\ge 0.63$ times the optimal w-score.

Dudycz et al. [24] designed an algorithm that gives stronger approximation guarantees than $(1 - \nicefrac {1}{e})$ for w-Thiele methods for which the derivatives of the defining w-function decrease slower than a geometric sequence. The algorithm is based on pipage rounding of the fractional solution returned by a linear program. Barman et al. [4] provided a $\left( 1 - \frac{\ell ^\ell }{e^\ell \cdot \ell !}\right)$-approximation algorithm for the w-Thiele function with $w(x) = \min (x, \ell )$. Table 5.1 summaries the guarantees of the best approximation algorithms for most prominent Thiele methods. Notably, under standard assumptions, all these guarantees cannot be improved within the class of algorithms running in polynomial time.

Table 5.1 Guarantees of the approximation algorithms for the most prominent Thiele methods. The approximation ratios of the algorithms of Lu and Boutilier [44] and Dudycz et al. [24] are tight unless ${{\textrm{P}}}= {{\textrm{NP}}}$. They are also tight for the algorithms that run in $f(k) \cdot n^{o(k)}$ time assuming the Gap Exponential Time Hypothesis (Gap-ETH). The approximation ratio of the algorithm of Barman et al. [4] is tight assuming Unique Games Conjecture

One can also find approximation algorithms for the corresponding minimisation problem: for w-Thiele, instead of maximising the w-score, one can equivalently minimise the difference from the theoretical optimum of $n\cdot w(k)$, i.e., to minimise the w-loss defined as ${{\textrm{loss}_{w}}}(A, W)= n\cdot w(k) - {{\textrm{score}_{w}}}(A, W)$. The minimisation and the maximisation variants of the problem have the same optimal solutions, but they differ in terms of approximability. If the optimal committee W has a high score, i.e., if ${{\textrm{score}_{w}}}(A, W)$ is close to $n\cdot w(k)$, then an approximation algorithm for the minimisation variant would be superior. For instance, if for the optimal committee W we have ${{\textrm{score}_{w}}}(A, W) = 0.95 \cdot n\cdot w(k)$, then a 2-approximation algorithm for the minimisation variant of the problem is guaranteed to return a solution with the score at least as high as $0.9 \cdot n\cdot w(k)$. On the other hand, a $\nicefrac {1}{2}$-approximation algorithm for the maximisation variant may return a committee with score equal to $0.475 \cdot n\cdot w(k)$. Conversely, if the the optimal committee has a significantly lower score than $n\cdot w(k)$, then a good approximation algorithm for the maximisation variant of the problem will produce better committees.

Byrka et al. [17] present a 2.36-approximation algorithm for PAV according to this ${{\textrm{loss}_{w}}}$ measure. This algorithm is based on dependent rounding of a linear program solution. It is notable that this result does not hold for arbitrary weights; in particular, such an approximation algorithm does not exist for CC under the assumption that ${{\textrm{P}}}\ne {{\textrm{NP}}}$ [17]. While seq-PAV can be viewed as a voting rule in its own right, this is more debatable for such a rounding-based algorithm. In particular, it cannot be expected to satisfy nice axiomatic properties such as committee monotonicity, and thus constitutes first and foremost an approximation of PAV.

Skowron [57] describes two alternative algorithms that for certain Thiele methods (including PAV and CC) can provide arbitrarily good approximation guarantees and that work in FPT time for the parameter (k, t), where t is the upper-bound on the number of candidates each voter approves. Thus, these algorithms are practical only when the desired size of the committee k and the approval sets of the voters are all small. Moreover, Skowron [57] shows that if each voter approves sufficiently many candidates, then Sequential w-Thiele provides an even better approximation guarantee than 0.63. Analogous results, but with the focus on CC, are due to Skowron and Faliszewski [58].

For MAV, stronger approximation results hold: Byrka and Sornat [16] and Cygan et al. [22] present polynomial-time approximation schemes (PTAS) for MAV, i.e., polynomial-time approximation algorithms that achieves arbitrary (but fixed) precision; previous work established first a 3-approximation algorithm (LeGrand et al. [40]) and then a 2-approximation algorithm (Caragiannis et al. [18]).

5.2.4 Algorithms for Structured Domains

The fourth and final algorithmic technique is to consider structured preference domains. Here, the assumption is that preference profiles possess some combinatorial structure that gives algorithmic advantages. We refer the interested reader to a survey by Elkind et al. [27] that discusses this topic more broadly. For our purpose here, we would like to discuss only two restrictions: candidate and voter interval (defined by Elkind and Lackner [25], based on previous work by Dietrich and List [30], Faliszewski et al. [23], List [42]), but we note that many other restrictions exist and have been studied extensively [25, 26, 33, 50, 62, 63].

A profile A belongs to the candidate interval (CI) domain if there exists a linear order of candidates such that for each voter $i\in N$, the set A(i) appears contiguously on the linear order. Similarly, a profile A belongs to the voter interval (VI) domain if there exists a linear order of voters such that for each voter $c\in C$, the set N(c) appears contiguously on the linear order. The CI domain is closely related to the single-peaked domain for arbitrary ordinal preferences and the VI domain is similar to the single-crossing domain; this is analysed in more detail by Elkind and Lackner [25].

Under the assumption that preferences belong either to the CI or VI domain, the computational complexity can change dramatically: MAV is solvable in polynomial time if the given approval profile belongs either to the CI or VI domain [43]. Further, Thiele methods (Peters and Lackner [51]) and Monroe’s rule (Betzler et al. [9]) can be solved in polynomial time if the given approval profile belongs to the CI domain. It remains an open problem whether the same holds for the VI domain.

5.3 The Algorithmic Perspective on Proportionality

In this section, we briefly review the literature that deals with the computational problem of finding a proportional committee.

5.3.1 Finding Proportional Committees for Cohesive Groups

We first look at the proportionality concepts that formalise the behaviour of rules with respect to cohesive groups of voters; see Sect. 4.2.

Note that even the problem of deciding whether in a given instance of election there exists an $\ell$-cohesive group of voters is ${{\textrm{NP}}}$-complete [60]. Similarly, given a committee W, deciding whether W satisfies the EJR condition is ${{\textrm{coNP}}}$-complete [2]; the same holds for the problem of deciding whether W satisfies the PJR condition [3]. Checking if a given committee W satisfies JR is computationally easy—for each candidate one needs to check whether the group of voters approving this candidate is 1-cohesive, and if so, to check if less than $\nicefrac {n}{k}$ voters from such a group are left without a representative in W. Checking whether a given committee satisfies perfect representation (Definition 4.9) is also computationally easy—the problem reduces to finding a perfect constrained matching in a bipartite graph [56].

While the problem of checking if a given committee satisfies the EJR/PJR condition is computationally hard, for a given election instance one can find in polynomial time some committee that satisfies the two conditions (e.g., through the Method of Equal Shares [52], or through a local-search algorithm for PAV [3]). The situation is quite different for perfect representation (PR): it is ${{\textrm{NP}}}$-complete to check whether there exists a PR committee for a given election instance [56]. Consequently, unless $\textrm{P} = {{\textrm{NP}}}$, there exists no polynomial-time ABC rule that satisfies perfect representation.

5.3.2 Finding Committees with Attribute-Level Constraints

Next, we move to the model with external attribute-level constraints from Sect. 4.7.

We start by considering the model from Example 4.10, where we have a set of voters with approval-based preferences over the candidates, the candidates have attribute values (the attributes can be, e.g., gender, age group, education level, etc.) and for each attribute value we are given quotas specifying upper and lower limits on the number of committee members with this particular attribute value. Two recent works by Bredereck et al. [12] and Celis et al. [20] considered algorithmic aspects of the problem of finding committees maximising a certain score, subject to given attribute-level constraints. The authors considered the problem from the perspective of approximation algorithms and parameterized complexity theory, as well as variants of the problem where the attribute-level constraints have certain special structures. We do not describe their results in detail as the specific results are obtained for the ranking-based multi-winner model (see Sect. 6.1). However, it is worth mentioning that even the problem of finding a committee that satisfies the attribute-level constraints is computationally hard. Approximation and fixed-parameter tractable algorithms for this simpler problem were studied by Lang and Skowron [39].

A very similar model to the one from Example 4.10 is constrained approval voting (CAP) (Brams [10], Potthoff [53]). The main difference to the previously discussed model is that CAP uses constraints formulated for combinations of attributes. For example, a constraint can have the following form: “the proportion of young (Y) males (M) with higher education (H) in the committee should not exceed 14%”. Specifically, Brams [10] and Potthoff [53] suggest to pick the committee that maximises the AV score subject to the aforementioned combinatorial constraints. A direct translation of CAP into an ILP problem was given by Straszak et al. [61]. In general, the setting of constrained approval voting has not been thoroughly studied in its full generality, and the model is fairly unexplored from a computational perspective.

Finally, the computational problem of finding a committee subject to attribute-level constraints is related to the multidimensional knapsack problem (the main difference is that in the multidimensional knapsack the candidates can contribute more than a unit weight to each attribute-level constraint) and to the generic problem of optimising a submodular function subject to constraints (see, e.g., a survey by Krause and Golovin [37]). However, this literature usually deals with more general types of constraints, whereas the voting literature we discussed often concerns more specific approaches.

5.4 The Algorithmic Perspective on Strategic Voting

Other types of computational problems arise when one analyses how the results of ABC elections are affected by changes in voters’ preferences. There are several reasons to study this type of computational problems, and we briefly summarise them below. Historically, the first motivation was to use the computational complexity as a shield protecting elections from strategic manipulations. The reasoning was the following: if we cannot construct a good rule that is strategyproof (e.g., due to known impossibility theorems; cf. Sect. 4.6), then we could at least aim at proposing a rule for which it is computationally hard for a voter to come up with a successful strategic manipulation. This motivation originated in the context of single-winner elections, and was first proposed by Bartholdi et al. [6]. This reasoning was later contested since the analysis of computational complexity is worst-case in spirit. Even for rules for which the problem of finding a successful strategic manipulation is ${{\textrm{NP}}}$-hard, such manipulations can be found easily in the average case, in particular for many real-life preference profiles. For a more detailed discussion of these arguments (but with a focus on single-winner elections), we refer the reader to a survey by Faliszewski and Procaccia [28], a book by Meir [45], and handbook chapters by Conitzer and Walsh [21] and Faliszewski and Rothe [29].

In addition to the original motivation to study strategic voting, there are other, more “positive” applications that do not concern insincere behaviour. For example, the question of whether one can stop eliciting preferences and safely determine the winners of an election is equivalent to asking whether a group of (undecided) voters can still change the outcome of an election. These questions are captured by the manipulation problems discussed in Sect. 5.4.1. Furthermore, the problem of deciding whether the result of an election is robust to small changes in the given preference profile can also be phrased as “bribing” voters to change their ballots so to change the election result. We discuss the robustness problem in Sect. 5.4.2.

Before we move further, we note that for the case of selecting a single winner ($k=1$) under approval-based preferences, an excellent overview of computational issues related to strategic voting is given by Baumeister et al. [7].

5.4.1 Computational Complexity of Manipulation

We first consider the computational problem of finding a successful manipulation. Recall that we write $A_{+X}$ to denote the profile A with one additional voter approving X, i.e., $A_{+X}=(A(1),\dots ,A(n),X)$.

Definition 5.1

Consider an ABC rule $\mathcal {R}$. In the Utility-Manipulation problem, we are given an election instance (A, k), a utility function $u :C \rightarrow \mathbb R$, and a threshold value $t \in \mathbb R$. We ask whether whether there exists a profile $A'$ that extends A by r additional voters such that $\sum _{c \in W} u(c) \ge t$ for some $W\in \mathcal {R}(A_{+X}, k)$.

In the Subset-Manipulation problem, we are given an election (A, k), a subset of candidates $L \subseteq C$, and a positive integer r. We ask whether there exists a profile $A'$ that extends A by r additional voters such that $L \subseteq W$ for some $W\in \mathcal {R}(A', k)$.

Intuitively, in Utility-Manipulation we have manipulators with a utility function describing their level of appreciation for different candidates; the utility function is additive. The question is whether the manipulators can submit approval ballots such that they derive a utility of at least t from the elected committee. In Subset-Manipulation, the goal is slightly different—the manipulators want to ensure that the candidates from a given set L are all selected. For $r = 1$, Subset-Manipulation can be represented as Utility-Manipulation: we assign the utility of one to the candidates from L and the utility of zero to the other candidates, and set $t = |L|$. Observe that it makes sense to consider Utility-Manipulation also in the context of AV—this is because AV is strategyproof only for approval preferences, while the definition of Utility-Manipulation assumes the manipulators have more fine-grained preferences.

Meir et al. [46] studied Utility-Manipulation for $r=1$ and showed that it is solvable in polynomial time for Multi-Winner Approval Voting with adversarial tie-breaking,⁴ Baumeister et al. [8] proved that also Subset-Manipulation is solvable in polynomial time for AV. (The main focus of both papers is on ranking-based multi-winner rules, cf. Sect. 6.1.) Aziz et al. [1] show that Utility-Manipulation is computationally hard for SAV and PAV with a given tie-breaking order on candidates. They further prove that Subset-Manipulation is ${{\textrm{NP}}}$-hard for SAV and ${{\textrm{coNP}}}$-hard for PAV. For PAV the problem stays hard even if there is only a single manipulator ($r=1$), while for SAV with a single manipulator the problem becomes computable in polynomial time.

Bredereck et al. [11] studied a more general version of Utility-Manipulation, where the goal is to check whether there exists a coalition of voters that could jointly perform a successful manipulation. The authors focused on the $\ell$-Bloc rule, which is a variant of Multi-Winner Approval Voting, where each voter approves exactly $\ell$ candidates. Then, the coalition-manipulation problem is computationally hard in its all variants studied by the authors. On the other hand, if we look at an egalitarian version of $\ell$-Bloc (maximising the number of candidates in the committee that are approved by the worst-off voter), then the problem becomes computationally tractable. Another problem related to Utility-Manipulation has been considered by Barrot et al. [5]: given utility functions of all voters, is there an approval profile consistent with the utility functions in which a given committee wins.

5.4.2 Computational Complexity of Robustness

The next computational problem that we look at is Robustness, introduced by Bredereck et al. [14] and adapted to the ABC setting by Gawron and Faliszewski [35]. In the definition below, we consider the following three operations: the operation $\textrm{Add}$ adds a candidate to the approval set of some voter, $\textrm{Remove}$ deletes a candidate from the approval set of a voter, and $\textrm{Swap}$ is a combination of $\textrm{Add}$ and $\textrm{Remove}$ applied simultaneously to the approval set of a single voter.

Definition 5.2

(Bredereck et al. [14], Gawron and Faliszewski [35]) Consider an ABC rule $\mathcal {R}$ and an operation $\textrm{Op} \in \{\textrm{Add}, \textrm{Remove}, \textrm{Swap}\}$. In the $\textrm{Op}$-Robustness problem we are given an election instance (A, k) and an integer b. We ask whether there exist a sequence S of b operations of type $\textrm{Op}$ such that $\mathcal {R}(A, k) \ne \mathcal {R}(A', k)$, where $A'$ is the preference profile obtained from A by applying the operations from sequence S.

Gawron and Faliszewski [35] have shown that the $\textrm{Op}$-Robustness problem is computationally hard for PAV and CC, for each type of the three operations. On the other hand, the problem can be solved in polynomial time for AV and SAV. The authors also computed the robustness radius—a measure that says how much the result of an election can change in response to a single change in the preference profile—for several ABC rules. Notably, they show that for w-Thiele methods with $2w(1)>w(2)$ (this class includes PAV and CC), a single $\textrm{Add}$, $\textrm{Remove}$, or $\textrm{Swap}$ operation can lead to a completely different winning committee.

Gawron and Faliszewski [35] and Misra and Sonar [47] also considered the parameterized complexity of the Robustness problem, and have designed several parameterized algorithms for natural parameters, such as the number of voters n and the number of candidates m. Faliszewski et al. [31] considered a similar problem, but they asked whether, through a sequence of operations of a given type, one can make a particular candidate a member of a winning committee. This question is particularly relevant if one wants to report to non-winners how close they were to being selected. Finally, robustness of ABC rules has also been studied by Caragiannis et al. [19]; their analysis is based on a noise model assuming a “ground truth” (i.e., optimal) committee.