1 Introduction
A number of realworld problems consist of selecting a set of items for a group of agents to jointly use. Examples of such activities include picking a set of movies to put on a plane’s entertainment system, deciding which journals a university library should subscribe to, deciding what common facilities to build, or even voting for a parliament (or other assembly of representatives). Let us consider some common features of these examples.
First, there is a set of items^{2}^{2}2We use the term ‘item’ in the most neutral possible way. Items may be candidates running for an election, or movies, or possible facilities, and so on. and a set of agents; each agent has some intrinsic utility for each of the items (e.g., this utility can be the level of appreciation for a movie, the average number of articles one reads from a given issue of a journal, expected benefit from building a particular facility, the feeling—measured in some way—of being represented by a particular politician).
Second, typically it is not possible to provide all the items to the agents and we can only pick some of them, say (a plane’s entertainment system fits only a handful of movies, the library has a limited budget, only several sites for the facilities are available, the parliament has a fixed size).
Third, the intrinsic utilities for items extend to the sets of items in such a way that the utility derived by an agent from a given item may depend on the rank of this item (from the agent’s point of view) among the selected ones. Extreme examples include the case where each agent derives utility from his or her most preferred item only (e.g., an agent will watch his or her favorite movie only, will read/use the favorite journal/favorite facility only, will feel represented by the most appropriate politician only), from his or her least preferred item only (say, the agent worries that the family will force him or her to watch the worst available movie), or derives
of the utility from each of the available items (e.g., the agent chooses the item—say, a movie—at random). However, in practice one should expect much more complicated schemes (e.g., an agent watches the top movie certainly, the second one probably, the third one perhaps, etc.; or, an agent is interested in having at least some
interesting journals in the library; an agent feels represented by some top members of the parliament, etc.).The goal of this paper is to formally define a model that captures all the abovedescribed scenarios, provide a set of examples where the model is applicable, and provide an initial set of computational results for it in terms of efficient algorithms (exact or approximate) and computational hardness results (hardness and inapproximability results).
Our work builds upon, generalizes, and extends quite a number of settings that have already been studied in the literature. We provide a deeper overview of this research in Section 8 and here we only mention the two most directly related lines of work. First, our model where the agents derive utility from their most preferred item among the selected ones directly corresponds to winner determination under the Chamberlin–Courant’s voting rule [18, 48, 7] (it is also very deeply connected to the model of budgeted social choice [39, 47, 40]) and is in a certain formal sense a variant of the facility location problem. Second, the case where for each item each agent derives the same fraction of the utility is, in essence, the same as winner rangevoting (or winner Borda [21]); that agents enjoy equally the items they get is also a key assumption in the Santa Claus problem [6], and in the problem of designing optimal picking sequences [14, 10, 33].
The paper is organized as follows. First, in Section 2 we discuss several important modeling choices and provide the formal description of our model. Then, in Section 3, we discuss the applicability of the model in various scenarios. Specifically, we show a number of examples that lead to particular parameter values of our model. We give an overview of our results in Section 4 and then, in Sections 5, 6, and 7, we present these results formally. In Section 5 we present results regarding the complexity of computing exact solutions for our model. In the next two sections we discuss the issue of computing approximate solutions. First without putting restrictions on agents’ utilities (Section 6) and, then, for what we call nonfinicky utilities (Section 7). Intuitively put, under nonfinicky utilities the agents are required to give relatively high utility values to a relatively large fraction of the items). We believe that the notion of nonfinicky utilities is one of the important contributions of this paper. We discuss related work in Section 8 and conclude in Section 9.
2 The Model
In this section we give a formal description of our model. However, before we move on to the mathematical details, let us explain and justify some highlevel assumptions and choices that we have made.
First, we assume that the agents have separable preferences. This means that the intrinsic utility of an object does not depend on what other objects are selected. This is very different from, for example, the case of combinatorial auctions. However, in our model the impact of an object on the global utility of an agent does depend on its rank (according to that agent) among the selected items. This distinction between the intrinsic value of an item and its value distorted by its rank are also considered in several other research fields, especially in decision theory (where it is known as “rankdependent utility theory”) and in multicriteria decision making, from which we borrow one of the main ingredients of our approach, the ordered weighted average (OWA) operators [55] (for technical details see the work of Kacprzyk et al. [32]). OWAs were recently used in social choice in several contexts [29, 3, 23]; we discuss these works in detain in Section 8.
Second, throughout the paper we navigate between two views of the agents’ intrinsic utilities:

Generally, we assume that the utilities are provided explicitly in the input as numerical values, and that these values are comparable between agents. Yet, we make no further assumptions about the nature of agents’ utilities: they do not need to be normalized, they do not need to come from any particular range of values, etc. Indeed, it is possible that some agent has very strong preferences regarding the items, modeled through high, diverse utility values, whereas some other agent does not care much about the selection process and has low utility values only.

