Skip to main content
Springer logoLink to Springer
. 2021 Mar 26;83(5):1559–1603. doi: 10.1007/s00453-020-00794-4

Obtaining a Proportional Allocation by Deleting Items

Britta Dorn 1, Ronald de Haan 2, Ildikó Schlotter 3,
PMCID: PMC8550255  PMID: 34720294

Abstract

We consider the following control problem on fair allocation of indivisible goods. Given a set I of items and a set of agents, each having strict linear preferences over the items, we ask for a minimum subset of the items whose deletion guarantees the existence of a proportional allocation in the remaining instance; we call this problem Proportionality by Item Deletion (PID). Our main result is a polynomial-time algorithm that solves PID for three agents. By contrast, we prove that PID is computationally intractable when the number of agents is unbounded, even if the number k of item deletions allowed is small—we show that the problem is W[3]-hard with respect to the parameter k. Additionally, we provide some tight lower and upper bounds on the complexity of PID when regarded as a function of |I| and k. Considering the possibilities for approximation, we prove a strong inapproximability result for PID. Finally, we also study a variant of the problem where we are given an allocation π in advance as part of the input, and our aim is to delete a minimum number of items such that π is proportional in the remainder; this variant turns out to be NP-hard for six agents, but polynomial-time solvable for two agents, and we show that it is W[2]-hard when parameterized by the number k of

Keywords: Fair division, Proportional allocation, Control, Item deletion, Computational complexity, Parameterized complexity

Introduction

We consider a situation where a set I of indivisible items needs to be allocated to a set N of agents in a way that is perceived as fair. Unfortunately, it may happen that a fair allocation does not exist in a setting. In such situations, we might be interested in the question how our instance can be modified in order to achieve a fair outcome. Naturally, we seek for a modification that is as small as possible. This can be thought of as a control action carried out by a central agency whose task is to find a fair allocation. The computational study of such control problems was first proposed by Bartholdi, III et al. [5] for voting systems; our paper follows the work of Aziz et al. [4] who have recently initiated the systematic study of control problems in the area of fair division.

The idea of fairness can be formalized in various different ways such as proportionality, envy-freeness, or max-min fair share (see the book chapter by Bouveret et al. [6] for an introduction). Here we focus on proportionality, a notion originally defined in a model where agents use utility functions to represent their preferences over items. In that context, an allocation is called proportional if each agent obtains a set of items for which their utility is at least 1/|N| of their total utility of all items. One way to adapt this notion to a model with linear preferences (not using explicit utilities) is to look for an allocation that is proportional with respect to any choice of utility functions for the agents that is compatible with the given linear preferences. Aziz et al. [3] referred to this property as “necessary proportionality”; for simplicity, we use the shorter term “proportionality.” For a survey of other possible notions of proportionality and fairness under linear preferences, we also refer to Aziz et al. [3].

We have several reasons for considering linear preferences. First, the most important advantage of this setting is the easier elicitation of agents’ preferences. In many practical applications, especially with a large number of items, it is unrealistic to assume that agents are able to assign a meaningful cardinal value to each of the items. This may be due to lack of information, e.g., when agents need to declare preferences over items about which they have incomplete knowledge, or an unwillingness to associate a determined value for each item: in scenarios where the usefulness or virtue of an item cannot be simply measured by its monetary value (e.g., students ranking assignments, shared owners of a holiday home ranking time slots, heirs ranking family assets), people may find it much more convenient to express their preferences in an ordinal way, thus reducing their cognitive burden. Besides easier elicitation, it is important to note that it is also easier to visualize ordinal preferences than cardinal ones, which may have significance when we wish to elicit preferences from children or people with impaired cognitive abilities. Hence, ordinal preferences may be more useful in practical applications. From a technical point of view, this simpler model is more tractable in a computational sense: under linear preferences, the existence of a proportional allocation can be decided in polynomial time [3], whereas the same question for cardinal utilities is NP-hard [20]. Since Lipton et al. [20] show the NP-hardness of the problem already for two agents, we do not even have hope for an FPT-algorithm with the number of agents as the parameter. Clearly, if already the existence of a proportional allocation is computationally hard to decide, then we have no hope to solve the corresponding control problem efficiently.

Control actions can take various forms. Aziz et al. [4] mention several possibilities: control by adding/deleting/replacing agents or items in the given instance, or by partitioning the set of agents or items. In this paper we concentrate only on control by item deletion, where the task is to find a subset of the items, as small as possible, whose removal from the instance guarantees the existence of a proportional allocation. In other words, we ask for the maximum number of items that can be allocated to the agents in a proportional way.

Related Work

We follow the research direction proposed by Aziz et al. [4] who initiated the systematic study of control problems in the area of fair division. As an example, Aziz et al. [4] consider the complexity of obtaining envy-freeness by adding or deleting items or agents, assuming linear preferences. They show that adding/deleting a minimum number of items to ensure envy-freeness can be done in polynomial time for two agents, while for three agents it is NP-hard even to decide if an envy-free allocation exists. As a consequence, they obtain NP-hardness also for the control problems where we want to ensure envy-freeness by adding/deleting items in case there are more than two agents, or by adding/deleting agents.

The problem of deleting a minimum number of items to obtain envy-freeness was first studied by Brams et al. [7] who gave a polynomial-time algorithm for the case of two agents.1

In a setting with cardinal utilities, Caragiannis et al. [8] propose a model where items can be donated (i.e., deleted) before allocating the rest to agents; they propose an algorithm that, after deleting a set of items, yields an allocation for the remaining items that is envy-free up to any goods, and whose Nash welfare value is at least half of the optimum. In the context of cake cutting, Segal-Halevi et al. [24] proposed the idea of distributing only a portion of the entire cake in order to obtain an envy-free allocation efficiently.

Looking at the topic in a broader sense, several papers have investigated possible ways to achieve fairness by certain types of control actions. A prominent example is hiding information from agents in order to facilitate a fair allocation. Chen and Shah [10] have found that if agents do not receive any information about the items allocated to others, then the expected amount of envy experienced by the agents typically reduces. Aziz et al. [2] investigated a model where the information that agents obtain on the allocation is based on a graph representing social contacts. Hosseini et al. [18] have proposed an algorithm that eliminates envy through withholding information about a set of few items. Halpern and Shah [16] have also examined the possibilities for overcoming envy by subsidies where agents receive monetary compensation.

For the Hospitals/Residents with Couples problem, Nguyen and Vohra [22] considered yet another type of control action: they obtained stability by slightly perturbing the capacities of hospitals.

Our Contribution

We first consider the case where the number of agents is unbounded (see Sect. 3). We show that the problem of deciding whether there exist at most k items whose deletion allows for a proportional allocation is NP-complete, and that this problem is W[3]-hard with parameter k (see Theorem 2). This latter result shows that even if we allow only a few items to be deleted, we cannot expect an efficient algorithm, since the problem is not fixed-parameter tractable with respect to the parameter k (unless FPT=W[3], which is widely believed not to be the case).

Additionally, we provide tight upper and lower bounds on the complexity of the problem. In Theorem 3 we prove that the trivial |I|O(k) time algorithm—that, in a brute force manner, checks for each subset of I of size at most k whether it is a solution—is essentially optimal (under the widely accepted assumption that FPTW[1]). We provide another simple algorithm in Theorem 4 that has optimal running time, assuming the Exponential Time Hypothesis.

Next, we look at the possibilities of approximation in Sect. 3.1. First we focus on the approximation problem where the objective is to minimize the number k of item deletions, and we provide a strong inapproximability result in Theorem 5 by proving that not even an FPT-algorithm with parameter k can yield a ratio of |I|1-ε for some constant ε>0. Next, we examine the possibilities for maximizing the number of items that agents obtain under a proportional allocation. In Corollary 1, we observe that it is NP-hard to decide if there exists a set of 2|N| items which can be allocated to our set N of agents in a proportional way. Contrasting this result, we propose a simple polynomial-time algorithm in Theorem 6 that allocates one item to each agent proportionally, whenever this is possible.

In Section 4, we turn our attention to the case with only three agents. In Theorem 7 we propose a polynomial-time algorithm for this case, which can be viewed as our main result. The presented algorithm is based on dynamic programming, but relies heavily on a non-trivial insight into the structure of solutions.

Finally, in Sect. 5 we briefly look at the variant of our problem where we are given a fixed allocation in advance, and the task is to decide whether we can make the given allocation proportional by deleting certain items. We prove that this problem is easy for two agents (Theorem 8), but becomes NP-hard for six agents (Theorem 9). The computational intractability persists even if the number of deletions is small, as evidenced by Theorem 10 that proves W[2]-hardness with parameter k for this variant.

Preliminaries and Definitions

In this section, we revisit some technical concepts and notions that we use in the remainder of the paper. We also give a formal definition of the problem of Proportionality by Item Deletion (PID).

(Parameterized) complexity theory We assume the reader to be familiar with basic notions from the theory of computational complexity—in particular, with the complexity classes P and NP, with the notion of polynomial-time algorithms and polynomial-time (many-to-one) reductions, and with the notion of NP-hardness and -completeness. For more details, we refer to textbooks on the topic (see, e.g., the book by Arora and Barak [1]).

We review some basic notions from parameterized complexity theory—for more details, see, e.g., the book by Downey and Fellows [13]. In parameterized complexity theory, in addition to the size |x| of the input x of a problem, one considers a problem parameter k. This parameter is intended to measure some type of structure that is present in the input. The aim then is to obtain fixed-parameter tractable algorithms (or FPT-algorithms), that have running time f(k)·|x|O(1), for some computable function f. This is in contrast with the central notion of tractable algorithms in classical complexity theory: polynomial-time algorithms, i.e., algorithms running in time |x|O(1). The class of all parameterized problems that admit an FPT-algorithm is denoted by FPT.

In addition to the class FPT, parameterized complexity theory features parameterized intractability classes. These are classes containing problems that are considered to be unlikely to have fixed-parameter tractable algorithms. The most prominent examples of such classes are the classes W[t] for t{1,2,3,}. For a formal definition of these classes, we refer to textbooks (e.g., [13] or [15]). It holds that W[1]W[2]W[3], and it is widely believed that FPTW[1].

To give evidence that a problem is not fixed-parameter tractable, one typically uses FPT-reductions to show that the problem is W[t]-hard for some t. If the problem admitted an FPT-algorithm, then this would imply that FPT=W[t]—in other words, under the assumption that FPTW[t], the problem is not fixed-parameter tractable. An FPT-reduction from a parameterized problem Q1 to a parameterized problem Q2 is a function R that takes an input (x, k) of Q1, and produces an input (x,k) of Q2, such that: (i) (x,k)Q1 if and only if (x,k)Q2; (ii) runs in time f(k)·|x|O(1), for some computable function f; and (iii) kg(k), for some fixed computable function g. A problem Q is W[t]-hard for some t, if every problem in W[t] can be FPT-reduced to Q.

Preferences Let N be a set of agents and I a set of indivisible items that we wish to allocate to the agents in some way. We assume that each agent aN has strict preferences over the items, expressed by a preference list La that is a linear ordering of I, and we set L={LaaN}. We call the triple (N, I, L) a (preference) profile. We denote by La[i:j] the subsequence of La containing the items ranked by agent a between the positions i and j, inclusively, for any 1ij|I|. Also, for a subset XI of items we denote by LXa the restriction of La to the items in X.

Proportionality Interestingly, Pruhs and Woeginger [23, Lemma 1] gave an equivalent definition for the concept of proportionality (as described in Sect. 1) that is more direct and practical: we say that an allocation π:IN mapping items to agents is proportional if for any integer i{1,,|I|} and any agent aN, the number of items from La[1:i] allocated to a by π is at least i/|N|. Note that, in particular, this means that in a proportional allocation, each agent needs to get his or her first choice. Another important observation is that a proportional allocation can only exist if the number of items is a multiple of |N|, since each agent needs to obtain at least |I|/|N| items.

Control by deleting items Given a profile P=(N,I,L) and a subset U of items, we can define the preference profile P-U obtained by removing all items in U from I and from all preference lists in L. Let us define the Proportionality by Item Deletion (PID) problem as follows. The input of PID is a pair (P,k) where P=(N,I,L) is a preference profile and k is an integer. We call a set UI of items a solution for P if its removal from I allows for proportionality, that is, if there exists a proportional allocation π:I\UN for P-U. The task in PID is to decide if there exists a solution for P of size at most k. Note that the number of items remaining after the removal of the solution must be a multiple of |N|.

Unbounded Number of Agents

The existence of a proportional allocation can be decided in polynomial time by checking whether a certain bipartite graph corresponding to our instance admits a perfect matching [23, Lemma 4]. Therefore the Proportional Item Deletion problem is solvable in |I|O(k) time by the brute force algorithm that checks for each subset of I of size at most k whether it is a solution. In terms of parameterized complexity, this means that PID parameterized by the solution size k is in XP, i.e., the class of parameterized problems that can be solved in polynomial time for any constant value of the parameter.