In some parts of the paper (which will always be clearly identified), we assume that utilities are heavily constrained and derive from nonnumerical information, such as approval ballots specifying which items an agent approves (leading to approvalbased utilities), or rankings over alternatives, from which utilities are derived using an agentindependent scoring vector (typically, a Bordalike vector).
Formally, the latter view is a special case of the former, but we believe that it is worthwhile to consider it separately. Indeed, many multiwinner voting rules (such as the Chamberlin–Courant [18] rule or the Proportional Approval Voting rule [35]) fit the second view far more naturally, whereas for other applications the former view is more natural.
Third, we take the utilitarian view and measure the social welfare of the agents as the sum of their perceived utilities. One could study other variants, such as the egalitarian variant, where the social welfare is measured as the utility of the worstoff agent. We leave this as possible future research (our preliminary attempts indicated that the egalitarian setting is computationally even harder than the utilitarian one). Very recently, Elkind and Ismaïli [23] used OWA operators to define variants of the Chamberlin–Courant rule that lay between the utilitarian and egalitarian variants; we discuss this work in more detail in Section 8.
2.1 The Formal Setting
Let be a set of agents and let be a set of items. The goal is to pick a size set of items that, in some sense, is most satisfying for the agents. To this end, (1) for each agent and for each item we have an intrinsic utility that agent derives from ; (2) the utility that each agent derives from a set of items is an ordered weighted average [55] of this agent’s intrinsic utilities for these items.
A weighted ordered average (OWA) operator over numbers is a function defined through a vector of (nonnegative) numbers^{3}^{3}3The standard definition of OWAs assumes normalization, that is, . We do not make this assumption here, for the sake of convenience; note that whether OWA vectors are normalized or not is irrelevant to all notions and results of this paper. as follows. Let be a vector of numbers and let be the nonincreasing rearrangement of , that is, , where is a permutation of such that . Then we set:
To make the notation lighter, we write , instead of .
We provide a more detailed discussion of the OWA operators useful in our context later and here we only mention that, for example, they can be used to express the arithmetic average (through the size vector ), the maximum and minimum operators (through vectors , and , respectively) and the median operator (through the vector of all zeros, with a single one in the middle position).
We formalize our problem of computing “the most satisfying set of items” as follows.
Definition 1.
In the OWAWinner problem we are given a set of agents, a set of items, a collection of agent’s utilities , a positive integer (), and a number OWA . The task is to compute a subset of such that is maximal.
Example 1.
Consider six agents with the following utilities over the items from the set :
We want to select items and we use OWA . What is the score of ? The first three agents get utility each, the next two get each, and the last one gets . So, the score of is . Indeed, this is the optimal set; the next best ones are , and , all with score . The rule defined by the OWA , known as Borda (due to the very specific values of agents’ utilities; see Example 2 in the next section), would choose and Chamberlin–Courant’s rule (in our terms, the rule defined by the OWA operator ) would choose .
For a family of OWAs, we write OWAWinner to denote the variant of the problem where for each given solution size we use OWA . From now on we will not mention the size of the OWA vector explicitly and it will always be clear from the context. We implicitly assume that OWAs in our families are polynomialtime computable.
2.2 Classes of Intrinsic Utilities
While our general setting allows agents to express arbitrary utilities, we also focus on two cases where they only provide dichotomous or ordinal information:
 Dichotomous information.

Agents provide dichotomous information if they only have to specify which items they like. This information is then mapped into dichotomous (or, as we typically refer to them, approvalbased) utilities, defined by if likes and otherwise.
 Ordinal information.