Clearly, such a brute force approach may only be feasible if the number k of items we are allowed to delete is very small. Searching for a more efficient algorithm, one might ask whether the problem becomes fixed-parameter tractable with k as the parameter, i.e., whether there exists an algorithm for PID that, for an instance (P,k) runs in time f(k)|P|O(1) for some computable function f. Such an algorithm could be much faster in practice compared to the brute force approach described above.

Unfortunately, the next theorem shows that finding such a fixed-parameter tractable algorithm seems unlikely, as PID is W[2]-hard with parameter k. Hence, deciding whether the deletion of k items can result in a profile admitting a proportional allocation is computationally intractable even for small values of k. (After showing W[2]-hardness, we will show that this result can in fact be strengthened to W[3]-hardness. We present the W[2]-hardness result for two reasons: (1) it is conceptually simpler than the W[3]-hardness proof; and (2) its proof will be useful for showing other lower bounds—namely, Theorems 3 and 5.)

Theorem 1

Proportionality by Item Deletion is NP-complete and W[2]-hard when parameterized by the size k of the desired solution.

Proof

We are going to present an FPT-reduction from the W[2]-hard problem k -Dominating Set, where we are given a graph G=(V,E) and an integer k, and the task is to decide if G contains a dominating set of size at most k; a vertex set DV is dominating in G if each vertex in V is either in D or has a neighbor in D. We denote by N(v) the set of neighbors of some vertex vV, and we let N[v]=N(v){v}. Thus, a vertex set D is dominating if N[v]D holds for each vV.

Let us construct an instance IPID=(P,k) of PID with P=(N,I,L) as follows. We let N contain 3n+2m+1 agents where n=|V| and m=|E|: we create n+1 so-called selection agents s1,,sn+1, and for each vV we create a set Av={avj1j|N[v]|+1} of vertex agents. Next we let I contain 2|N|+k items: we create distinct first-choice items f(a) for each agent aN, a vertex item iv for each vV, a dummy item dvj for each vertex agent avjN, and k+1 additional dummy items c1,,ck+1.

Let F denote the set of all first-choice items, i.e., F={f(a)aN}. For any set UV of vertices in G, let IU={ivvU}; in particular, IV denotes the set of all vertex items.

Before defining the preferences of agents, we need some additional notation. We fix an arbitrary ordering over the items, and for any set X of items we let [X] denote the ordering of X according to . Also, for any aN, we define the set Fia to contain the first i elements of [F\{f(a)}], for any i{1,,|N|-1}. We end preference lists below with the symbol ‘Inline graphic’ meaning all remaining items not listed explicitly, ordered according to .

Now we are ready to define the preference list La for each agent a.

  • If a is a selection agent a=si with 1in-k, then let
    graphic file with name 453_2020_794_Equ19_HTML.gif
  • If a is a selection agent a=si with n-k<in+1, then let
    graphic file with name 453_2020_794_Equ20_HTML.gif
  • If a is a vertex agent a=avj for some vV with 1j|N[v]|+1, then let
    graphic file with name 453_2020_794_Equ21_HTML.gif

This finishes the definition of our PID instance IPID.

Suppose that there exists a solution S of size at most k to IPID and a proportional allocation π mapping the items of I\S to the agents in N. Observe that by |I|=2|N|+k, we know that S must contain exactly k items.

First, we show that S cannot contain any item from F. For contradiction, assume that f(a)S for some agent a. Since the preference list of a starts with more than k items from F (by N-n>n>k), the first item in LI\Sa must be an item f(b) for some bN, ba. The first item in LI\Sb is exactly f(b), and thus any proportional allocation should allocate f(b) to both a and b, a contradiction.

Next, we prove that SIV. For contradiction, assume that S contains less than k items from IV. Then, after the removal of S, the top |N|+1 items in the preference list LI\Ssi of any selection agent si are all contained in IVF. Hence, π must allocate at least two items from IVF to si, by the definition of proportionality. Recall that for any agent a, π allocates f(a) to a, meaning that π would need to distribute the n items in IV among the n+1 selection agents, a contradiction. Hence, we have SIV.

We claim that the k vertices D={vivS} form a dominating set in G. Let us fix a vertex vV. For sake of contradiction, assume that N[v]D=, and consider any vertex agent a in Av. Then the top |N|+1 items in LI\Sa are the same as the top |N|+1 items in La=LIa (using that SF=), and these items form a subset of IN[v]F for every aAv. But then arguing as above, we get that π would need to allocate an item of IN[v] to each of the |N[v]|+1 vertex agents in Av; again a contradiction. Hence, we get that N[v]D for each vV, showing that D is indeed a dominating set of size k.

For the other direction, let D be a dominating set of size k in G, and let S denote the set of k vertex items {ivvD}. To prove that S is a solution for IPID, we define a proportional allocation π in the instance obtained by removing S. First, for each selection agent si with 1in-k, we let π allocate f(si) and the ith item from IV\D to si . Second, for each selection agent sn-k+i with 1ik+1, we let π allocate f(sn-k+i) and the dummy item ci to sn-k+i. Third, π allocates the items f(avj) and dvj to each vertex agent avjN.

It is straightforward to check that π is indeed proportional.

For proving NP-completeness, observe that the presented FPT-reduction is a polynomial-time reduction as well, so the NP-hardness of Dominating Set implies that PID is NP-hard as well; since for any subset of the items we can verify in polynomial time whether it yields a solution, containment in NP follows.

As mentioned above, we can in fact strengthen the W[2]-hardness result of Theorem 1 and show that PID is even W[3]-hard with respect to parameter k.

Theorem 2

Proportionality by Item Deletion is W[3]-hard when parameterized by the size k of the desired solution.

Proof

We are going to present an FPT-reduction from the W[3]-hard wcs-[3] problem, which is the weighted satisfiability problem for formulas of the form φ=i=1m1j=1m2,i=1m3,i,jli,j,, where each li,j, is a negative literal [14, Theorem 4.13] (see also [11, 15]). Let (φ,k) be an instance of the weighted satisfiability problem, where φ is a formula of the form described above; the task in wcs-[3] is to decide whether there is a truth assignment of weight k that satisfies φ. Let X={x1,,xn} be the set of variables occurring in φ— that is, n denotes the number of variables in φ. We will construct an instance IPID=(P,k) of PID with P=(N,I,L) as follows. We let N contain n+1+i=1m1m2,i agents: we create n+1 so-called selection agents s1,,sn+1, and for each 1im1 we create a set Ai={aij1jm2,i} of verification agents. Next we let I contain 2|N|+k items: we create distinct first-choice items f(a) for each agent aN, a variable item wu for each 1un, m2,i verification items yi,1,,yi,m2,i for each 1im1, and k+1 dummy items c1,,ck+1.

Let F denote the set of all first-choice items, i.e., F={f(a)aN}. For any subset XX of variables, let WX={wuxuX}; in particular, WX denotes the set of all variable items.

Before defining the preferences of agents, we need the additional notation used also in the proof of Theorem 1. We fix an arbitrary ordering over the items, and for any set Z of items we let [Z] denote the ordering of Z according to . Also, for any aN, we define the set Fia to contain the first i elements of [F\{f(a)}], for any i{1,,|N|-1}. Moreover, for any 1im1 we define the sets Yi={yi,1,,yi,m2,i} and Yi={yi,1,,yi,m2,i-1}. We end preference lists below with the symbol ‘Inline graphic’ meaning all remaining items not listed explicitly, ordered according to .

Now we are ready to define the preference list La for each agent a.

  • If a is a selection agent a=si with 1in-k, then let
    graphic file with name 453_2020_794_Equ22_HTML.gif
  • If a is a selection agent a=si with n-k<in+1, then let
    graphic file with name 453_2020_794_Equ23_HTML.gif
  • If a is a verification agent a=aij for 1im1 and 1jm2,i, then let
    graphic file with name 453_2020_794_Equ24_HTML.gif
    where Ci,j=X\{xXli,j,=¬xfor some1m3,i,j} is the set of variables that do not occur in any literal li,j,, for 1m3,i,j.

This finishes the definition of our PID instance IPID.

Suppose that there exists a solution S of size at most k to IPID and a proportional allocation π mapping the items of I\S to the agents in N. Observe that by |I|=2|N|+k, we know that S must contain exactly k items.

First, we show that S cannot contain any item from F. To derive a contradiction, assume that f(a)S for some agent a. We can safely assume that |N|-n>k and that |N|-n>m2,i for each 1im1. As a result, the preference list of a starts with more than k items from F. Therefore, the first item in LI\Sa must be an item f(b) for some bN, ba. Clearly, the first item in LI\Sb is exactly f(b), which means that any proportional allocation should allocate f(b) to both a and b, which is a contradiction.

Next, we prove that SWX. To derive a contradiction, assume that S contains less than k items from WX. Then, after the removal of S, the top |N|+1 items in the preference list LI\Ssi of any selection agent si are all contained in WXF. Hence, π must allocate at least two items from WXF to each si, by the definition of proportionality. Recall that for any agent a, π allocates f(a) to a, meaning that π would need to distribute the n items in WX among the n+1 selection agents, which is a contradiction. Hence, we have SWX. We also get that π must allocate all items in WX\S{c1,,ck+1} to the selection agents.

Consider the truth assignment α:X{0,1} defined by letting α(xu)=1 if and only if wuS, for each xuX. Since |S|=k, the truth assignment α has weight k. We show that α satisfies φ. To do so, we need to show that for each 1im1 it holds that α satisfies φi=j=1m2,i=1m3,i,jli,j,. Take an arbitrary 1im1. To derive a contradiction, assume that for each 1jm2,i it holds that there is some 1m3,i,j such that li,j, is made false by α. Then for each such 1jm2,i it holds that |WCi,jS|<k. Then for each verification agent aij, for 1jm2,i it holds that the top |N|+1 items in LI\Sa (for a=aij) form a subset of YiWXF. Then arguing as above, we get that π would need to allocate an item of Yi to each of the |Yi|=|Yi|+1 agents aij, which is a contradiction. Since i was arbitrary, we can conclude that α satisfies φ.

For the other direction, let α:X{0,1} be a truth assignment of weight k that satisfies φ, and let S denote the set of k variable items {wuxuX,α(xu)=1}. To prove that S is a solution for IPID, we define a proportional allocation π in the instance obtained by removing S. First, for each selection agent si with 1in-k, we let π allocate f(si) and the ith item from WX\S to si. Second, for each selection agent sn-k+i with 1ik+1, we let π allocate f(sn-k+i) and the dummy item ci to sn-k+i. Then, for each 1im1, let 1jim2,i be some number such that α makes =1m3,i,jili,ji, true—we know that such a ji exists for each i because α satisfies φ. For each verification agent aij we let π allocate f(aij) and one item from Yi to aij as follows. If j=ji, we let π allocate yi,m2,i to aij; if j<ji, we let π allocate yi,j to aij; and if j>ji, we let π allocate yi,j-1 to aij. It is straightforward to check that π is indeed proportional.

Theorem 2 implies that we cannot expect an FPT-algorithm for PID with respect to the parameter k, the number of item deletions allowed, unless FPTW[3]. Next we show that the brute force algorithm that runs in |I|O(k) time is optimal, assuming the slightly stronger assumption FPTW[1].

Theorem 3

There is no algorithm for PID that on an instance (P,k) with item set I runs in f(k)|I|o(k)|P|O(1) time for some function f, unless FPTW[1].2

Proof

Chen et al. [9] introduced the class of Wl[2]-hard problems based on the notion of linear FPT-reductions. They proved that Dominating Set is Wl[2]-hard, and that this implies a strong lower bound on its complexity: unless FPTW[1], Dominating Set cannot be solved in f(k)|V|o(k)(|V|+|E|)O(1) time for any function f, where (V, E) is the input graph and k is the size of the desired dominating set.

Observe that in the FPT-reduction presented in the proof of Theorem 1, the new parameter has linear dependence on the original parameter (in fact they coincide). Therefore, this reduction is a linear FPT-reduction, and consequentially, PID is Wl[2]-hard. Hence, as proved by Chen et al. [9], PID on an instance (P,k) with item set I cannot be solved in time f(k)|I|o(k)|P|O(1) time for any function f, unless FPTW[1].

If we want to optimize the running time not with respect to the number k of allowed deletions but rather in terms of the total number of items, then we can also give the following tight complexity result, under the Exponential Time Hypothesis (ETH). This hypothesis, formulated in the seminal paper by Impagliazzo, Paturi, and Zane [19] says that 3-Sat cannot be solved in 2o(n) time, where n is the number of variables in the 3-CNF formula given as input.

Theorem 4

PID can be solved in O(2|I|)·|I|O(1) time, but unless the ETH fails, it cannot be solved in 2o(|I|) time, where I is the set of items in the input.

Proof

To show that PID can be solved in O(2|I|)·|I|O(1) time, it suffices to consider the brute force algorithm that iterates over all possible subsets of items to delete, and for each such subset computes whether deleting it enables a proportional allocation (using polynomial-time matching techniques as described by Pruhs and Woeginger [23]). This algorithm runs in time O(2|I|)·|I|O(1).

Next, we show that PID cannot be solved in 2o(|I|) time, unless the ETH fails. The so-called Sparsification Lemma proved by Impagliazzo et al. [19] implies that assuming the ETH, 3-Sat cannot be solved in 2o(m) time, where m is the number of clauses in the 3-CNF formula given as input. Since the standard reduction from 3-Sat to Dominating Set transforms a 3-CNF formula with n variables and m clauses into an instance (G, n) of Dominating Set such that the graph G has O(m) vertices and maximum degree 3 (see, e.g., [25]), it follows that Dominating Set on a graph (V, E) cannot be solved in 2o(|V|) time even on graphs having maximum degree 3, unless the ETH fails.

Recall that the reduction presented in the proof of Theorem 1 computes from each instance (G, k) of Dominating Set with G=(V,E) an instance (P,k) of PID where the number of items is 3|V|+2|E|+1. Hence, assumming that our input graph G has maximum degree 3, we obtain |I|=O(|V|) for the set I of items in P. Therefore, an algorithm for PID running in 2o(|I|) time would yield an algorithm for Dominating Set running in 2o(|V|) time on graphs of maximum degree 3, contradicting the ETH.

Approximating PID

In view of the intractability results we have encountered sofar, it is natural to ask whether an efficient approximation might exist for PID. For some value c1, we say that an algorithm A is an approximation for PID with ratio c if, for any instance (P,k) of PID, A either returns a solution for P containing at most c·k items, or correctly concludes that there is no solution for P of size k.

Unfortunately, the proof of Theorem 1 implies that we cannot hope for an efficient approximation algorithm. Even if we do not aim for a constant-factor approximation, that is, for a ratio c for some constant c, but allow for a ratio |I|1-ε for some fixed ε>0, we cannot expect an efficient algorithm.

Theorem 5

Let ε>0 be a constant. If FPTW[2], then there is no algorithm that, given an instance (P,k) of PID with item set I, yields an approximation for PID with ratio |I|1-ε and runs in FPT time with parameter k.

Proof

Let us suppose that A is an algorithm as described in the statement of the theorem. We are going to use A to give an FPT-algorithm for the W[2]-hard Dominating Set problem, implying FPT=W[2].

Let (G, k) be our instance of Dominating Set, and let n and m denote the number of vertices and edges in G, respectively. We first apply the reduction given in the proof of Theorem 1; let (P,k) be the constructed instance of PID with P=(N,I,L). Recall that |N|=3n+2m+1 and |I|=2|N|+k. We distinguish between two cases, depending on the relationship between |N| and k; recall that ε is a positive constant.

First, if |N|<31-εε·k1ε, then we apply the brute force algorithm for Dominating Set that selects k vertices in every possible way and checks whether they form a dominating set. By n<|N|, this approach takes

nkO(n+m)31-εε·k1εkO(n+m)

time, which is fixed-parameter tractable with parameter k.

Second, assume 31-εε·k1ε|N|. In this case, we apply algorithm A, which either correctly concludes that there does not exist a solution of size k for P, or returns a solution S of size at most |I|1-εk. Observe that by |I|=2|N|+k we have

|S||I|1-εk(3|N|)1-εk=|N|1-ε·31-εk|N|1-ε·|N|ε=|N|

where the last inequality follows from our assumption on |N|.

Recall that P-S must contain a number of items that is a multiple of |N|, as otherwise no proportional allocation may exist for P-S. Hence, |S|kmod|N|, and thus |S||N| implies that S must be a solution of size k. Hence, A either finds a solution of size k for P, or reports that no such solution exists. By the correctness of our reduction, a solution of size k for P implies the existence of a dominating set of size k for G (in the proof of Theorem 1 we actually determined such a set). Since A is an FPT-algorithm with parameter k, the presented algorithm for Dominating Set is also FPT with parameter k.

Inspecting the proof of Theorem 5, one can observe that the necessity of finding a solution such that the number of remaining items is a multiple of |N| seems to be a major impediment when considering approximation for PID. This led us to ask a different question: instead of approximating the size of the solution, is it perhaps possible to approximate the number of items that each agent ends up with in a proportional allocation? More formally, our task is the following: given a profile P and some integer c, determine a set U of items with |U|=c|N| such that U can be proportionally allocated to the set N of agents (i.e., such that P-(I\U) admits a proportional allocation).

Looking into the proofs of Theorems 1 and 2, we can immediately observe that the case c=2, that is, finding 2|N| items (yielding two items for each agent) for which a proportional allocation exists, is already computationally intractable.

Corollary 1

Given a profile P with a set N of agents and a set I of items, it is NP-hard to decide whether there exists a set of 2|N| items which can be proportionally allocated to the agents of N.

We remark that Corollary 1 directly implies that it is NP-hard to approximate the number of items each agent obtains in a proportional allocation with a ratio better than 12.

By contrast, there is a simple algorithm to decide whether we can find one item for each agent in a proportional way.

Theorem 6

There exists an algorithm that given a profile P=(N,I,L) determines in polynomial time a set U of |N| items that can be proportionally allocated to the agents of N, whenever such a set U exists.

Proof

Suppose that S is a set of |I|-|N| items such that P-S is solvable. Then, clearly, there cannot be two agents whose first-choice items in P-S coincide. This simple observation leads us to the following algorithm. Starting from P, we repeatedly search for a pair of agents whose first-choice items coincide. If there exist such agents, then we remove their common first-choice item from P (as this item must be contained in S), and proceed with the remaining profile. Whenever we reach a profile such that no two agents’ first-choice items coincide, then we allocate to each agent its first-choice item (and we delete all remaining items).

Since we only delete items from S (except for the deletion of superfluous items performed after an appropriate allocation is found), this algorithm returns a set |N| of items as promised, unless P admits no solution S of size at most |I|-|N|. The running time is clearly polynomial in |P|.

Three Agents

It is known that PID for two agents is solvable in polynomial-time: if there are only two agents, then an allocation is proportional if and only it is envy-free [3]. Since the problem of obtaining an envy-free allocation by item deletion is polynomial-time solvable (in case of two agents) [4, 7], this implies tractability of PID for |N|=2 immediately. In this section, we generalize this result by proving that PID is polynomial-time solvable for three agents.

In what follows, we will assume that our profile P contains three agents, so let N={a,b,c}. In Sect. 4.1, we will define the necessary basic concepts that we will need. Then, in Sect. 4.2 we present a high-level overview of our algorithm. In Section 4.3, we will look at partial solutions and define the notion of branching sets. Finally, in Sect. 4.4, when all necessary notions are in place, we present our algorithm.

Basic Concepts: Prefixes and Minimal Obstructions

We begin by defining a graph representation of our profile P which can be used to determine whether P admits a proportional allocation. The following construction is identical to the one proposed by Pruhs and Woeginger [23, Section 4] and later generalized by Aziz et al. [3, Theorem 6].

Graph underlying a profile Let us define the underlying graph G of our profile P of PID as the following bipartite graph. The vertex set of G consists of the set I of items on the one side, and a set S on the other side, containing all pairs of the form (x, i) where xN is an agent and i{1,,|I|/|N|}. Such pairs are called slots. We can think of the slot (x, i) as the place for the ith item that agent x receives in some allocation. We say that an item is eligible for a slot (x, i), if it is contained in Lx[1:|N|(i-1)+1]. In the graph G, we connect each slot with the items that are eligible for it; see Fig. 1 for an illustration. Observe that any proportional allocation corresponds to a perfect matching in G; for the sake of completeness, we will prove this in Lemma 1.

Fig. 1.

Fig. 1

Illustration for the graph underlying a profile P and its prefix Q. Note that slots (a, 2) and (c, 2) are incomplete in G(Q)

Since our approach to solve PID with three agents is to apply dynamic programming, we need to handle partial instances of PID. Let us define now the basic necessary concepts.

Prefixes For any triple (ia,ib,ic) with 1ia,ib,ic|I| we define a prefix Q=P[ia,ib,ic] of P as the triple (La[1:ia],Lb[1:ib],Lc[1:ic]), listing only the first ia, ib, and ic items in the preference list of agents a, b, and c, respectively. We call (ia,ib,ic) the size of Q and denote it by size(Q).

We say that a prefix Pi=P[ia,ib,ic] is contained in another prefix Pj=P[ja,jb,jc] if jxix for each xN; the containment is strict if jx<ix for some xN. We say that Pi and Pj are intersecting if none of them contains the other; we call the unique largest prefix contained both in Pi and in Pj, i.e., the prefix P[min(ia,ja),min(ib,jb),min(ic,jc)], their intersection, and denote it by PiPj. We may also compare prefixes of different profiles, deciding their relationship (i.e., whether one contains the other, or they intersect) solely based on their sizes.

For some prefix Q=P[ia,ib,ic], let I(Q) denote the set of all items appearing in Q. We define the set of slots appearing in Q as S(Q)={(x,i)1i(ix+2)/3,xN}. We also define the graph G(Q) underlying Q as the subgraph of G where a slot (x,i)S(Q) is adjacent to an item uI(Q) if u appears in Lx[1:ix] and is eligible for (x, i) in G; see Fig. 1 for an illustration. Note that any slot (x, i) where 1i(ix+2)/3 is connected to the same items in G(Q) as in G; we say that such slots are complete in Q. By contrast, if ix1mod3, then the slot (x,(ix+2)/3) is connected to fewer items in G(Q) than in G. Hence, the only slots which may be incomplete are the last slots in Q, that is, the slots (x,(ix+2)/3), xN. See Fig. 1 for an illustration.

Solvability We say that a prefix Q is solvable, if the underlying graph G(Q) has a matching that covers all its complete slots. Hence, a prefix is solvable exactly if there exists an allocation π from I(Q) to N that satisfies the condition of proportionality restricted to each index in Q: for any agent xN and any index i{1,,ix}, the number of items from Lx[1:i] allocated by π to x is at least i/3.

Minimal obstructions We say that a prefix Q is a minimal obstruction, if it is not solvable, but all prefixes strictly contained in Q are solvable. Observe that all slots in a minimal obstruction must be complete. Furthermore, Hall’s Theorem tells us that a minimal obstruction must have exactly one item less than the number of slots, so |I(Q)|=|S(Q)|-1. We will call any prefix Q that is not solvable an obstruction; note that any obstruction that does not strictly contain another obstruction is, indeed, a minimal obstruction in the above sense. See Fig. 2 for an illustration. Lemma 1 shows that a minimal obstruction, if existing, can be found efficiently; Lemma 2 states some useful observations about minimal obstructions.

Fig. 2.

Fig. 2

Illustration depicting a profile P with the graph G(P) (edges incident to the last slots are grey only to help visibility). The matching in G(P) shown in bold is the one found by the algorithm of Lemma 1; observe that there is no augmenting path from (c, 2). The slots reachable in G(P) by alternating paths from slot (c, 2) together with all items eligible for them (as depicted in G(P) by the dashed trapezoid) yield the minimal obstruction Q of straight shape. The boundary of Q is δ(Q)={2,4,5} (emphasized in bold). There are six partial solutions for Q of size at most 2, namely {1}, {4}, {5}, {1,4}, {1,5}, and {4,5}. Each partial solution U is witnessed by an allocation πU showing that Q-U is solvable; in each (partial) preference list for Q-U, we indicated the items allocated by πU to the given agent by underlining them

Lemma 1

Profile P admits a proportional allocation if and only if the underlying graph G contains a perfect matching. Also, in O(|I|3) time we can find either a proportional allocation for P, or a minimal obstruction Q in P.

Proof

We prove this lemma for arbitrary |N|.

First, it is easy to see that any proportional allocation π immediately yields a perfect matching M for G: for each xN and each i{1,,|I|/|N|} (note that |I|/|N|N since π is proportional), we simply put into M the edge connecting slot (x, i) with the ith item p(x,i) received by x; naturally, we rank items received by x according to x’s preferences. The proportionality of π implies that p(x,i) is contained in the top (i-1)|N|+1 items in Lx, and thus is indeed eligible for the slot (x, i).