Agents provide ordinal information if they only have to specify their rankings over items, called their preference orders. This information is then mapped into utilities using a scoring vector, exactly in the same way as positional scoring rules (for singlewinner voting) do. We focus on the partiuclar case where this scoring vector is the Borda vector, i.e., if the rank of in ’s ranking is then . We refer to this setting as Bordabased utilities.
Naturally, these are special cases of our general setting. Yet using approvalbased or Bordabased utilities can be more convenient than using the general approach.
Example 2.
The utilities of the agents from Example 1 are Bordabased and can be expresses as the following preference orders:
Both approvalbased utilities and Bordabased utilities are inspired by analogous notions from the theory of voting, where approval and Borda count are very wellknown singlewinner voting rules (briefly put, under these rules we treat the utilities of the items as their scores, sum up the scores assigned to the items by the voters, and elect the item that has the highest score). Further, Bordabased utilities have been used in the original Chamberlin–Courant’s rule and in several works on fair division (see, e.g., a paper of Brams and King [13]).
One of the highlevel messages of this paper is that OWAWinner problems tend to be computationally easier for the case of Bordabased utilities than for the case of approvalbased ones (while we typically obtain hardness in both settings, we find good approximation algorithms for many of the Bordabased cases, whereas for the approvalbased setting our algorithms are either significantly weaker or we obtain outright inapproximability results). This is so mostly because under Bordabased utilities all the agents assign relatively high utility values to a relatively large fraction of items. In the following definition we try to capture this property.
Definition 2.
Consider a setting with items and let denote the highest utility that some agent gives to an item. Let and be two numbers in . We say that the agents have (, )nonfinicky utilities if every agent has utility at least for at least items.
To understand this notion better, let us consider the following example.
Example 3.
Let and . The utilities are as defined below:
The agents have nonfinicky utilities. Indeed, all there agents have utility at least 8 for at least half of the items. They also have nonfinicky utilities, and nonfinicky utilities. We will also use the agents and items from this example later, when presenting our algorithms.
As we can expect, Bordabased utilities are nonfinicky in a very natural sense.
Observation 1.
For every , , Bordabased utilities are nonfinicky.
However there are also other natural cases of nonfinicky utilities. For example, consider agents that have approvalbased utilities and where each agent approves of at least a fraction of the items. These agents have nonfinicky utilities. (The reader may be surprised here that approvalbased utilities may be nonfinicky even though we said that we obtain inapproximability results for them. Yet, there is no contradiction here. These inapproximability results rely on the fact that some agents approve of very few items.)
2.3 A Dictionary of Useful OWA Families
Below we give a catalog of OWA families that we focus on throughout the paper (in the description below we take to be the dimension of the vectors to which we apply a given OWA).

median OWA. For each , is the OWA defined by the vector of zeros, followed by a single one, followed by zeros. It is easy to see that is the th largest number in the set and is known as the median of . In particular, is the maximum operator, is the minimum operator, and if
is odd,
is the median operator. 
best OWA. For each , OWA is defined through the vector of ones followed by zeros. That is, is the sum of the top values in (with appropriate scaling, this means an arithmetic average of the top numbers). is simply the sum of all the numbers in (after scaling, the arithmetic average).

Arithmetic progression OWA. This OWA is defined through the vector , where and . (One can easily check that the choice of has no impact on the outcome of OWAWinner; this is not the case for , though.)

Geometric progression OWA. This OWA is defined through the vector , where . (This is without loss of generality, because multiplying the vector by a constant factor has no impact on the outcome of OWAWinner; but the choice of matters.)

Harmonic OWA. This OWA is defined through the vector ,

Hurwicz OWA. This OWA is defined through a vector , where , , is a parameter.
Naturally, all sorts of middleground OWAs are possible between these particular cases, and can be tailored for specific applications. As our natural assumption is that highly ranked items have more impact than lowerranked objects, we often make the assumption that OWA vectors are nonincreasing, that is, . While most OWA operators we consider in the paper are indeed nonincreasing, this is not the case for medians (except for median) and Hurwicz (except for ).
3 Applications of the Model
We believe that our model is very general. To substantiate this claim, in this section we provide four quite different scenarios where it is applicable.
Generalizing Voting Rules. Our research started as an attempt to generalize the rule of Chamberlin and Courant [18] for electing sets of representatives. For this rule, the voters (the agents) have Bordabased utilities over a set of candidates and we wish to elect a member committee (e.g., a parliament), such that each voter is represented by one member of the committee. If we select candidates, then a voter is “represented” by the selected candidate that she ranks highest among the chosen ones. Thus, winner determination under Chamberlin–Courant’s voting rule boils down to solving OWAWinner for the case of Bordabased utilities. On the other hand, solving OWAWinner for Bordabased utilities is equivalent to finding winners under Borda, the rule that picks candidates with the highest Borda scores (see the work of Elkind et al. [22] for a classification of multiwinner voting rules, including, e.g., Borda and Chamberlin–Courant’s rule).
Our model extends one more appealing voting rule, known as Proportional Approval Voting (PAV; see the work of Kilgour [35] for a review of approvalbased multiwinner rules, and the work of Aziz et al. [5] and Elkind and Lackner [24] for computational results). Winner determination under PAV is equivalent to solving OWAWinner for the harmonic OWA, for the case of approvalbased utilities.
Malfunctioning Items or Unavailable Candidates. Consider a setting where we pick the items offline, but online it may turn out that some of them are unavailable (for example, we pick a set of journals the library subscribes to, but when an agent goes to a library, a particular journal could already be borrowed by someone else; see the work of Lu and Boutilier [38] for other examples of social choice with possibly unavailable candidates). We assume that each item is available with the same, given, probability (i.i.d.). The utility an agent gets from a set of selected items is the expected value of the best available object. The probability that the ’th item is available while the preceding items are not, is proportional to . So, to model the problem of selecting items in this case, we should use the geometric progression OWA with initial value and coefficient .
Uncertainty Regarding How Many Items a User Enjoys. There may be some uncertainty about the number of items a user would enjoy (e.g., on a plane, it is uncertain how many movies a passenger would watch; one might fall asleep or might only watch those movies that are good enough). We give two possible models for the choice of the OWA vectors:

The probability that an agent enjoys items, for
, is uniformly distributed, i.e., an agent would enjoy exactly his or her first
items in with probability . So, the agent enjoys the ’th item if she enjoys at least items, which occurs with probability ; we should use OWA vector defined by (we disregard the normalizing constant), i.e., an arithmetic progression. 
We assume that the values given by each user to each item are distributed uniformly, i.i.d., on and that each user uses only the items that have a value at least , where is a fixed (userindependent) threshold. Therefore, a user enjoys the item in ranked in position if she values at least items at least , which occurs with probability , thus leading to the OWA vector defined by .
Ignorance About Which Item Will Be Assigned to a User. We now assume that a matching mechanism will be used after selecting the items. The matching mechanism is not specified; it might also be randomized. If the agents have a complete ignorance about the mechanism used, then it makes sense to use known criteria for decisionmaking under complete uncertainty:

The Wald criterion assumes that agents are extremely riskaverse, and corresponds to . The agents consider their worst possible items.

The Hurwicz criterion is a linear combination between the worst and the best outcomes, and corresponds to for some fixed .
If the agents know that they are guaranteed to get one of their best items, then the Wald and Hurwicz criteria lead, respectively, to the OWAs and , with in position . If the agents know that the mechanism gives them one of their top items, each with the same probability, then we should use OWA. More generally, the matching mechanism may assign items to agents with a probability that decreases when the rank increases.
4 Overview of the Results
general and  –nonfinicky  
OWA family  approval utilities  and Borda utilities  References 
median ( fixed)  hard  hard (Borda)  Proposition 8 
DkSbounded  approx.  Theorem 15 and Corollary 26  
PTAS (Borda)  Theorem 30  
median  hard  hard  Theorems 6 and 7 
MEBPbounded  ?  Theorem 19, open problem  
best  hard (approval)  hard (Borda)  Literature [48, 39] 
approx.  approx.  Literature [39], Corollary 26  
PTAS (Borda)  Literature [53]  
best ( fixed)  hard (approval)  hard (Borda)  Proposition 8 
approx.  approx.  Theorem 13 and Corollary 26  
best  hard (approval)  hard (Borda)  Theorems 6 and 7 
PTAS  PTAS  Theorem 23  
best  folk result  
arithmetic progression  hard  ?  Theorem 3, open problem 
approx.  approx.  Theorem 13  
geometric progression  hard  ?  Theorem 3, open problem 
approx.  Theorem 13, Corollary 31  
Hurwicz[]  hard (approval)  ?  Corollary 20, open problem 
approx.  approx.  Corollary 22  
for each  
In this section we provide a highlevel overview of our results. It turns out that computational properties of the OWAWinner problem are quite varied and strongly depend on the types of OWA operators and the allowed agent utilities. We present a summary of our results in Table 1 (however, we stress that some of our technical results are not listed in the table and can be found only in the following sections).
Our first observation is that without any restrictions, OWAWinner is hard. This is hardly surprising since the problem generalizes other hard problems, and it is natural to ask if there are any special cases where it is easy. Unfortunately, as we show in Section 5, they are very rare. For example, without restrictions on the agents’ utilities, OWAWinner can be solved in polynomial time either if we treat as a constant or if we use the constant OWA vector (i.e., if we use OWA). Indeed, the problem becomes hard already for the OWA. This holds even if the agents are restricted to have approvalbased utilities (Theorem 6) or Bordabased utilities (Theorem 7). More generally, we show that OWAWinner is hard for every family of OWA vectors that are nonconstant and nonincreasing (Theorem 5), which captures a significant fraction of all interesting settings.
After considering the worstcase complexity of computing exact solutions in Section 5, in Section 6 we focus on the approximability of the OWAWinner problem. We show that in this respect there is a significant difference between two main classes of OWA vectors, those that are nonincreasing and the remaining ones. We show that for the nonincreasing OWA vectors the standard greedy algorithm for optimizing submodular functions achieves approximation ratio of (), irrespective of the nature of the agents’ utilities (Lemma 12 and Theorem 13). On the other hand, we present evidence that there is little hope for good approximation algorithms for the case of OWA vectors that are not nonincreasing (Example 5 and Theorems 15 and 19).
Next, in Section 7, we consider approximation algorithms for OWAWinner for the case where agents have nonfinicky utilities. It turns out that for nonfinicky utilities we can sometimes obtain much better approximability guarantees than in the general setting. The key feature of nonfinicky utilities assumption is that every agent gives sufficiently high utility values to sufficiently many items, so that the algorithms have enough flexibility in picking the items to achieve high quality results. Specifically, we show a strong approximation algorithm for the case of nonfinicky utilities and OWA vectors that concentrate most of the weight in a constant number of their top coefficients (Theorems 25, 29, 30, and Corollary 31). These results apply, for example, to the case of geometric progression OWAs, OWAs, and OWAs (for fixed values of ). Further, when applied to the case of Bordabased utilities (which, as we have argued in Section 2.2, are nonfinicky in a very strong sense), we obtain polynomialtime approximation schemes (that is, approximation algorithms that can compute solutions with an arbitrarily good precision, but whose running time depends polynomially only on the size of the problem but not necessarily on the desired approximation ratio).
5 Computing Exact Solutions
We start our analysis by discussing the complexity of solving the OWAWinner problem exactly. In general, it seems that OWAWinner is a rather difficult problem and below we show this section’s main negative result. That is, we show that our problem is hard for any class of OWA vectors satisfying a certain natural restriction. Intuitively, this restriction says that in a considered family of OWAs, the impact of moreliked items on the total satisfaction of an agent is greater than that of the lessliked ones.
Theorem 3.
Fix an OWA family such that for every , is nonincreasing and nonconstant. OWAWinner is hard, even for approvalbased utilities.
For the sake of readability, we first prove two simpler results that we later use in the proof of Theorem 3. In these proofs, we give reductions from the standard VertexCover problem and from CubicVertexCover, its variant restricted to cubic graphs.
Definition 4.
In the VertexCover problem we are given an undirected graph , where is the set of vertices and is the set of edges, and a positive integer . We ask if there is a set of up to vertices such that each edge is incident to at least one vertex from . The CubicVertexCover problem the same problem, restricted to graphs where each vertex has degree exactly three.
VertexCover is wellknown to be hard [28]; hardness for CubicVertexCover was shown by Alimonti and Kann [1].
Theorem 5.
Fix an OWA family , such that there exists such that for every we have . OWAWinner is hard, ever for approvalbased utilities.
Proof.
We give a reduction from CubicVertexCover problem. Let be an instance of CubicVertexCover with graph , where and , and positive integer . W.l.o.g., we assume that .
We construct an instance of OWAWinner. In we set (the agents correspond to the edges), (there are dummy items; other items correspond to the vertices), and we seek a collection of items of size . Each agent , , has utility exactly for all the dummy items and for two vertices that connects and for each of the dummy items (for the remaining items has utility ). In effect, each agent has utility for exactly items.
We claim that is a yesinstance of CubicVertexCover if and only if there exists a solution for with the total utility at least .
If there is a vertex cover of size for , then by selecting the items we obtain the required utility of the agents. Indeed, for every agent there are at least items in for which gives value (the dummy items and at least one vertex incident to ). These items contribute the value to the total agents’ utility. Additionally, since every nondummy item has value for exactly 3 agents, and since every agent has at most items with value , there are exactly agents that have exactly items in with values . These ’th additional utility items of the agents contribute to the total utility. Altogether, the agents’ utility is , as claimed.
Let us assume that there is a set of items with total utility at least . In we have items that have value for each of the agents, and every other item has value for exactly agents. Thus, the sum of the utilities of items (without applying the OWA operator yet) is at most . Thus, the total utility of the agents (now applying the OWA operator) is only if for each agent the solution contains items with utility . Since there are only dummy items, it means that for each agent there is a vertex in the solution such that is incident to . That is, is a yesinstance of CubicVertexCover. ∎
Theorem 6.
OWAWinner is complete even for approvalbased utilities.
Proof.
Membership in is clear. We show a reduction from the VertexCover problem. Let be an instance of VertexCover with graph , where and , and with a positive integer (without loss of generality, we assume that and ).
We construct an instance of bestOWAWinner in the following way. We let the set of items be and we form agents, two for each edge. Specifically, if is an edge connecting two vertices, call them and , then we introduce two agents, and , with the following utilities: has utility for and for , and has utility for all the other items; has opposite utilities—it has utility for and for , and has utility for all the remaining ones.
Let be some set of items (i.e., vertices) and consider the sum of the utilities derived by the two agents and from under bestOWA. If neither nor belong to , then the total utility of and is equal to (the former agent gets utility and the latter one gets ). If only one of the items, i.e., either or , belongs to , then the total utility of and is equal to (the former agent gets utility and the latter one still gets ). Finally, if both items belong to , then the total utility of and is also equal to (the former gets utility and the latter gets utility ). Thus the total utility of all agents is equal to if and only if the answer to the instance is “yes”. This shows that the reduction is correct and, since the reduction is computable in polynomial time, the proof is complete. ∎
Using a proof that combines the ideas of the proof of Theorems 5 and 6, we show that indeed OWAWinner is hard for a large class of natural OWAs.
Proof of Theorem 3.
We give a reduction from CubicVertexCover. Let be an instance of CubicVertexCover with graph , where and , and with positive integer .
Now let us consider . Since is nonincreasing and nonconstant, one of the two following conditions must hold.