For the other direction, consider a perfect matching M in G. Then giving each agent x all the items assigned to the slots {(x,i)i{1,,|I|/|N|} by M we obtain a proportional allocation π: for each agent x and index j{1,,|N|}, our allocation π assigns at least j/|N| items to x from Lx[1:j], namely the items matched by M to the slots {(x,i)1ij/|N|}. Since (j/|N|-1)|N|+1j, even the last item eligible for (x,j/|N|) is contained in Lx[1:j], ensuring that π is indeed proportional.

Therefore, we can check whether there exists a proportional allocation for P by finding a maximum matching in the bipartite graph G. Using the Hopcroft–Karp algorithm [17], this takes O(|I|5/2) time, since G has 2|I| vertices. If no perfect matching exists in G, then we can find a minimal obstruction using a variant of the classical augmenting path method that starts from an empty matching, and increases its size by finding augmenting paths one by one. Namely, at each iteration we pick an unmatched starting slot (x, i) for which all slots in {(x,j)xN,1j<i} are already matched, and search for an augmenting path that starts at (x, i).

Suppose that this algorithm stops at an iteration where the starting slot is (x, i), and no augmenting path starts at (x, i) for the current matching M. Let SH be the set of all slots reachable by an alternating path in G from (x, i), and let IH be the set of all items eligible for any slot in SH. It is well known that SH and IH violate Hall’s condition: |IH|<|SH|. Moreover, the slots in SH “induce” a prefix in the sense that there exists a prefix Q with S(Q)=SH. To prove this, it suffices to show that if (y,j)SH and j{1,,j-1}, then (y,j)SH. By our strategy for picking starting slots, we know j<ji, implying that (y,j) is matched by M. Let q be the item assigned to it by M; note that q is eligible for (y, j) as well. To obtain an alternating path from (x, i) to (y,j), we can take any alternating path from (x, i) to (y, j), and append the two-edge path from (y, j) to (y,j) through q. Hence, there indeed exists a prefix Q with S(Q)=SH; we pick such a Q containing only complete slots. Using standard arguments from matching theory, it is straightforward to check that Q is a minimal obstruction.

Each iteration can be performed in O(|I|2) time (e.g., with a BFS), and there are at most |I| steps, so the algorithm runs in O(|I|3) time.

Lemma 2

Let Q=P[ia,ib,ic] be a prefix of P that is a minimal obstruction. Then iaibic1mod3, |I(Q)|=(ia+ib+ic)/3+1, and either

  • (i)

    ia=ib=ic, or

  • (ii)

    ix=iy=iz+3 for some choice of agents x, y, and z with {x,y,z}={a,b,c}.

Moreover, if (ii) holds, then Lx[1:ix] and Ly[1:iy] contain exactly the same item set, namely I(Q).

Proof

First, observe that if ia1mod3, then the set of complete slots is the same in Q as in P[ia-1,ib,ic], contradicting the minimality of Q. Thus, we have ia1mod3, and we get ibic1mod3 analogously.

Second, let us consider the graph G(Q) underlying our prefix. Since Hall’s condition fails for the set S(Q) of (complete) slots but, by minimality, it holds for any proper subset of these slots, we know that

|I(Q)|=|S(Q)|-1=ia+23+ib+23+ic+23-1=ia+ib+ic3+1 1

where the last equality follows from the first claim of the lemma. Let us assume iamax{ib,ic}. Note that if neither (i) nor (ii) holds, then by the maximality of ia and the first claim of the lemma we obtain ia+ib+ic3ia-6, from which (1) implies |I(Q)|ia-1. However, La[1:ia] contains only items from I(Q), which would imply that some item appears twice in La[1:ia], a contradiction.

To see the last claim of the lemma, suppose ia=ib=ic+3. Then (1) implies |I(Q)|=ia=ib, and hence La[1:ia] (and also Lb[1:ib]) must contain each item in I(Q) exactly once.

Based on Lemma 2, we define the shape of a minimal obstruction Q as either straight or slant, depending on whether Q fulfills the conditions (i) or (ii), respectively. More generally, we also say that a prefix has straight or slant shape if it fulfills the respective condition. Furthermore, we define the boundary items of Q, denoted by δ(Q), as the set of all items that appear once or twice (but not three times) in Q. Fig. 2 depicts a minimal obstruction of straight shape, while Fig. 3 shows one of slant shape; both examples indicate the boundary of the minimal obstruction as well.

Fig. 3.

Fig. 3

Illustration depicting a profile P containing a minimal obstruction Q of slant shape. Proportional allocations, where existent, are indicated by underlining. We investigate four partial solutions, {3}, {4}, {5} and {7}, for Q. The boundary of Q is δ(Q)={2,7,x} (emphasized in bold). Deleting either 3, 4, or 7 yields a solution for P, but deleting item 5 does not; we have depicted a minimal obstruction in P-{5}

Lemma 3

Let Q be a prefix of P that is a minimal obstruction. Then the boundary of Q contains at most three items: |δ(Q)|3.

Proof

We make use of Lemma 2. First, if Q has a straight shape, so Q=P[i,i,i] for some index i, then |S(Q)|=i+2. Since Q is a minimal obstruction, by Lemma 2 we get |I(Q)|=i+1. However, each agent’s list within Q contains exactly i items, yielding that there is exactly one position outside Q in each agent’s list where an item of I(Q) occurs. Hence, |δ(Q)|3 follows in this case.

Second, assume that Q has a slant shape, say Q=P[i,i,i-3] for some index i (the two remaining cases are analogous). Then Lemma 2 implies |I(Q)|=i and that both La[1:i] and Lb[1:i] contain all the i items in I(Q), but Lc[1:i-3] misses exactly three items from I(Q). Hence, there are exactly three occurrences of items listed outside Q, each in the list of agent c, meaning |δ(Q)|=3.

High-level Overview of Our Algorithm

Having in place the most basic definitions, we are now able to give an intuition about how our algorithm works. The main idea is to repeatedly find a minimal obstruction, delete certain items from it to render it solvable (i.e., to ensure that the remainder admits a proportional allocation), and then proceed with the modified instance.

However, we are not able to immediately tell which items should be deleted from the current minimal obstruction Q, as such a decision may have consequences later, when we are dealing with subsequent minimal obstructions. Therefore, instead of picking just one solution, we apply a bounded search tree approach: at each minimal obstruction, we perform a branching, and pursue several possible ways to delete a set of items to make Q solvable. To obtain a polynomial-time algorithm, we must bound the size of our search tree; for this we need several ideas.

Bounding the number of branches In order to bound the number of branches that we have to investigate in a branching, we use the important fact stated by Lemma 4 that any minimal solution removes at most two items from a minimal obstruction. This insight is of crucial importance in our algorithm, as it yields a polynomial bound on the number of branches, namely O(|I|2).

Bounding the size of the search tree Although our search tree algorithm has a recursive structure, we apply a dynamic programming technique to limit the number of recursive calls, i.e., the number of nodes in the search tree.

To this end, we define an equivalence relation between partial solutions, corresponding to nodes in the search tree. Intuitively, two partial solutions are equivalent if they can be extended in the same way into a solution. It turns out that we can determine sufficient conditions that guarantee equivalence. These conditions are somewhat technical, but they essentially ensure that two deletions have the same effect with respect to any possible minimal obstruction that may arise later during the run of the algorithm.

These conditions allow us to classify partial solutions into equivalence classes whose number is bounded by a polynomial; this results in a polynomial running time for our algorithm.

Partial Solutions and Branching Sets

Partial solutions For a prefix Q and a set U of items, we define Q-U in the natural way: by deleting all items of U from the (partial) preference lists of the prefix (note that the total length of the preference lists constituting the prefix may decrease). We say that an item set YI(Q) is a partial solution for Q if Q-Y is solvable. See again Fig. 2 or 3 for an example. Observe that for any item set Y we can check whether it is a partial solution for Q by checking whether all complete slots can be covered by a matching in the graph corresponding to Q-Y.

Branching set. To solve PID we will repeatedly apply a branching step: whenever we encounter a minimal obstruction Q, we shall consider several possible partial solutions for Q, and for each partial solution Y we try to find a solution U for P such that UI(Q)=Y. To formalize this idea, we say that a family Y containing partial solutions for a minimal obstruction Q is a branching set for Q, if there exists a solution U of minimum size for the profile P such that UI(Q)Y. Such a set is exactly what we need to build a search tree algorithm for PID.

Lemma 4 shows that we never need to delete more than two items from any minimal obstruction. This will be essential for constructing a branching set.

Lemma 4

Let Q be a minimal obstruction in a profile P, and let U denote an inclusion-wise minimal solution for P. Then |UI(Q)|2.

Proof

Let UQ:=UI(Q), and let us assume |UQ|3 for contradiction. We are going to select a set Y of three items from UQ for which we can prove that U\Y is a solution for P, contradicting the minimality of U.

We rank the items of UQ according to the index of the first slot in which they appear in P: we say that an item u appears at i, if i is the smallest index such that u is eligible for a slot (x, i) for some xN. If there exist three items y1, y2, and y3 in UQ appearing strictly earlier (i.e., at a smaller index) than all other items in UQ, then we let Y={y1,y2,y3}.

Otherwise, we apply the following procedure to choose Y. Let Y1 be the set of items in UQ that appear at the earliest index, say i1. We select y1 from Y1 by favoring items eligible for more than one slot from {(a,i1),(b,i1),(c,i1)}; if there are still several possibilities to choose y1, then we select it arbitrarily. Similarly, let Y2 be the set of earliest appearing items in UQ\{y1}, appearing at some index i2. We pick an item y2 from Y2 by favoring items eligible for more than one slot from {(a,i2),(b,i2),(c,i2)}; again, if there are still several possibilities to choose y2, then we select it arbitrarily. Note that we use the notion of eligibility based on the original preference lists in P.

To choose an item y3 from the set Y3 of the earliest appearing items in UQ\{y1,y2}, we create the profile P3=P-(U\{y1,y2}). If there exists a minimal obstruction in P3 strictly contained in Q, then we fix such a minimal obstruction Q3, and we choose an item y3Y3 eligible for a slot of S(Q3). Otherwise we choose y3 from Y3 arbitrarily. Intuitively, we choose y3 so as to overcome the possible obstructions obtained when putting y1 and y2 back into our instance, and our strategy for this is simply to choose an item lying within any such obstruction. Observe that if the minimal obstruction Q3 exists, then (1) since there is no obstruction strictly contained in Q in the profile P-UQ, there must exist some item in UQ\{y1,y2} that is eligible for some slot in S(Q3); and (2) if u appears earliest in P among all such items, then uY3. To see this, let (x, i) be the first slot in S(Q3) for which u is eligible in P3. By the claim of Lemma 2 on the shape of a minimal obstruction, all slots preceding (x, i) belong to Q3 as well, that is, the prefix P3<i=P3[3i-5,3i-5,3i-5] “induced” by these slots in P3 is contained in Q3. Thus, by our choice of u, we get that P3<i is a prefix of P as well, implying that no item of UQ\{y1,y2} appears earlier in P than u. Hence, uY3, showing that y3 is well-defined.

Setting Y={y1,y2,y3}, we finish our proof by proving that U\Y is a solution for P. For contradiction, suppose that R is a minimal obstruction in P=P-(U\Y).

First, suppose that R contains all items in Y. As U is a solution, the profile R-Y is solvable, and hence contains at least as many items as complete slots. Note that adding the items of Y into the profile R-Y means adding exactly three new items and at most three new complete slots (since each agent’s list contains at most three more items, resulting in at most one extra complete slot per agent). Hence, R has at least as many items as slots, contradicting the assumption that R is a minimal obstruction.

Hence we know that R does not contain all items in Y. By Lemma 2, R is then strictly contained3 in Q, and by the minimality of Q we get that R must contain an item from {y1,y2,y3}. We claim that if R contains yh for some h{2,3}, then it contains all items yj with 1j<h. Since yj appears not later than yh, the only possible way for R to contain yh but not yj would be the following: yj and yh appear at the same slot number i, but R has a slant shape and thus only contains two slots from Si:={(x,i)xN}, missing exactly the (unique) slot where yj appears. However, since R is a minimal obstruction, yh must appear at both remaining slots from Si by the last statement of Lemma 2, which contradicts our choice of yj.

This leaves us with the case when y3 is not contained in R (for y3I(R) would imply YI(R), which we already proved not to be the case). Then R is not only a prefix of P but also of P3. Assume w.l.o.g. that y3 appears at index j in the slot (c, j). Since R is a minimal obstruction in P3 strictly contained in Q, we know that a minimal obstruction Q3 was found when choosing y3, but RQ3. Thus, both R and Q3 are minimal obstructions of slant shape, with R containing the slots (a, j) and (b, j) but not (c, j), and Q3 containing the slot (c, j) and one of (a, j) and (b, j), say (b, j). This means that R=P3[3j-2,3j-2,3j-5] and Q3=P3[3j-5,3j-2,3j-2]. Note also that by the last statement of Lemma 2, we know

LI\(U\{y1,y2})a[1:3j-2]=LI\(U\{y1,y2})b[1:3j-2]=LI\(U\{y1,y2})c[1:3j-2].

This means that P3[3j-2,3j-2,3j-2] contains exactly 3j-2 items.

Observe that deleting {y1,y2} from profile P3[3j-2,3j-2,3j-2] results in a prefix T of P3-{y1,y2}=P-U of size [3j-4,3j-4,3j-4] that contains exactly 3j-4 items. However, S(T) contains 3j-3 complete slots (and 3 incomplete ones). Therefore, P-U contains a prefix that is not solvable, a contradiction finishing the proof.

Lemma 4 implies that simply taking all partial solutions of I(Q) of size 1 or 2 yields a branching set for Q. As an example, the minimal obstruction shown in Fig. 2 admits the branching set {{1},{4},{5},{1,4},{1,5},{4,5}}.

Corollary 2

For any minimal obstruction Q in a profile, a branching set Y for Q of cardinality at most |I(Q)|+|I(Q)|2=O(|I|2) and with maxYY|Y|2 can be constructed in O(|I|4) time.

Proof

By Lemma 4, in order to construct the branching set Y as required, it suffices to check for each YI(Q) of size at most 2 whether Q-Y is solvable. To do so, we first construct the graph G underlying the prefix Q and compute a maximum matching M in G. This can be done in O(|I|5/2) time using the Hopcroft–Karp algorithm, as explained in Lemma 1. Note that since Q is a minimal obstruction, it matches all but one slots in G, so |M|=|S(Q)|-1.

Now, for each YI(Q) with 1|Y|2 we compute the graph GY underlying the prefix Q-Y. Observe that we can obtain GY from G by deleting the items of Y, and adding the necessary edges so that every slot is connected with all items eligible for it. Observe that M yields a matching MY of size at least |M|-2 in GY, which covers at least |M|-5=|S(Q)|-6 complete slots (because at most three slots may have become incomplete in Q-Y). Hence, starting from MY we only need to find a constant number of augmenting paths in order to check whether all complete slots of GY can be covered by a matching. This takes O(|I|2) time, because GY has at most 2|I| vertices, yielding a running time of O(|I|4) in total.

Polynomial-Time Algorithm for PID for Three Agents

Let us now present our algorithm for solving PID on our profile P=(N,I,L).

We are going to build the desired solution step-by-step, iteratively extending an already found partial solution. For a prefix T of P and a partial solution U for T, we call a set EI an extension for (T,U) if E is disjoint from I(T) and EU is a solution for P; we will refer to the set of items in I(T)\U as forbidden w.r.t. (T,U). We propose an algorithm Extend(T,U) that, given a prefix T of P and a partial solution U for T, returns an extension for (T,U) of minimum size if one exists, otherwise returns ‘No’.

Branching set with forbidden items. To address the problem of finding an extension for (T,U), we modify the notion of a branching set accordingly. Given a minimal obstruction Q in some profile P and a set FI(Q) of items, we say that a family Y of partial solutions for Q is a branching set for Q forbidding F, if the following holds: either there exists a solution U for the profile P that is disjoint from F and has minimum size among all such solutions, and moreover, fulfills UI(Q)Y, or P does not admit any solution disjoint from F (in which case Y can be arbitrary).

Lemma 5

There is an algorithm that, given a minimal obstruction Q in a profile and a set FI(Q) of forbidden items, produces a branching set Y forbidding F with maxYY|Y|2 and |Y|=O(|I|2), and runs in time O(|I|4).

Proof

The algorithm given in Corollary 2 can be adapted in a straightforward fashion to take forbidden items into account: it suffices to simply discard in the first place any subset YI(Q) that is not disjoint from F. It is easy to verify that this modification indeed yields an algorithm as desired.

Equivalent partial solutions. We will describe Extend as a recursive algorithm, but in order to ensure that it runs in polynomial time, we need to apply dynamic programming. For this, we need a notion of equivalence: we say that two partial solutions U1 and U2 for T are equivalent if

  1. |U1|=|U2|, and

  2. (T,U1) and (T,U2) admit the same extensions.

See Fig. 4 for an illustration.

Fig. 4.

Fig. 4

An example showing how different partial solutions for minimal obstruction Q can be extended into a solution for profile P. Among all partial solutions, only {1} is a solution for P, deleting any other partial solution leads to a new minimal obstruction. Note that both 4 and 5 are contained in the boundary, while 1 is not; hence, the size of Q-{1} is different from that of Q-{4} or Q-{5} (as can be seen on Fig. 2). This implies that the prefixes (P-{4})[4,1,4] and (P-{5})[4,4,1] have less items than the corresponding prefixes in P-{1} of the same size, ultimately leading to the fact that {1} is a solution for P, while neither {4} nor {5} can be extended into a solution for P (because there exists no partial solution for the minimal obstructions depicted in P-{4} and P-{5} that is disjoint from I(Q)). The list of possible extensions shows that {4} is equivalent with {5}, and all partial solutions of size 2 are equivalent with each other. (We remark that, however, all partial solutions for Q have distinct deficiency patterns, so no two of them are strongly equivalent)

Ideally, whenever we perform a call to Extend with a given input (T,U), we would like to first check whether an equivalent call has already been performed, i.e., whether Extend has been called with an input (T,U) for which U and U are equivalent. However, the above definition of equivalence is computationally hard to handle: there is no easy way to check whether two partial solutions admit the same extensions or not. To overcome this difficulty, we will use a stronger condition that implies equivalence.

Deficiency patterns Consider a solvable prefix Q of P. We let the deficiency of Q, denoted by def(Q), be the value |S(Q)|-|I(Q)|. Note that due to possibly incomplete slots in Q, the deficiency of Q may be positive even if Q is solvable. However, if Q contains only complete slots, then its solvability implies def(Q)0. We define the deficiency pattern of Q, denoted by defpat(Q), as the set of all triples

(size(R),def(QR),I(QR)δ(Q))

where R can be any prefix with a straight or a slant shape that intersects Q. Roughly speaking, the deficiency pattern captures all the information about Q that is relevant for determining whether a given prefix intersecting Q is a minimal obstruction or not. Note that any given value of size(R) can be present in only one triple from the deficiency pattern of Q, because def(QR) and I(QR)δ(Q) only depend on size(R) and Q. See Fig. 5 for an example.

Fig. 5.

Fig. 5

Illustration of deficiency patterns. For the minimal obstruction Q contained in profile P from Fig. 3, we show four partial solutions and the corresponding deficiency patterns. Since Q-{3} and Q-{4} have the same deficiency pattern D1, and neither 3, nor 4 is contained in the boundary δ(Q), we get that {3} and {4} are strongly equivalent partial solutions for Q; by Lemma 6 they are also equivalent. By D1D2 sets {3} and {5} are not strongly equivalent for Q. Since 7δ(Q), set {7} is not strongly equivalent with any other partial solution; nevertheless, {3} and {7} are in fact equivalent with respect to Q: they are both solutions for P and thus admit the extension (recall Fig. 3)

For an intuitive understanding of the role of deficiency patterns, consider a prefix T and a partial solution U for T. In our algorithm, after we have decided on deleting U, we will not delete any further items from I(T); hence, it should not matter which items we have included in U, as long as its deletion leaves us with the same kind of prefix. So suppose that T is a prefix that may or may not become a minimal obstruction after deleting U; clearly we may suppose that R=T-U has a straight or a slant shape (otherwise it is certainly not a minimal obstruction).

In case T-U contains T-U, the only important properties of U are its size and its intersection with the boundary of T: deleting any partial solution U with |U|=|U| that contains the same items from δ(T) as U will leave us with the same number of slots and the same number of items as the deletion of U. (See also Fig. 4 for an example showing why the boundary matters.)

In case T-U=R does not contain T-U but intersects it, all further information necessary to “classify” U is contained in defpat(T-U). Indeed, to calculate the number of items in R, it suffices to know the number of items in the intersection R(T-U) and the number of items that are contained in I(R)\I(T-U). The former can be calculated from the deficiency of R(T-U). For the latter we also need to know which items, among those occurring at positions of R outside T-U, occur also in R(T-U); since such items are necessarily contained in the boundary of T, it suffices to know the set I(R(T-U))δ(T).

Strong equivalence To formalize the above ideas, we call partial solutions U1 and U2 for T strongly equivalent, if

  1. |U1|=|U2|,

  2. U1δ(T)=U2δ(T), and

  3. defpat(T-U1)=defpat(T-U2).

As the name suggests, strong equivalence is a sufficient condition for equivalence.

Lemma 6

If U1 and U2 are strongly equivalent partial solutions for T, then they are equivalent as well.

Proof

Suppose that W is an extension for (T,U1). We need to prove that it is an extension for (T,U2) as well. Clearly, we have WI\I(T), so it suffices to show that P-(U2W) is solvable.

Suppose for contradiction that Q2 is a minimal obstruction in P-(U2W). Let us consider the prefix Q1 of P-(U1W) that has the same size as Q2; such a prefix exists because |U1|=|U2|. In the remainder of the proof, we argue that Q1 is not solvable in P-(U1W), contradicting the assumption that W is an extension for (T,U1) and thus U1W is a solution for P. Note that Q1 and Q2 clearly have the same slots, all of them complete.

Recall that U2 is a partial solution for T, so T-U2 is solvable. Since W is disjoint from I(T), we know that Q2 cannot be contained in T-U2.

First, let us assume that Q2 contains T-U2. In this case, |U1|=|U2| and U1δ(T)=U2δ(T) together immediately imply that Q1 and Q2 contain the same number of items: |I(Q1)|=|I(Q2)|. Hence, we get |I(Q1)|=|I(Q2)|<|S(Q2)|=|S(Q1)|, proving our claim.

Second, let us assume now that Q2 and T-U2 are intersecting, and let their intersection be T2. Similarly, let T1 be the intersection of Q1 and T-U1. Since Q2 is a minimal obstruction and thus has a straight or a slant shape, we know that (size(Q2),def(T2),I(T2)δ(T-U2)) is contained in the deficiency pattern of T-U2. By the third condition of equivalence, the same triple must also be present in the deficiency pattern of T-U1. Hence, T1 must have the same deficiency as T2. By |U1|=|U2| and U1δ(T)=U2δ(T), we know that T-U1 and T-U2 have the same size, and thus T1 has the same size as T2. This implies |I(T1)|=|I(T2)|.

Moreover, we also get I(T2)δ(T-U2)=I(T1)δ(T-U1). Recall that U1δ(T)=U2δ(T) is guaranteed by the second condition of strong equivalence. Hence, adding the items contained in Q2 but not in T increases the size of I(T2) exactly as adding the items contained in Q1 but not in T increases the size of I(T1). Therefore, we can conclude that |I(Q1)|=|I(Q2)|, which again implies that Q1 is not solvable.

Before giving the details of algorithm Extend, we need one more lemma on the relation of prefixes that we consider during the iterative approach of addressing minimal obstructions one-by-one.

Lemma 7

Let Q0 be a minimal obstruction in P-U0 for a set U0I of items, and let T be the largest4 prefix in P for which T-U0=Q0. Let also YI(T)\U0 with 1|Y|2 be a partial solution for T-U0; then U=U0Y is a partial solution for T. Now, let Q be a minimal obstruction in P-U, and let T be the largest prefix of P such that T-U=Q. Then either I(T)I(T), or there does not exist an extension for (T,U).

Proof

First observe that T-U cannot contain T-U, because T-U is solvable, but T-U is a minimal obstruction. Assume now that I(T)I(T). Then clearly, T-U cannot contain T-U either. Hence, T-U must intersect with the minimal obstruction Q=T-U.

Consider agents’ preference lists in the profile P-U and the underlying graph GP-U. We say that two (or three) positions in the preference lists belong to the same slot in GP-U, if they are contained in LI\Ux[i-2:i] for some agent x and index i1mod3. We claim that either

  • (i)

    all positions contained in T-U but not in Q belong to the same slot in GP-U, or conversely,

  • (ii)

    all positions contained in Q but not in T-U belong to the same slot in GP-U.

This claim can be seen by the heavy use of Lemma 2, distinguishing between cases depending on the shapes and positions of Q and Q0; see Fig. 6.

Fig. 6.

Fig. 6

Illustration for the proof of Lemma 7. The shapes of prefixes Q0, Q, and T-U=Q0-Y are depicted with solid, dashed, and dotted lines, respectively. Positions contained in T-U but not in Q are marked by black diamonds, while positions contained in Q but not in T-U are marked by white diamonds

Let us first assume that Q0 has a straight shape, so Q0=(P-U0)[i,i,i] for some index i1mod3. Then by |Y|2 we know that Q0-Y=T-U contains (P-U)[i-3,i-3,i-3] and is contained in (P-U)[i,i,i]. Hence, the only possible way for T-U to intersect Q is for Q to have size [i,i,i-3], [i,i-3,i], or [i-3,i,i]; w.l.o.g. we suppose Q=(P-U)[i,i,i-3]. But then (i) must hold, because any position contained in T-U but not in Q must be a position in LI\Uc[i-2,i].

Let us now assume that Q0 has a slant shape; w.l.o.g. we may assume that Q0=(P-U0)[i,i,i-3] for some index i1mod3. Now, if Q is contained in (P-U)[i-3,i-3,i-3], then (ii) holds, because any position contained in Q but not in Q0-Y=T-U must be a position in LI\Uc[i-4,i-3]. Otherwise, using again |Y|2, the only way for Q to intersect T-U is for Q to have size [i-3,i,i] or [i,i-3,i], and in either case (i) holds. This proves our claim.

Suppose now (i). Let (x, j) be the slot to which all positions contained in T-U but not in Q belong; let I denote the set of items on these positions in T-U. Then

I(T-U)\I(Q)I. 2

Since I contains items of T-U=Q0-Y, we know that they occur on positions belonging to the slot (x, j) in Q0 as well (note that Q0 is a prefix in P-(U\Y) not in P-U). Thus (x,j)S(Q0), but observe that (x,j+1)S(Q0). However, by the minimality of Q0, any item present in a last slot of Q0 occurs at least once more in Q0 (since an item eligible only for (x, j) among all slots in S(Q0) would imply that deleting the positions corresponding to (x, j) from Q0 would yield a prefix with |S(Q0)|-1 slots and at most |I(Q0)|-1 items). Therefore, any item of I occurs at least once more in Q0. By IY=, this implies that any item of I occurs at least once in a position of Q0-Y=T-U that does not belong to (x, j). However, any such position is contained in Q as well, by our assumption (i). Thus II(Q), which by Equality (2) implies =I(T-U)\I(Q)=I(T-U)\I(T-U). This proves I(T)I(T).

Supposing (ii), let (x, j) be the slot to which all positions contained in Q but not in T-U belong; let I denote the set of items on these positions in Q. Then it is clear that (x,j)S(Q) but (x,j+1)S(Q), hence arguing as above, we get that II(T-U). But then I(Q)I(T-U)II(T-U), implying that the minimal obstruction Q in P-U contains only items that are forbidden w.r.t. (T,U). Thus, there cannot exist an extension for (T,U).

Now, we are ready to describe algorithm Extend in detail. Let (T,U) be the input for Extend. Throughout the run of the algorithm, we will store all inputs with which Extend has been computed in a table SolTable, keeping track of the corresponding extensions as well. Initially, we call Extend with input (T,), where T denotes the empty prefix of our input profile P, i.e., P[0,0,0], and we initialize SolTable as empty. For an example of running algorithm Extend on an instance of PID, see Appendix A.

Algorithm Extend(T,U):

Step 0:

Check for strongly equivalent inputs.

For each (T,U) in SolTable, check whether U and U are strongly equivalent with respect to T, and if so, return Extend(T,U).

Step 1:

Check for trivial solution.

Check if P-U is solvable. If so, then return the empty extension , and store the entry (T,U) together with the value in SolTable.

Step 2:

Find a minimal obstruction.

Find a minimal obstruction Q in P-U; recall that P-U is not solvable in this step.

Step 3:

Compute the new prefix.

Let T be the largest prefix of P for which T-U=Q. If I(T)I(T), then return ‘No’, and store the entry (T,U) together with the value ‘No’ in SolTable.

Step 4:

Compute a branching set.

Using Lemma 5, determine a branching set Y for Q forbidding I(T)\U. If Y=, then return ‘No’, and store the entry (T,U) together with the value ‘No’ in SolTable.

Step 5:

Branch.

For each YY, compute EY:=Extend(T,UY).

Step 6:

Find a smallest extension.

Compute a set EY for which |YEY|=minYY|YEY|. Return the set YEY, and store the entry (T,U) together with the extension YEY in SolTable.

Lemma 8

When initially called with input (T,), algorithm Extend is correct, i.e., for any prefix T of P and any partial solution U for T, Extend(T,U) returns a minimum-size extension for (T,U) (if existent).

Proof

Observe that it suffices to prove the claim for those cases when algorithm Extend does not return a solution in Step 0: its correctness in the remaining cases (so when a solution contained in SolTable for a strongly equivalent input is found and returned in Step 0) follows from Lemma 6.

We are going to prove the lemma by induction on |I\U|. Clearly, if |I\U|=0, then P-U is an empty instance, and hence is trivially solvable. Assume now that I\U, and that Extend returns a correct output for any input (T0,U0) with |I\U0|<|I\U|.

First, if the algorithm returns in Step 1, then this is clearly correct.

Second, if it returns ‘No’ in Step 3, then in this case TT, so Extend(T,U) is a recursive call, and hence was called when branching on a branching set. Thus, there exists some YU with 1|Y|2 for which T-(U\Y) is a minimal obstruction Q0. Hence, Lemma 7 can be applied, which implies the correctness of this step.

Third, if the algorithm returns ‘No’ in Step 4 because it finds that the branching set Y forbidding I(T)\U for the minimal obstruction Q is empty, then this, by the definition of a branching set (forbidding I(T)\U) and by the soundness of the algorithm of Lemma 5, means that there is no solution S for P-U disjoint from I(T)\U. But then we also know that there is no solution S for P for which SI(T)=U holds, so there is no extension for (T,U). Hence this step is correct as well.

Therefore, we can assume that the algorithm’s output is YEY for some YY, where EY=Extend(T,UY) and T is the largest profile in P for which T-U=Q. As |I\(UY)|<|I\U| for any YY, the induction hypothesis implies that Extend runs correctly on all inputs (T,UY), YY. Hence, EY is an extension for (T,UY) and so UYEY is a solution for P. Moreover, since EYI(T)= and I(T)I(T) by Step 3, we know that EY is disjoint from I(T). Since Y is contained in a branching set for Q in P-U forbidding I(T)\U, we get that YEY is disjoint from I(T) as well. Thus, YEY is an extension for (T,U).

It remains to argue that if E is an extension for (T,U), then |YEY||E|. Clearly, E is a solution for P-U disjoint from I(T)\U. By the definition of a branching set forbidding I(T)\U and the correctness of Lemma 5, we know that there must exist a solution E for P-U disjoint from I(T)\U and having size |E||E| for which EI(Q)Y. Define Y=EI(Q). Observe that E\Y an extension for (T,UY).

Using again the induction hypothesis, we get that Extend(T,UY) returns an extension EY for (T,UY) of minimum size, so in particular, |EY||E\Y|, implying |YEY||E||E|. Thus, by our choice of Y, we get that the output of Extend(T,U) (that is, YEY) has size at most |E|. This proves our claim. Therefore, we get that if Extend returns an output in Step 6, then this output is correct.

Lemma 8 immediately gives us an algorithm to solve PID: Extend(T,) returns a solution S for P of minimum size; we only have to compare |S| with the desired solution size k.

The next lemma states that Extend gets called polynomially many times.

Lemma 9

Throughout the run of algorithm Extend initially called with input (T,), the table SolTable contains O(|I|7) entries.

Proof

Let us consider table SolTable at a given moment during the course of algorithm Extend, initially called with the input (T,) (and having possibly performed several recursive calls since then). Let us fix a prefix T. We are going to give an upper bound on the maximum cardinality of the family UT of partial solutions U for T for which SolTable contains the entry (T,U).

By Step 0 of algorithm Extend, no two sets in UT are strongly equivalent. Recall that if U1 and U2, both in UT, are not strongly equivalent with respect to T, then either |U1||U2|, or δ(T)U1δ(T)U2, or defpat(T-U1)defpat(T-U2). Let us partition the sets in UT into groups: we put U1 and U2 in the same group, if |U1|=|U2| and δ(T)U1=δ(T)U2.

Examining Steps 2–4 of algorithm Extend, we can observe that if U, then for some YUU of size 1 or 2, the prefix T-(U\YU) is a minimal obstruction QU. Since removing items from a prefix cannot increase the size of its boundary, Lemma 3 implies that the boundary of T-U contains at most 3 items. We get |δ(T)\U|=|δ(T-U)|3, from which it follows that δ(T)U is a subset of δ(T) of size at least |δ(T)|-3. Therefore, the number of different values that δ(T)U can take is O(|I|3). Since any UUT has size at most |I|, we get that there are O(|I|4) groups in UT. Let us fix some group Ug of UT. We are going to show that the number of different deficiency patterns for T-U where UUg is constant.

Recall that the deficiency pattern of T-U consists of triples of the form

(size(R),def(R),I(R)δ(T-U))

where R is some prefix of P-U with a slant or a straight shape, and R is the intersection of T-U and R.

First observe that by the definition of a group, size(T-U1)=size(T-U2) holds for any U1,U2Ug. Let us fix an arbitrary UUg. Since T-U can be obtained by deleting 1 or 2 items from a minimal obstruction, Lemma 2 implies that there can only be a constant number of prefixes R of P-U which intersect T-U and have a slant or a straight shape; in fact, it is not hard to check that the number of such prefixes R is at most 5 for any given T-U. Therefore, the number of values taken by the first coordinate size(R) of any triple in the deficiency pattern of T-U is constant. Since T-U has the same size for any UUg, we also get that these values coincide for any UUg. Hence, we obtain that (A) the total number of values the first coordinate of any triple in the deficiency pattern of T-U for any UUg can take is constant.

Let R be the intersection of T-U and some prefix of straight or slant shape. By definition, R is contained in QU. By |YU|2, there are only a constant number of positions which are contained in QU but not in R. From this both ||I(R)|-|I(QU)||=O(1) and ||S(R)|-|S(QU)||=O(1) follow. As QU is a minimal obstruction, we also have |I(QU)|=|S(QU)|-1, implying that (B) the deficiency def(R)=|S(R)|-|I(R)| can only take a constant number of values too; note that we have an upper bound on |def(R)| that holds for any UUg. Considering that I(R)δ(T-U) is the subset of δ(T-U), and we also know |δ(T-U)|3, we obtain that (C) the set I(R)δ(T-U) can take at most 23 values (again, for all UUg).

Putting together observations (A), (B), and (C), it follows that the number of different deficiency patterns of T-U taken over all UUg is constant. This implies |UT|=O(|I|4). Since there are O(|I|3) prefixes T of P, we arrive at the conclusion that the maximum number of entries in SolTable is O(|I|7).

We are now able to formulate our main theorem, stating that PID is solvable in polynomial time for three agents.

Theorem 7

Proportional Item Deletions for three agents can be solved in time O(|I|11).

Proof

By Lemma 8, we know that algorithm Extend(T,) returns a solution for P of minimum size, solving PID.

To bound the running time of Extend(T,), let us first give a bound on the time necessary for the computations performed by Extend on some input (T,U) when not counting the computations performed in recursive calls. Clearly, Step 0 takes O(|I|) time (assuming we can effectively search within the table SolTable). Steps 1 and 2 can be accomplished in O(|I|3) time, as described in Lemma 1. Step 3 can be accomplished in time O(|I|). Using Lemma 5, Step 4 can be performed in O(|I|4) time. Since the cardinality of the branching set found in Step 4 is O(|I|2), Steps 5 and 6 can be performed in O(|I|3) time. Hence, any call to Extend can be performed in (|I|4) time (when not counting the computations performed in the recursive calls).

Let us distinguish now between two types of recursive calls to Extend: a call Extend(T,U) is regular, if Step 0 does not produce an output during its execution; otherwise we refer to this call as a shadow call. We first give an upper bound for the time spent on regular calls. Note that in each such call, an entry is added to SolTable. By Lemma 9, SolTable contains O(|I|7) entries, and therefore the number of regular calls to Extend is also O(|I|7). This gives us an upper bound of O(|I|11) on the total time spent on regular calls to Extend.

To bound the time spent on shadow calls, observe that each regular call may give rise to at most O(|I|2) shadow calls (and there are no recursive calls performed within a shadow call). Hence, the number of shadow calls is O(|I|9). Since Step 0 takes O(|I|) time, this yields a bound of O(|I|10) for the total time spent on shadow calls. Hence the total running time of Extend(T,) is as claimed.

PID with Fixed Allocation

In this section we investigate a version of PID where an allocation is given in advance, and we want to make this allocation proportional by item deletion. The input of the problem, which we refer to as PID with Fixed Allocation, consists of a preference profile P=(N,I,L), an allocation π:IN, and an integer kN. We call a set SI of items a solution for (P,π), if the restriction of π to I\S is proportional for the profile P-S; the task is to find a solution of size at most k for (P,π).

Since we are given a fixed allocation, the concept of minimal obstruction can be simplified accordingly: we say that agent x becomes envious at index i for some i{1,,|I|}, if the number of items in Lx[1:i] assigned to x by π is less than i/|N|, but for any smaller index j<i the number of items in Lx[1:j] assigned to x by π is at least j/|N|. Clearly, if no agent becomes envious at any index, then our allocation π is proportional.

Our first observation is that PID with Fixed Allocation can be solved in polynomial time if there are only two agents. To show this, we propose an algorithm that we call GreedyDel. Suppose that N contains only two agents. For an agent xN, we denote by x¯ the other agent, i.e., x¯N, xx¯.

Algorithm GreedyDel(P,π,k):

Step 0:

If k<0, then return ‘No’.

Step 1:

If π is proportional for P, then return ‘Yes’.

Step 2:

Perform a greedy deletion:

Let x denote an agent and i an index such that x becomes envious at i. Compute the item s that is the least preferred by agent x¯ among all items of Lx[1:i] assigned to x¯ by π, and call GreedyDel(P-{s},πI\{s},k-1).

Theorem 8

If the number of agents is two, then PID with Fixed Allocation can be solved in polynomial time by algorithm GreedyDel.

Proof

It is easy to see that algorithm GreedyDel can be implemented in quadratic running time. To prove its correctness, let us consider the steps of GreedyDel on our input instance (P,π,k).

Note that Steps 0 and 1 are clearly correct. We claim that the deletion performed in Step 2 is safe in the following sense: if S is a solution for (P,π) and s is the item deleted by the algorithm in Step 2, then there exists a solution S for (P,π) that contains s. Clearly, if this holds, then GreedyDel is correct.

Let x be the agent and i the index for which x becomes envious at i, as found in Step 2. Let S[1:i] denote those items of S that are contained in Lx[1:i]. Suppose that S does not contain the deleted item s. However, since S is a solution, we know that S[1:i] must contain strictly more items assigned by π to x¯ than to x, i.e.,

|S[1:i]π-1(x¯)||S[1:i]π-1(x)|+1. 3

Let s be the item least preferred by x in S[1:i]π-1(x¯). We will show that S=S\{s}{s} is a solution for (P,π), proving our claim that Step 2 is safe.

Note that by our choice of s, agent x¯ prefers s to s, so x¯ cannot become envious at any index in P-S. If x prefers s to s, then x cannot become envious at any index in P-S either (because deleting an item assigned to x¯ that comes before s in Lx is always preferable for x than deleting s), so in this case S is a solution for (P,π). Thus, for the sake of contradiction, assume that x also prefers s to s, and x becomes envious somewhere in P-S. This means that there exists an index j{1,,|I|} such that

|Jx\S|<|Jx¯\S|, 4

where Jx and Jx¯ denote the set of items in Lx[1:j] assigned to x and to x¯ by π, respectively (note that Lx is the preference list of x in the original instance P).

First, if Jx¯ contains either both s and s or neither of them, then |Jx¯S|=|Jx¯S|, so

|Jx\S|=|Jx\S||Jx¯\S|=|Jx¯\S|,

where the first equality is implied by {s,s}Jx=, and the inequality follows from the fact that S is a solution for (P,π). This contradicts (4).

Second, if |Jx¯{s,s}|=1, then sJx¯ but sJx¯, because x prefers s to s. In this case we know j<i. Using that s is the least preferred by x among all items of S[1:i]π-1(x¯) but it still falls within Lx[1:j], we know that all items of S[1:i]π-1(x¯) fall within Lx[1:j] and are thus contained in Jx¯. From this, we get that

|Jx¯S|=|Jx¯S|-1=|S[1:i]π-1(x¯)|-1|S[1:i]π-1(x)||JxS|=|JxS|,

where the first inequality follows from (3). Recall that x only becomes envious at i in P, and therefore |Jx||Jx¯|, leading us to

|Jx\S|=|Jx|-|JxS||Jx¯|-|Jx¯S|=|Jx¯\S|,

which again contradicts (4).

Interestingly, PID with Fixed Allocation becomes NP-hard if the number of agents is 6. Hence, providing an allocation in advance does not seem to make PID much easier; the intuitive argument behind this is that we may be given an allocation that is quite unreasonable and may actually become a hindrance to proportionality instead of helping us. Our results leave open the computational complexity of the problem when the number of agents is in {3,4,5}.

Theorem 9

If the number of agents is six, then PID with Fixed Allocation is NP-complete.

Proof

It is straightforward to see that the problem is in NP. To prove its NP-completeness, we are going to present a reduction from the Cubic Monotone 1-in-3-SAT problem, whose input is a propositional formula φ in conjunctive normal form where variables only occur as positive literals, and the underlying graph G is a cubic graph (i.e., every vertex has degree 3). Formally, we define G=(VC,E) as a bipartite graph whose two partitions are the set V of variables and the set C of clauses, and a variable vV is adjacent to a clause CC in G if and only if v appears in C. Since G is cubic, each variable occurs in exactly three clauses, and conversely, each clause contains exactly three distinct variables. The task in the Cubic Monotone 1-in-3-SAT problem is to decide whether there exists a truth assignment for φ where exactly one out of three variables is true in each clause; we will call such a truth assignment valid. Moore and Robson [21] proved that this problem is NP-hard.

Given the input formula φ, we construct an instance (P,π,k) of PID with Fixed Allocation such that φ is satisfiable if and only if (P,π) admits a solution of size at most k. Let φ contain variables v1,,vn and clauses C1,,Cn; note that n0mod3 must hold, as G is cubic. We define the set of agents as N={v,v,w,w,f,f}. The set I of items contains Vi={ai,bi,ci} and V^i={a^i,b^i,c^i} for each variable viV, as well as a set Ix containing some newly introduced items for each agent xN; we set |If|=3n, |If|=2n, and |Ix|=4n for any other agent xN\{f,f}. We let U=V1Vn and U^=V^1V^n. Items in U and U^ are assigned by π to f and f, respectively, while for any agent xN, items in Ix are assigned to x by π. We set k=3n.

To finish the definition of profile P=(N,I,L), it remains to give the preferences of each agent, for which we need additional notation. The three items in Vi will correspond to the three occurrences of variable vi, each a positive literal, while the items in V^i will correspond to their negated forms. Hence, for each clause CiC, we define Pi as the set of items that, for any j{1,,n}, contains item aj, bj, or cj if and only if Ci contains the first, second, or third occurrence, respectively, of variable vj in φ. We also define Ni as the set of items containing a^j, b^j, or c^j for some j if and only if Pi contains aj, bj, or cj, respectively.

To simplify our notation for the preference lists, we fix an arbitrary ordering over I so that we can omit listing all irrelevant items in the preference lists: the symbol ‘Inline graphic’ at the end of a preference list stands for the sequence of all remaining items according to their order in . Also, we write [X] for a set X of items to denote their sequence according to . In the preference list of some agent xN, it will be sufficient to distinguish between items of D=IvIvIwIw only up to the point of indicating whether they are assigned to x by π or not. Thus, we will use ‘’ symbols in Lx to denote items from Ix, and we will use ‘’ symbols to denote items from D\Ix (these will serve as dummy items). If the number of ‘’ (or ‘’) symbols in Lx is , then they refer to the first items from Ix (or from D\Ix, respectively) according to . Now, the preference lists are as shown in Table 1.

Table 1.

Preferences in the instance of PID with Fixed Allocation constructed in the proof of Theorem 9.

Lv: ,,,,,a1,a^16, ,,,,,b1,b^16, ,,,,,c1,c^16,
,,,,,a2,a^2, ,,,,,b2,b^2, ,,,,,c2,c^2,
,,,,,an,a^n, ,,,,,bn,b^n, ,,,,,cn,c^n, Inline graphic
Lv: ,,,,,cn,c^n, ,,,,,bn,b^n, ,,,,,an,a^n,
,,,,,c2,c^2, ,,,,,b2,b^2, ,,,,,a2,a^2,
,,,,,c1,c^1, ,,,,,b1,b^1, ,,,,,a1,a^1, Inline graphic
Lw: ,,,,,a^1,b1, ,,,,,b^1,c1, ,,,,,c^1,a1,
,,,,,a^2,b2, ,,,,,b^2,c2, ,,,,,c^2,a2,
,,,,,a^n,bn, ,,,,,b^n,cn, ,,,,,c^n,an, Inline graphic
Lw: ,,,,,c^n,an, ,,,,,b^n,cn, ,,,,,a^n,bn,
,,,,,c^2,a2, ,,,,,b^2,c2, ,,,,,a^2,b2,
,,,,,c^1,a1, ,,,,,b^1,c1, ,,,,,a^1,b1, Inline graphic
Lf: ,,,,[P1]6, ,,,,[P2]6,, ,,,,[Pn]6, Inline graphic
Lf: ,,,,,[N1]7, ,,,,,[N2]7,, ,,,,,[Nn]7, Inline graphic

Recall that in a preference list Lx, all ‘’ symbols stand for items in Ix (assigned by π to x), while ‘’ symbols stand for items in D\Ix (assigned by π to some other agent in {v,v,w,w}\{x}). The numbers above braces indicate the length of the given series of items

Notice that we need to make sure that we do not “run out of” the necessary items when using ‘’ symbols: for any agent x, the number of available dummy items is |D\Ix|12n, while Lx contains at most 12n dummies. Hence, P is indeed a profile.

The reduction presented can clearly be computed in polynomial time, so let us prove its correctness. First assume that S is a solution for (P,π) of size at most k. Note that π assigns exactly 4n items to each agent except for f and f, while it assigns 6n and 5n items to f and f, respectively (recall that f receives all 3n items in U^, while f receives all 3n items in U). By k=3n, we get that S contains exactly 2n items of U^If and n items of UIf. In particular, S does not contain any (dummy) item from D.

Fix some agent xN\{f,f}, and consider the first 7j items in the preference list of x for some j{1,,3n}. Observe that Lx[1:7j] contains only j items assigned to x by π. However, π cannot be proportional as long as the set consisting of the first 6j+1 items in x’s preference list contains at most j items assigned to x by π. Hence we know that S must contain at least j items from Lx[1:7j]. Let Qjx denote the set of items in Lx[7j-6:7j] that are not in D and hence may be included in the solution S; e.g., Q1v={a1,a^1}, Q2v={b1,b^1}, and so on. Then our observation for each xN\{f,f} can be written as

|S(Q1xQjx)|j. 5

However, notice that Qjv=Q3n+1-jv and also Qjw=Q3n+1-jw, which implies

|S(Qj+1xQ3nx)|=|S(Q3n-jxQ1x)|3n-j 6

for any xN\{f,f} where we abuse notation by setting v=v and w=w; note that we used Inequality (5) for agent x and index 3n-j. Using that |S|=3n and that the sets Qjx, j{1,,3n}, are mutually disjoint, it is straightforward to verify that Inequalities (5) and (6) can only hold for each value of j{1,,3n} if

|SQjx|=1for everyj{1,,3n}. 7

For agents v and v, (7) implies that uS if and only if u^S for any item uU. Taking into account the statement of (7) for agents w and w, we obtain that either ViS and V^iS=, or V^iS and ViS= for each i{1,,n}.

Let us define a truth assignment α by setting variable viV in φ to true if and only if ViS. We claim that α is valid for φ, i.e., each clause in C contains exactly one variable vi for which ViS.

Considering the first 7j items from the preference list of f for some j{1,,n} and arguing similarly as before, we obtain that

|S(P1Pj)|j. 8

Analogously, from the first 8j items from the preference list of f (among which only j are assigned to f by π), we get

|S(N1Nj)|2j. 9

However, notice that |S(PjNj)|=3 for any j{1,,n}. Hence, Inequalities (8) and (9) imply |SPj|=1 and |SNj|=2 for every j{1,,n}. This means exactly that α is valid for φ.

For the other direction, assume that there exists a valid truth assignment α for φ, and let Tα denote the set of true variables. First observe that |Tα|=n/3 must hold, because each variable appears in exactly three clauses, and there are n clauses. We define a solution S for (P,π) by putting ai, bi, and ci into S for each viTα, and putting a^i, b^i, and c^i into S for each viV\Tα. Hence |SU|=n and |SU^|=2n. Note that Inequality (5) holds for S for any agent xN\{f,f} and index j{1,,3n}. Inequalities (8) and (9) hold as well for any j{1,,n}, due to the validity of α. Based on these facts, it is easy to check that S is indeed a solution for (P,π).

Our next theorem shows that PID with Fixed Allocation remains computationally intractable even if the number of deletions allowed is small.

Theorem 10

PID with Fixed Allocation is W[2]-hard when parameterized by the size k of the desired solution.

Proof

We are going to present an FPT-reduction from the Red-Blue Dominating Set problem. The input of this problem is a bipartite graph G=(V,E) and an integer k, with V partitioned into a set Vred={r1,,rs} of ‘red’ and a set Vblue={b1,,bt} of ‘blue’ vertices. We denote by N(v) the set of neighbors of some vertex vV. The task is to decide if G contains a set DVred of at most k red vertices that dominates all blue vertices, i.e., such that N(bj)D for each bjVblue. Red-Blue Dominating Set is known to be NP-complete and W[2]-complete when parameterized by k [12].

Let us construct an instance I=(P,π,k) of PID with Fixed Allocation. We let P=(N,I,L), and we define the set of agents as N={r^}B^D^ where B^={b^1,,b^t}, and D^={d^1,,d^Δ} contains Δ dummy agents for the smallest integer Δ such that Δ(s-k)|N|=Δ+t+1. We define the set of items as I=VredBD where B={b1i,,bti1is-k} contains s-k copies of each blue vertex, and D={d1i,,dΔi1is-k} contains s-k dummy items for each dummy agent. The allocation π assigns every item of Vred to agent r^, while each agent b^jB^ is assigned items bj1,,bjs-k, and each agent d^jD^ is assigned items dj1,,djs-k.

To define the preferences of agents, we fix an arbitrary ordering over I so that we can omit listing all irrelevant items in the preference lists: the symbol ‘Inline graphic’ at the end of a preference list stands for the sequence of all remaining items according to their order in . Also, we write [X] for a set X of items to denote their sequence according to . Moreover, a series of ‘’ symbols of length denotes the sequence of the first dummy items from D according to . Now, the preference lists are as follows (allocation π is indicated by underlining the items assigned to the given agent x in Lx).

graphic file with name 453_2020_794_Equ25_HTML.gif

Note that the preference list of an agent b^jB^ contains at most |N| dummy items, whose existence is ensured by our choice of Δ.

The presented reduction is clearly a polynomial-time reduction as well as a parameterized one (with k being the parameter in both instances). To prove its correctness, let us first assume that S is a solution of size at most k for (P,π). Note that π assigns s-k items to each agent, except for agent r^ who gets s items. Hence, Sπ-1(r^)=Vred and |S|=k follows. We claim that S dominates all blue vertices in G: indeed, if SN(bj)= for some bjVblue in G, then agent b^j becomes envious at index |N|+1 in P-S, since Lb^j[1:|N|+1] contains only one item assigned to b^j by π, a contradiction.

For the other direction, it is straightforward to verify that any set S of k red vertices that dominates all blue vertices in G yields a solution to (P,π) as well, because if no agent of B^ becomes envious at index |N|+1 in P-S, then π is guaranteed to be proportional in P-S.

Conclusion and Open Questions

In Section 4 we have shown that Proportionality by Item Deletion is polynomial-time solvable if there are only three agents. In comparison, the problem of obtaining an envy-free allocation by item deletion was shown to be polynomial-time solvable for two agents, but becomes NP-hard already for three agents [4]. We have also proved that if the number of agents is unbounded, then PID becomes NP-hard, and practically intractable already when we want to delete only a small number of items, as shown by the W[3]-hardness result of Theorem 2.

The complexity of PID remains open for the case when the number of agents is a constant greater than 3. Is it true that for any constant n, there exists a polynomial-time algorithm that solves PID in polynomial time for n agents? The reason why our algorithm is not directly applicable for more than three agents is that Lemma 4 relies heavily on the properties of minimal obstructions observed in Lemma 2; these properties imply a very strict structure for two properly intersecting minimal obstructions. For the case of more than three agents, there are more possibilities how minimal obstructions may properly intersect, and so we cannot obtain a variant of Lemma 4 for n4: it is an open question whether for n4 it holds that any inclusion-wise minimal solution S contains at most n-1 items from a minimal obstruction Q. In fact, it is not even known whether there is a bound f(n) on the number of items in SI(Q) for some function f; we believe that establishing such a bound would imply the existence of a polynomial-time algorithm for PID for any constant n.

Supposing that there does exist a polynomial-time algorithm for PID for any constant n, can we find an FPT-algorithm with respect to the parameter n? If not—that is, if PID turns out to be NP-hard for some constant number of agents—then can we at least give an FPT-algorithm with parameter k for a constant number of agents (or maybe with combined parameter (k, n))?

Since approximation seems hopeless w.r.t. the number of deletions, it may be interesting to see whether there might exist an approximation w.r.t. the number of items obtained by each agent in a proportional way. Our results from Corollary 1 and Theorem 1 show that we cannot get a polynomial-time approximation with a ratio better than 2. Is this lower bound sharp?

Regarding PID with Fixed Allocation, we gave a polynomial-time algorithm for n=2, but proved the problem to be NP-complete for n=6. This leaves open the case when the number of agents is in {3,4,5}; it would be interesting to close the gap.

Finally, there is ample space for future research if we consider different control actions (such as adding or replacing items), different notions of fairness, or different models for agents’ preferences.

Acknowledgements

We would like to thank the anonymous reviewers of this paper for their valuable advice and great questions.

Appendix A Example for Running Algorithm Extend

In this section we show how the algorithm runs on a profile P with agents a, b, and c ranking the item set {1,2,,9,x,y,z,v,u} as below:

ProfileP:a:1,2,3,6,4,7,8,9,y,x,z,v,5,u.b:2,1,5,3,4,8,6,x,7,y,z,u,9,v.c:3,4,6,2,5,7,1,x,8,y,z,9,v,u.

At each step, we will only indicate Step 0, Step 1, or Step 3 if it leads to an output. If not, then we give the minimal obstruction Q and the branching set Y computed in Steps 2 and 4. The numbering of the calls reflects how the algorithm performs the recursive calls in Step 5; Fig. 7 depicts the search tree traversed by the algorithm. Table 2 shows the content of SolTable. Sometimes, in order to omit details and avoid tedium, we will shorten the description of a call.

Fig. 7.

Fig. 7

Illustration for the search tree traversed by algorithm Extend on the example of Appendix A. Black arrows indicate a recursive call, while blue dashed arrows indicate strong equivalence (pointing towards the earlier call)

Table 2.

The contents of SolTable as a result of running Extend(T,) on the example of Appendix A. The entries appear according to the order in which the algorithm stores them

Prefix Partial solution Extension
P[6,11,11] {3,4,x,y,z}
P[6,10,10] {3,4,x,y} {z}
P[6,9,9] {3,4,x} {y,z}
P[7,7,7] {3,4} {x,y,z}
P[14,12,6] {3,5,x,y,z,9,v,u}
P[12,6,13] {3,5,x,y,z,9,v} {u}
P[8,6,12] {3,5,x,y,z,9} {v,u}
P[5,11,11] {3,5,x,y,z} {9,v,u}
P[5,10,10] {3,5,x,y} {z,9,v,u}
P[5,9,9] {3,5,x} {y,z,9,v,u}
P[7,7,7] {3,5} {x,y,z,9,v,u}
P[11,11,11] {7,y}
P[14,12,8] {7,9,z,v,u}
P[13,7,13] {7,9,z,v} {u}
P[11,11,11] {7,9,z} {v,u}
P[14,13,8] {7,y,z,v,u}
P[13,7,13] {7,y,z,v} {u}
P[11,11,11] {7,y,z} {v,u}
P[7,7,7] {7} {y}
P[7,7,7] {8} {y}
P[4,11,11] {7,8,x,y,z,}
P[4,10,10] {7,8,x,y} {z}
P[4,9,9] {7,8,x} {y,z}
P[7,7,7] {7,8} {x,y,z}
P[0,0,0] {7,y}

graphic file with name 453_2020_794_Figa_HTML.jpg

graphic file with name 453_2020_794_Figb_HTML.jpg

graphic file with name 453_2020_794_Figc_HTML.jpg

Funding

Open access funding provided by Budapest University of Technology and Economics.

Footnotes

1

For a complete proof of the correctness of their algorithm, see also the work by Aziz et al. [4].

2

Here, we use an effective variant of “little o” (see, e.g. Flum and Grohe [15, Definition 3.22]).

3

Seemingly it may be incorrect to say that R is contained in Q because R is a prefix of P while Q is a prefix of P; however, recall that the definition of containment only depends on the notion of size.

4

If T1-U0=T2-U0=Q, then (T1T2)-U0=Q also holds (where the union of T1 and T2 is the unique smallest prefix containing both); hence, T is well defined.

R. d. Haan: Supported by the Austrian Science Fund (FWF), project J4047.

I. Schlotter: Research supported by the Hungarian Academy of Sciences under its Momentum Programme (LP2016-3/2018), and the Hungarian Scientific Research Fund (OTKA grants K128611 and K124171)

Publisher's Note

Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

Change history

6/8/2021

The original article has been corrected: Open access funding information added.

Contributor Information

Britta Dorn, Email: britta.dorn@uni-tuebingen.de.

Ronald de Haan, Email: me@ronalddehaan.eu.

Ildikó Schlotter, Email: ildi@cs.bme.hu.

References

  • 1.Arora S, Barak B. Computational Complexity - A Modern Approach. Cambridge: Cambridge University Press; 2009. [Google Scholar]
  • 2.Aziz, H., Bouveret, S., Caragiannis, I., Giagkousi, I., Lang, J.: Knowledge, fairness, and social constraints. In Proceedings of the 32nd AAAI Conference on Artificial Intelligence (AAAI 2018), pages 4638–4645, New Orleans, Louisiana, United States, (2018)
  • 3.Aziz H, Gaspers S, Mackenzie S, Walsh T. Fair assignment of indivisible objects under ordinal preferences. Artif. Intel. 2015;227:71–92. doi: 10.1016/j.artint.2015.06.002. [DOI] [Google Scholar]
  • 4.Aziz, H., Schlotter, I., Walsh, T.: Control of fair division. In Proceedings of the 25th International Joint Conference on Artificial Intelligence (IJCAI 2016), pages 67–73, (2016)
  • 5.Bartholdi JJ, III, Tovey CA, Trick MA. How hard is it to control an election? Mathemat. Comp. Modelling. 1992;16(8–9):27–40. doi: 10.1016/0895-7177(92)90085-Y. [DOI] [Google Scholar]
  • 6.Bouveret, S., Chevaleyre, Y., Maudet, N.: Fair allocation of indivisible goods. In F. Brandt, V. Conitzer, U. Endriss, J. Lang, and A. D. Procaccia, editors, Handbook of Computational Social Choice, pages 284–310. Cambridge University Press, (2016)
  • 7.Brams SJ, Kilgour DM, Klamler C. Two-person fair division of indivisible items: An efficient, envy-free algorithm. Notic. American Mathemat. Soc. 2014;61(2):130–141. doi: 10.1090/noti1075. [DOI] [Google Scholar]
  • 8.Caragiannis, I., Gravin, N., Huang, X.: Envy-freeness up to any item with high nash welfare: The virtue of donating items. In Proceedings of the 2019 ACM Conference on Economics and Computation (EC 2019), page 527–545, New York, NY, USA, 2019. ACM (2019)
  • 9.Chen J, Huang X, Kanj IA, Xia G. Strong computational lower bounds via parameterized complexity. J. Comp. Sys. Sci. 2006;72(8):1346–1367. doi: 10.1016/j.jcss.2006.04.007. [DOI] [Google Scholar]
  • 10.Chen, Y., Shah, N.: Ignorance is often bliss: Envy with incomplete information, 2017. Working paper (2017)
  • 11.Downey RG, Fellows MR. Fixed-parameter tractability and completeness I: Basic results. SIAM J. Comp. 1995;24(4):873–921. doi: 10.1137/S0097539792228228. [DOI] [Google Scholar]
  • 12.Downey RG, Fellows MR. Parameterized Complexity. New York: Springer; 1999. [Google Scholar]
  • 13.Downey RG, Fellows MR. Fundamentals of parameterized complexity. London: Springer; 2013. [Google Scholar]
  • 14.Flum J, Grohe M. Model-checking problems as a basis for parameterized intractability. Logic. Methods . Comp. Sci. 2005;1(1:2):1–36. [Google Scholar]
  • 15.Flum, J., Grohe, M.: Parameterized Complexity Theory. Texts in Theoretical Computer Science, vol. XIV. An EATCS Series. Springer Verlag, Berlin (2006)
  • 16.Halpern, D., Shah, N.: Fair division with subsidy. In : D. Fotakis and E. Markakis, editors, Proceedings of the 12th International Symposium on Algorithmic Game Theory (SAGT 2019), Lecture Notes in Computer Science, pp. 374–389. Springer, New york (2019)
  • 17.Hopcroft JE, Karp RM. An n5/2 algorithm for maximum matchings in bipartite graphs. SIAM Journal on Computing. 1973;2(4):225–231. doi: 10.1137/0202019. [DOI] [Google Scholar]
  • 18.Hosseini, H., Sikdar, S., Vaish, R., Wang, H., Xia, L.: Fair division through information withholding. In The 34th AAAI Conference on Artificial Intelligence (AAAI 2020), pages 2014–2021. AAAI Press, (2020)
  • 19.Impagliazzo R, Paturi R, Zane F. Which problems have strongly exponential complexity? J. Comp. Sys. Sci. 2001;63(4):512–530. doi: 10.1006/jcss.2001.1774. [DOI] [Google Scholar]
  • 20.Lipton, R.J., Markakis, E., Mossel, E., Saberi, A.: On approximately fair allocations of indivisible goods. In EC 2004: Proc. of the 5th ACM Conference on Electronic Commerce, pages 125–131, (2004)
  • 21.Moore C, Robson JM. Hard tiling problems with simple tiles. Discret. Comput. Geom. 2001;26(4):573–590. doi: 10.1007/s00454-001-0047-6. [DOI] [Google Scholar]
  • 22.Nguyen, T., Vohra, R.: Near feasible stable matchings. In Proceedings of the Sixteenth ACM Conference on Economics and Computation (EC 2015), pages 41–42, (2015)
  • 23.Pruhs, K.R., Woeginger, G.J.: Divorcing made easy. In E. Kranakis, D. Krizanc, and F. Luccio, editors, Proceedings of the 6th International conference on Fun with Algorithms (FUN 2012), volume 7288 of LNCS, pages 305–314. Springer, (2012)
  • 24.Segal-Halevi, E., Hassidim, A., Aumann, Y.: Waste makes haste: Bounded time protocols for envy-free cake cutting with free disposal. In AAMAS 2014: In Proc. of the 14th International Conference on Autonomous Agents and Multi-Agent Systems, pages 901–908, (2015)
  • 25.Thulasiraman, K., Arumugam, S., Brandstädt, A., Nishizeki, T.: Handbook of Graph Theory, Combinatorial Optimization, and Algorithms. CRC Press, Chapman & Hall/CRC Computer and Information Science Series (2015)

Articles from Algorithmica are provided here courtesy of Springer

RESOURCES