There exists such that .

There exists such that , and for every , we have .
If (1) is the case then we use a reduction similar to that in the proof of Theorem 5. The only difference is that apart from the set of dummy items (ranked first by all agents), we introduce the set of dummy items and sets , each consisting of dummy agents. The dummy items from are introduced only to fillup the solution up to members. The dummy agents from have utility for each of the items from and for the ’th item from (they have utility for all the other items). This is to enforce that the items from are selected in the optimal solution. The further part of the reduction is as in the proof of Theorem 5.
If (2) is the case, then we use a reduction similar to that in the proof of Theorem 6. We let the set of items be , where , , and , are sets of dummy items that we need for our construction. Similarly as in the proof of Theorem 6, for each edge we introduce two agents and . Here, however, we additionally need the set of dummy agents. Each dummy agent from assigns utility 1 to each dummy item from and utility 0 to the remaining items—consequently, since , each dummy item from must be selected to every optimal solution. Further, each nondummy agent assigns utility 1 to each dummy agent from —this way we ensure that every item from must be selected to every optimal solution. Finally, the utilities of the nondummy agents for the nondummy items are defined exactly as in the proof of Theorem 6. This ensures that the optimal solution, apart from and , will contain the nondummy items that correspond to the vertices from the optimal vertex cover. ∎
One may wonder if our justpresented hardness results also hold for other restrictions on agents’ utilities. Below we show a variant of the result from Theorem 6 for Bordabased utilities. It follows by an application of a similar idea as in the proof of Theorem 6, but the restriction to Bordabased utilities requires a much more technical proof (available in the appendix).
Theorem 7.
OWAWinner is hard even for Bordabased utilities.
5.1 Inherited Hardness Results
We now consider the cases of OWAWinner and OWAWinner (where is a constant). By results of Procaccia, Rosenschein and Zohar [48] and Lu and Boutilier [39], we know that the bestOWAWinner problem is hard both for both approvalbased utilities and Bordabased utilities (in this case the problem is equivalent to winner determination under appropriate variants of Chamberlin–Courant voting rule; in effect, many results regarding the complexity of this rule are applicable for this variant of the problem [7, 53, 56, 52]). A simple reduction shows that this result carries over to each family of best OWAs and of med OWAs, where is a fixed positive integer (note that for the case of approvalbased utilities, these results also follow through Thoerem 3).
Proposition 8.
For each fixed , OWAWinner and OWAWinner are complete, even if the utility profiles are restricted to be approvalbased or Bordabased.
Proof.
Let be a fixed constant. It is easy to see that bestOWAWinner and medOWAWinner are both in . To show hardness, we give reductions from bestOWAWinner (either with approvalbased utilities or with Bordabased utilities) to bestOWAWinner and to medOWAWinner (with the same types of utilities).
Let be an instance of bestOWAWinner with agents, items, and where we seek a winner set of size . We form an instance of bestOWAWinner that is identical to except that: (1) We add special items such that under approvalbased utilities each agent has utility for each item , , and under Bordabased utilities each agent has utility for item , . (2) We set the size of the desired winner set to be . It is easy to see that if there is an optimal solution for that achieves some utility , then there is a solution for that uses all the items and also achieves utility . Further, the set is an optimal solution for and, for , has utility .
Analogous argument shows that bestOWAWinner reduces to medOWAWinner (also for approvalbased and for Bordabased utilities). ∎
We leave the problem of generalizing the above two theorems to more general classes of OWA vectors as a technical (but conceptually easy) open problem.
5.2 Rare Easy Cases
While the OWAWinner problem is in general hard, there are also some natural easy cases. For example, the problem is in provided that we seek a winner set of a fixed size. Naturally, in practice the variant of the problem with fixed has only limited applicability.
Proposition 9.
For each fixed constant (the size of the winner set), OWAWinner is in .
Proof.
For a profile with items, there are only sets of winners to try. We try them all and pick one that yields highest utility. ∎
Similarly, the problem is in when the number of available items is fixed (it follows by applying the above proposition; if the number of items is fixed then so is ). Throughout the rest of the paper we focus on the OWAWinner variant of the problem, where is given as part of the input and represents a family of OWAs, one for each value of .
It is easy to note that for best OWA (that is, for the family of constant OWAs ) the problem is in .
Proposition 10.
OWAWinner is in .
Proof.
Let be an input instance with items and agents, where we seek a winner set of size . It suffices to compute for each item the total utility that all the agents would derive if this item were included in the winner set and return items for which this value is highest. ∎
Indeed, if the agents’ utilities are either approvalbased or Bordabased, bestOWAWinner boils down to (polynomialtime) winner determination for best approval rule and for Borda rule [21], respectively (see also the work of Elkind et al. [22] for a general discussion of multiwinner rules). However, in light of this fact, Theorems 6 and 7 appear quite surprising.
Given the results in this section so far, we conjecture that the family of constant OWAs, that is, the family of best OWAs, is the only natural family for which OWAWinner is in . We leave this conjecture as a natural followup question.^{4}^{4}4It is tempting to conjecture that for all families of nonconstant OWAs, not just the natural ones, the problem is hard. This, however, is not the case. Indeed, by following the arguments of the classic theorem of Ladner [36], it is possible to show a polynomialtime computable family of OWAs such that OWAWinner is in , but is neither complete nor in . (Intuitively put, such a family could consist of interspersed long fragments where the OWAs are either best or best. The best fragments would prevent the problem from being complete, while the best fragments would prevent it from being in .)
5.3 Integer Programming
In spite of all the hardness results that we have seen so far, we still might be in a position where it is necessary to obtain an exact solution for a given OWAWinner instance, and where the bruteforce algorithm from Proposition 9
is too slow. In such a case, it might be possible to use an integer linear programming (ILP) formulation of the problem, given below. We believe that this ILP formulation is interesting in its own right and, in particular, that it is interesting future work to experimentally assess the size of instances for which it yields solutions in reasonable amount of time.
Theorem 11.
OWAWinner reduces to computing a solution for the following integer linear program.
subject to:  
Proof.
Consider an input instance with agents and items , where we seek a winner set of size , under OWA . For each , , we write to denote the utility that agent derives from item .
We form an instance of ILP with the following variables: (1) For each , , and , there is an indicator variable (intuitively, we interpret to mean that for agent , item is the th most preferred one among those selected for the solution). (2) For each , there is an indicator variable (intuitively, we interpret to mean that is included in the solution). Given these variables (and assuming that we enforce their intuitive meaning), the goal of our ILP is to maximize the function .
We require that our variables are indeed indicator variables and, thus, take values from the set only (constraints (f) and (g)). We requite that the variables of the form are internally consistent. (constraint (c) says that each agent ranks only one of the candidates from the solution as th best, constraint (d) say that there is no agent and item such that views as ranked on two different positions among the items from the solution.) Then, we require that variables of the form are consistent with those of the form (constraint (b)) and that exactly items are selected for the solution (constraint (a)).
Our final constraint, constraint (e), requires that variables indeed for each agent sort the items from the solution in the order of descending utility values. We mention that constraint (e) is necessary only for the case of OWAs that are notnonincreasing. For a nonincreasing , an optimal solution for our ILP already ensures the correct “sorting” (otherwise our goal function would not be maximized). ∎
We should note that linearprogramming formulations of OWAbased optimization problems have appeared in the literature far before our work; see, for example, the paper of Ogryczak and Śliwinski [46]. Yet, we use the OWA operators in a very different way and, thus, our approach is different. (In essence, Ogryczak and Śliwiński use an OWA operator to aggregate a number of values, whereas we use a simple sum to aggregate the agents’ perceived utilities, but we compute these perceived utilities by applying an OWA operator to each agent’s individual, intrinsic utilities.)
6 Approximation: General Utilities and Approval Utilities
The OWAWinner problem is particularly wellsuited for applications that involve recommendation systems (see, e.g., the work of Lu and Boutilier [39] for a discussion of
bestOWAWinner in this context). For recommendation systems it often suffices to find good approximate solutions instead of perfect, exact ones, especially if we only have estimates of agents’ utilities. It turns out that the quality of the approximate solutions that we can produce for
OWAWinner very strongly depends on both the properties of the particular family of OWAs used and on the nature of agents’ utilities.First, we show that as long as our OWA is nonincreasing, a simple greedy algorithm achieves approximation ratio. This result follows by showing that for a nonincreasing OWA , the function (recall Definition 1) is submodular and nondecreasing, and by applying the famous result of Nemhauser et al. [44].
Recall that if is some set and is a function , then we say that: (1) is submodular if for each and , , and each it holds that:
and (2) is nondecreasing if for each and each it holds that .
Lemma 12.
Let be an instance of OWAWinner with a nonincreasing OWA . The function is submodular and nondecreasing.
Proof.
Let be an instance of OWAWinner with agent set , item set , desired solution size , and OWA . For each agent and each item , is a nonnegative utility that derives from .
Since all the utilities and all the entries of the OWA vector are nonnegative, we note that is nondecreasing. To show submodularity, we decompose as follows:
For each , and , let be the set of those items from whose utility, from the point of view of agent , is highest (we break ties in an arbitrary way). Since nonnegative linear combinations of submodular functions are submodular, it suffices to prove that for each and each , function is submodular.
To show submodularity of , consider two sets, and , , and some . We claim that:
(1) 
Let and denote the utilities that the th agent has for the th best items from and , respectively (or if a given set has fewer than elements). Of course, . Let denote th agent’s utility for . We consider two cases. If , then both sides of (1) have value 0. Otherwise:
which proves (1) and completes the proof. ∎
Based on the above result, we can easily show that Algorithm 1 is a polynomial time approximation for the OWAWinner problem, for the case of nonincreasing OWA vectors (see Theorem 13 below). Algorithm 1 is a natural incarnation of the greedy algorithm of Nemhauser et al. [44]. It starts by setting the foundsofar solution to be empty. Then, in each iteration it extends by adding this item that causes the greatest increase in the utility.
Example 4.
Let the items and agents be as in Example 3. Let and consider OWA vector . Throughout the iterations, we obtain the following gain values (the contents of are given at the beginning of each iteration; below we also explain some of the computation):
At the beginning of the first iteration and the algorithm simply computes the utility of each item separately, using OWA operator . For example, . In the first iteration both and lead to the highest gain and, so, the algorithm is free to pick either of them. We assume it picks . In the second iteration, we have and, for example, the gain value for is computed as:
It is the highest gain value and so the algorithm includes in the solution. In the third iteration, item has the highest gain and so the algorithm includes it in . Finally, the algorithm outputs .
Theorem 13.
For a nonincreasing OWA , Algorithm 1 is a polynomial time approximation algorithm for the problem of finding the utilitarian set of winners.
Proof.
The thesis follows from the results of Nemhauser et al. [44] on approximating nondecreasing submodular functions. ∎
Algorithm 1 has interesting interpretation in the context of voting systems. This greedy algorithm can be viewed not only as an approximation algorithm, but also as a new iterative voting rule. Indeed, many popular voting rules are defined as iterative (greedy) algorithms. Such rules are not only polynomially solvable, but also are easier to understand for the society. Further, Caragiannis et al. [17] and, later, Elkind et al. [22], advocate viewing approximation algorithms for computationally hard voting rules as new election systems, and study their axiomatic properties (often showing that they are better than those of the original rules).
Here we give another interesting observation. It turns out that the algorithm from Theorem 13, when applied to the case of approvalbased utilities and the harmonic OWA, is simply the winner determination procedure for the Sequential Proportional Approval Voting rule [11] (developed by the Danish astronomer and mathematician Thorvald N. Thiele, and used for a short period in Sweden during early 1900’s). That is, the Sequential Proportional Approval Voting rule is simply an approximation of the PAV rule (the Proportional Approval Voting rule). We believe that this observation gives another evidence that approximation algorithms for computationally hard voting rules can indeed be viewed as new fullfledged voting rules. (We point readers interested in approvalbased multiwinner voting rules to the overview of Kilgour [35] and to the works of Aziz et al. [5, 4], Elkind and Lackner [24], and Skowron and Faliszewski [52]).
Is a approximation algorithm a good result? After all, and so the algorithm guarantees only about 63% of the maximum possible satisfaction for the agents. Irrespective if one views it as sufficient or not, this is the best possible approximation ratio of a polynomialtime algorithm for (unrestricted) OWAWinner with a nonincreasing OWA. The reason is that bestOWAWinner with approvalbased utilities is, in essence, another name for the MaxCover problem, and if , then is approximation upper bound for MaxCover [25]. We omit the exact details of the connection between MaxCover and bestOWAWinner and instead we point the readers to the work of Skowron and Faliszewski [52] who discuss this point in detail (we mention that they refer to what we call bestOWAWinner as winner determination for Chamberlin–Courant’s voting rule).
For OWAs that are not nonincreasing, it seems that we cannot even hope for a approximation algorithm. There are two arguments to support this belief. First, such OWAs yield utility functions that are not necessarily submodular and, so, it is impossible to apply the result of Nemhauser et al. [44]. As an example, we show that medOWA yields a utility function that is not submodular.
Example 5.
Let us consider a single agent, two sets of items and (of course ), and OWA . The utilities of the agent over the items , , , and are equal to 10, 9, 2, and 1, respectively. We get:
That is, is not submodular. Indeed, this example works even for approvalbased utilities: it suffices to set the utilities for and to be , and for and to be .
Second, it is quite plausible that there are no constantfactor approximation algorithms for many notnonincreasing OWAs. As an example, let us consider the case of families of OWAs with the following structure: their first entries are zeros followed by some nonzero entry at a sufficiently early position. If there were a good approximation algorithm for winner determination under such OWAs, then there would be a good approximation algorithm for the DensestKSubgraph problem, which seems unlikely.
Definition 14.
In a DensestkSubgraph problem we are given an undirected graph and a positive integer . We ask for a subgraph with vertices with the maximal number of edges.
Theorem 15.
Fix some integer ,
Comments
There are no comments yet.