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 -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 -hard for six agents, but polynomial-time solvable for two agents, and we show that it is -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 -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 , 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 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 ). 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 for some constant . 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 -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 -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 -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 and , with the notion of polynomial-time algorithms and polynomial-time (many-to-one) reductions, and with the notion of -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 , 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 . The class of all parameterized problems that admit an FPT-algorithm is denoted by .
In addition to the class , 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 for . For a formal definition of these classes, we refer to textbooks (e.g., [13] or [15]). It holds that , and it is widely believed that .
To give evidence that a problem is not fixed-parameter tractable, one typically uses FPT-reductions to show that the problem is -hard for some t. If the problem admitted an FPT-algorithm, then this would imply that —in other words, under the assumption that , the problem is not fixed-parameter tractable. An FPT-reduction from a parameterized problem to a parameterized problem is a function R that takes an input (x, k) of , and produces an input of , such that: (i) if and only if ; (ii) runs in time , for some computable function f; and (iii) , for some fixed computable function g. A problem Q is -hard for some t, if every problem in 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 has strict preferences over the items, expressed by a preference list that is a linear ordering of I, and we set . We call the triple (N, I, L) a (preference) profile. We denote by the subsequence of containing the items ranked by agent a between the positions i and j, inclusively, for any . Also, for a subset of items we denote by the restriction of 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 mapping items to agents is proportional if for any integer and any agent , the number of items from 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 and a subset U of items, we can define the preference profile 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 where is a preference profile and k is an integer. We call a set of items a solution for if its removal from I allows for proportionality, that is, if there exists a proportional allocation for . The task in PID is to decide if there exists a solution for 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 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 , 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 runs in time 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 -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 -hardness, we will show that this result can in fact be strengthened to -hardness. We present the -hardness result for two reasons: (1) it is conceptually simpler than the -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 -hard when parameterized by the size k of the desired solution.
Proof
We are going to present an FPT-reduction from the -hard problem k -Dominating Set, where we are given a graph and an integer k, and the task is to decide if G contains a dominating set of size at most k; a vertex set 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 , and we let . Thus, a vertex set D is dominating if holds for each .
Let us construct an instance of PID with as follows. We let N contain agents where and : we create so-called selection agents , and for each we create a set of vertex agents. Next we let I contain items: we create distinct first-choice items f(a) for each agent , a vertex item for each , a dummy item for each vertex agent , and additional dummy items .
Let F denote the set of all first-choice items, i.e., . For any set of vertices in G, let ; in particular, 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 , we define the set to contain the first i elements of , for any . We end preference lists below with the symbol ‘
’ meaning all remaining items not listed explicitly, ordered according to .
Now we are ready to define the preference list for each agent a.
- If a is a selection agent with , then let

- If a is a selection agent with , then let

- If a is a vertex agent for some with , then let

This finishes the definition of our PID instance .
Suppose that there exists a solution S of size at most k to and a proportional allocation mapping the items of to the agents in N. Observe that by , we know that S must contain exactly k items.
First, we show that S cannot contain any item from F. For contradiction, assume that for some agent a. Since the preference list of a starts with more than k items from F (by ), the first item in must be an item f(b) for some , . The first item in is exactly f(b), and thus any proportional allocation should allocate f(b) to both a and b, a contradiction.
Next, we prove that . For contradiction, assume that S contains less than k items from . Then, after the removal of S, the top items in the preference list of any selection agent are all contained in . Hence, must allocate at least two items from to , 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 among the selection agents, a contradiction. Hence, we have .
We claim that the k vertices form a dominating set in G. Let us fix a vertex . For sake of contradiction, assume that , and consider any vertex agent a in . Then the top items in are the same as the top items in (using that ), and these items form a subset of for every . But then arguing as above, we get that would need to allocate an item of to each of the vertex agents in ; again a contradiction. Hence, we get that for each , 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 . To prove that S is a solution for , we define a proportional allocation in the instance obtained by removing S. First, for each selection agent with , we let allocate and the ith item from to . Second, for each selection agent with , we let allocate and the dummy item to . Third, allocates the items and to each vertex agent .
It is straightforward to check that is indeed proportional.
For proving -completeness, observe that the presented FPT-reduction is a polynomial-time reduction as well, so the -hardness of Dominating Set implies that PID is -hard as well; since for any subset of the items we can verify in polynomial time whether it yields a solution, containment in follows.
As mentioned above, we can in fact strengthen the -hardness result of Theorem 1 and show that PID is even -hard with respect to parameter k.
Theorem 2
Proportionality by Item Deletion is -hard when parameterized by the size k of the desired solution.
Proof
We are going to present an FPT-reduction from the -hard wcs[3] problem, which is the weighted satisfiability problem for formulas of the form , where each is a negative literal [14, Theorem 4.13] (see also [11, 15]). Let 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 be the set of variables occurring in — that is, n denotes the number of variables in . We will construct an instance of PID with as follows. We let N contain agents: we create so-called selection agents , and for each we create a set of verification agents. Next we let I contain items: we create distinct first-choice items f(a) for each agent , a variable item for each , verification items for each , and dummy items .
Let F denote the set of all first-choice items, i.e., . For any subset of variables, let ; in particular, 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 , we define the set to contain the first i elements of , for any . Moreover, for any we define the sets and . We end preference lists below with the symbol ‘
’ meaning all remaining items not listed explicitly, ordered according to .
Now we are ready to define the preference list for each agent a.
- If a is a selection agent with , then let

- If a is a selection agent with , then let

- If a is a verification agent for and , then let
where is the set of variables that do not occur in any literal , for .
This finishes the definition of our PID instance .
Suppose that there exists a solution S of size at most k to and a proportional allocation mapping the items of to the agents in N. Observe that by , 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 for some agent a. We can safely assume that and that for each . As a result, the preference list of a starts with more than k items from F. Therefore, the first item in must be an item f(b) for some , . Clearly, the first item in 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 . To derive a contradiction, assume that S contains less than k items from . Then, after the removal of S, the top items in the preference list of any selection agent are all contained in . Hence, must allocate at least two items from to each , 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 among the selection agents, which is a contradiction. Hence, we have . We also get that must allocate all items in to the selection agents.
Consider the truth assignment defined by letting if and only if , for each . Since , the truth assignment has weight k. We show that satisfies . To do so, we need to show that for each it holds that satisfies . Take an arbitrary . To derive a contradiction, assume that for each it holds that there is some such that is made false by . Then for each such it holds that . Then for each verification agent , for it holds that the top items in (for ) form a subset of . Then arguing as above, we get that would need to allocate an item of to each of the agents , which is a contradiction. Since i was arbitrary, we can conclude that satisfies .
For the other direction, let be a truth assignment of weight k that satisfies , and let S denote the set of k variable items . To prove that S is a solution for , we define a proportional allocation in the instance obtained by removing S. First, for each selection agent with , we let allocate and the ith item from to . Second, for each selection agent with , we let allocate and the dummy item to . Then, for each , let be some number such that makes true—we know that such a exists for each i because satisfies . For each verification agent we let allocate and one item from to as follows. If , we let allocate to ; if , we let allocate to ; and if , we let allocate to . 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 . Next we show that the brute force algorithm that runs in time is optimal, assuming the slightly stronger assumption .
Theorem 3
There is no algorithm for PID that on an instance with item set I runs in time for some function f, unless .2
Proof
Chen et al. [9] introduced the class of -hard problems based on the notion of linear FPT-reductions. They proved that Dominating Set is -hard, and that this implies a strong lower bound on its complexity: unless , Dominating Set cannot be solved in 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 -hard. Hence, as proved by Chen et al. [9], PID on an instance with item set I cannot be solved in time time for any function f, unless .
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 time, where n is the number of variables in the 3-CNF formula given as input.
Theorem 4
PID can be solved in time, but unless the ETH fails, it cannot be solved in time, where I is the set of items in the input.
Proof
To show that PID can be solved in 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 .
Next, we show that PID cannot be solved in 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 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 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 an instance of PID where the number of items is . Hence, assumming that our input graph G has maximum degree 3, we obtain for the set I of items in . Therefore, an algorithm for PID running in time would yield an algorithm for Dominating Set running in 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 , we say that an algorithm is an approximation for PID with ratio c if, for any instance of PID, either returns a solution for containing at most items, or correctly concludes that there is no solution for 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 for some fixed , we cannot expect an efficient algorithm.
Theorem 5
Let be a constant. If , then there is no algorithm that, given an instance of PID with item set I, yields an approximation for PID with ratio and runs in FPT time with parameter k.
Proof
Let us suppose that is an algorithm as described in the statement of the theorem. We are going to use to give an FPT-algorithm for the W[2]-hard Dominating Set problem, implying .
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 be the constructed instance of PID with . Recall that and . We distinguish between two cases, depending on the relationship between |N| and k; recall that is a positive constant.
First, if , 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 , this approach takes
time, which is fixed-parameter tractable with parameter k.
Second, assume . In this case, we apply algorithm , which either correctly concludes that there does not exist a solution of size k for , or returns a solution S of size at most . Observe that by we have
where the last inequality follows from our assumption on |N|.
Recall that must contain a number of items that is a multiple of |N|, as otherwise no proportional allocation may exist for . Hence, , and thus implies that S must be a solution of size k. Hence, either finds a solution of size k for , or reports that no such solution exists. By the correctness of our reduction, a solution of size k for 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 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 and some integer c, determine a set U of items with such that U can be proportionally allocated to the set N of agents (i.e., such that admits a proportional allocation).
Looking into the proofs of Theorems 1 and 2, we can immediately observe that the case , 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 with a set N of agents and a set I of items, it is -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 -hard to approximate the number of items each agent obtains in a proportional allocation with a ratio better than .
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 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 items such that is solvable. Then, clearly, there cannot be two agents whose first-choice items in coincide. This simple observation leads us to the following algorithm. Starting from , 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 (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 admits no solution S of size at most . The running time is clearly polynomial in .
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 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 contains three agents, so let . 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 which can be used to determine whether 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 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 is an agent and . 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 . 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.

Illustration for the graph underlying a profile and its prefix . Note that slots (a, 2) and (c, 2) are incomplete in
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 with we define a prefix of as the triple ), listing only the first , , and items in the preference list of agents a, b, and c, respectively. We call the size of and denote it by .
We say that a prefix is contained in another prefix if for each ; the containment is strict if for some . We say that and are intersecting if none of them contains the other; we call the unique largest prefix contained both in and in , i.e., the prefix , their intersection, and denote it by . 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 , let denote the set of all items appearing in . We define the set of slots appearing in as . We also define the graph underlying as the subgraph of G where a slot is adjacent to an item if u appears in and is eligible for (x, i) in G; see Fig. 1 for an illustration. Note that any slot (x, i) where is connected to the same items in as in G; we say that such slots are complete in . By contrast, if , then the slot is connected to fewer items in than in G. Hence, the only slots which may be incomplete are the last slots in , that is, the slots , . See Fig. 1 for an illustration.
Solvability We say that a prefix is solvable, if the underlying graph has a matching that covers all its complete slots. Hence, a prefix is solvable exactly if there exists an allocation from to N that satisfies the condition of proportionality restricted to each index in : for any agent and any index , the number of items from allocated by to x is at least i/3.
Minimal obstructions We say that a prefix is a minimal obstruction, if it is not solvable, but all prefixes strictly contained in 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 . We will call any prefix 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.
Illustration depicting a profile with the graph (edges incident to the last slots are grey only to help visibility). The matching in 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 by alternating paths from slot (c, 2) together with all items eligible for them (as depicted in by the dashed trapezoid) yield the minimal obstruction of straight shape. The boundary of is (emphasized in bold). There are six partial solutions for of size at most 2, namely , , , , , and . Each partial solution U is witnessed by an allocation showing that is solvable; in each (partial) preference list for , we indicated the items allocated by to the given agent by underlining them
Lemma 1
Profile admits a proportional allocation if and only if the underlying graph G contains a perfect matching. Also, in time we can find either a proportional allocation for , or a minimal obstruction in .
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 and each (note that since is proportional), we simply put into M the edge connecting slot (x, i) with the ith item received by x; naturally, we rank items received by x according to x’s preferences. The proportionality of implies that is contained in the top items in , 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 by M we obtain a proportional allocation : for each agent x and index , our allocation assigns at least j/|N| items to x from , namely the items matched by M to the slots . Since , even the last item eligible for is contained in , ensuring that is indeed proportional.
Therefore, we can check whether there exists a proportional allocation for by finding a maximum matching in the bipartite graph G. Using the Hopcroft–Karp algorithm [17], this takes 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 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 be the set of all slots reachable by an alternating path in G from (x, i), and let be the set of all items eligible for any slot in . It is well known that and violate Hall’s condition: . Moreover, the slots in “induce” a prefix in the sense that there exists a prefix with . To prove this, it suffices to show that if and , then . By our strategy for picking starting slots, we know , implying that 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 , we can take any alternating path from (x, i) to (y, j), and append the two-edge path from (y, j) to through q. Hence, there indeed exists a prefix with ; we pick such a containing only complete slots. Using standard arguments from matching theory, it is straightforward to check that is a minimal obstruction.
Each iteration can be performed in time (e.g., with a BFS), and there are at most |I| steps, so the algorithm runs in time.
Lemma 2
Let be a prefix of that is a minimal obstruction. Then , , and either
-
(i)
, or
-
(ii)
for some choice of agents x, y, and z with .
Moreover, if (ii) holds, then and contain exactly the same item set, namely .
Proof
First, observe that if , then the set of complete slots is the same in as in , contradicting the minimality of . Thus, we have , and we get analogously.
Second, let us consider the graph underlying our prefix. Since Hall’s condition fails for the set of (complete) slots but, by minimality, it holds for any proper subset of these slots, we know that
| 1 |
where the last equality follows from the first claim of the lemma. Let us assume . Note that if neither (i) nor (ii) holds, then by the maximality of and the first claim of the lemma we obtain , from which (1) implies . However, contains only items from , which would imply that some item appears twice in , a contradiction.
To see the last claim of the lemma, suppose . Then (1) implies , and hence (and also ) must contain each item in exactly once.
Based on Lemma 2, we define the shape of a minimal obstruction as either straight or slant, depending on whether 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 , denoted by , as the set of all items that appear once or twice (but not three times) in . 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.

Illustration depicting a profile containing a minimal obstruction of slant shape. Proportional allocations, where existent, are indicated by underlining. We investigate four partial solutions, , , and , for . The boundary of is (emphasized in bold). Deleting either 3, 4, or 7 yields a solution for , but deleting item 5 does not; we have depicted a minimal obstruction in
Lemma 3
Let be a prefix of that is a minimal obstruction. Then the boundary of contains at most three items: .
Proof
We make use of Lemma 2. First, if has a straight shape, so for some index i, then . Since is a minimal obstruction, by Lemma 2 we get . However, each agent’s list within contains exactly i items, yielding that there is exactly one position outside in each agent’s list where an item of occurs. Hence, follows in this case.
Second, assume that has a slant shape, say for some index i (the two remaining cases are analogous). Then Lemma 2 implies and that both and contain all the i items in , but misses exactly three items from . Hence, there are exactly three occurrences of items listed outside , each in the list of agent c, meaning .
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 , 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 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 .
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 and a set U of items, we define 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 is a partial solution for if 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 by checking whether all complete slots can be covered by a matching in the graph corresponding to .
Branching set. To solve PID we will repeatedly apply a branching step: whenever we encounter a minimal obstruction , we shall consider several possible partial solutions for , and for each partial solution Y we try to find a solution U for such that . To formalize this idea, we say that a family containing partial solutions for a minimal obstruction is a branching set for , if there exists a solution U of minimum size for the profile such that . 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 be a minimal obstruction in a profile , and let U denote an inclusion-wise minimal solution for . Then .
Proof
Let , and let us assume for contradiction. We are going to select a set Y of three items from for which we can prove that is a solution for , contradicting the minimality of U.
We rank the items of according to the index of the first slot in which they appear in : 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 . If there exist three items , , and in appearing strictly earlier (i.e., at a smaller index) than all other items in , then we let .
Otherwise, we apply the following procedure to choose Y. Let be the set of items in that appear at the earliest index, say . We select from by favoring items eligible for more than one slot from ; if there are still several possibilities to choose , then we select it arbitrarily. Similarly, let be the set of earliest appearing items in , appearing at some index . We pick an item from by favoring items eligible for more than one slot from ; again, if there are still several possibilities to choose , then we select it arbitrarily. Note that we use the notion of eligibility based on the original preference lists in .
To choose an item from the set of the earliest appearing items in , we create the profile . If there exists a minimal obstruction in strictly contained in , then we fix such a minimal obstruction , and we choose an item eligible for a slot of . Otherwise we choose from arbitrarily. Intuitively, we choose so as to overcome the possible obstructions obtained when putting and 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 exists, then (1) since there is no obstruction strictly contained in in the profile , there must exist some item in that is eligible for some slot in ; and (2) if u appears earliest in among all such items, then . To see this, let (x, i) be the first slot in for which u is eligible in . By the claim of Lemma 2 on the shape of a minimal obstruction, all slots preceding (x, i) belong to as well, that is, the prefix “induced” by these slots in is contained in . Thus, by our choice of u, we get that is a prefix of as well, implying that no item of appears earlier in than u. Hence, , showing that is well-defined.
Setting , we finish our proof by proving that is a solution for . For contradiction, suppose that is a minimal obstruction in .
First, suppose that contains all items in Y. As U is a solution, the profile is solvable, and hence contains at least as many items as complete slots. Note that adding the items of Y into the profile 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, has at least as many items as slots, contradicting the assumption that is a minimal obstruction.
Hence we know that does not contain all items in Y. By Lemma 2, is then strictly contained3 in , and by the minimality of we get that must contain an item from . We claim that if contains for some , then it contains all items with . Since appears not later than , the only possible way for to contain but not would be the following: and appear at the same slot number i, but has a slant shape and thus only contains two slots from , missing exactly the (unique) slot where appears. However, since is a minimal obstruction, must appear at both remaining slots from by the last statement of Lemma 2, which contradicts our choice of .
This leaves us with the case when is not contained in (for would imply , which we already proved not to be the case). Then is not only a prefix of but also of . Assume w.l.o.g. that appears at index j in the slot (c, j). Since is a minimal obstruction in strictly contained in , we know that a minimal obstruction was found when choosing , but . Thus, both and are minimal obstructions of slant shape, with containing the slots (a, j) and (b, j) but not (c, j), and containing the slot (c, j) and one of (a, j) and (b, j), say (b, j). This means that and . Note also that by the last statement of Lemma 2, we know
This means that contains exactly items.
Observe that deleting from profile results in a prefix of of size that contains exactly items. However, contains complete slots (and 3 incomplete ones). Therefore, contains a prefix that is not solvable, a contradiction finishing the proof.
Lemma 4 implies that simply taking all partial solutions of of size 1 or 2 yields a branching set for . As an example, the minimal obstruction shown in Fig. 2 admits the branching set .
Corollary 2
For any minimal obstruction in a profile, a branching set for of cardinality at most and with can be constructed in time.
Proof
By Lemma 4, in order to construct the branching set as required, it suffices to check for each of size at most 2 whether is solvable. To do so, we first construct the graph G underlying the prefix and compute a maximum matching M in G. This can be done in time using the Hopcroft–Karp algorithm, as explained in Lemma 1. Note that since is a minimal obstruction, it matches all but one slots in G, so .
Now, for each with we compute the graph underlying the prefix . Observe that we can obtain 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 of size at least in , which covers at least complete slots (because at most three slots may have become incomplete in ). Hence, starting from we only need to find a constant number of augmenting paths in order to check whether all complete slots of can be covered by a matching. This takes time, because has at most 2|I| vertices, yielding a running time of in total.
Polynomial-Time Algorithm for PID for Three Agents
Let us now present our algorithm for solving PID on our profile .
We are going to build the desired solution step-by-step, iteratively extending an already found partial solution. For a prefix of and a partial solution U for , we call a set an extension for if E is disjoint from and is a solution for ; we will refer to the set of items in as forbidden w.r.t. . We propose an algorithm that, given a prefix of and a partial solution U for , returns an extension for of minimum size if one exists, otherwise returns ‘No’.
Branching set with forbidden items. To address the problem of finding an extension for , we modify the notion of a branching set accordingly. Given a minimal obstruction in some profile and a set of items, we say that a family of partial solutions for is a branching set for forbidding F, if the following holds: either there exists a solution U for the profile that is disjoint from F and has minimum size among all such solutions, and moreover, fulfills , or does not admit any solution disjoint from F (in which case can be arbitrary).
Lemma 5
There is an algorithm that, given a minimal obstruction in a profile and a set of forbidden items, produces a branching set forbidding F with and , and runs in time .
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 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 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 and for are equivalent if
, and
and admit the same extensions.
See Fig. 4 for an illustration.
Fig. 4.
An example showing how different partial solutions for minimal obstruction can be extended into a solution for profile . Among all partial solutions, only is a solution for , 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 is different from that of or (as can be seen on Fig. 2). This implies that the prefixes and have less items than the corresponding prefixes in of the same size, ultimately leading to the fact that is a solution for , while neither nor can be extended into a solution for (because there exists no partial solution for the minimal obstructions depicted in and that is disjoint from ). The list of possible extensions shows that is equivalent with , and all partial solutions of size 2 are equivalent with each other. (We remark that, however, all partial solutions for have distinct deficiency patterns, so no two of them are strongly equivalent)
Ideally, whenever we perform a call to with a given input , we would like to first check whether an equivalent call has already been performed, i.e., whether has been called with an input for which U and 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 of . We let the deficiency of , denoted by , be the value . Note that due to possibly incomplete slots in , the deficiency of may be positive even if is solvable. However, if contains only complete slots, then its solvability implies . We define the deficiency pattern of , denoted by , as the set of all triples
where can be any prefix with a straight or a slant shape that intersects . Roughly speaking, the deficiency pattern captures all the information about that is relevant for determining whether a given prefix intersecting is a minimal obstruction or not. Note that any given value of can be present in only one triple from the deficiency pattern of , because and only depend on and . See Fig. 5 for an example.
Fig. 5.
Illustration of deficiency patterns. For the minimal obstruction contained in profile from Fig. 3, we show four partial solutions and the corresponding deficiency patterns. Since and have the same deficiency pattern , and neither 3, nor 4 is contained in the boundary , we get that and are strongly equivalent partial solutions for ; by Lemma 6 they are also equivalent. By sets and are not strongly equivalent for . Since , set is not strongly equivalent with any other partial solution; nevertheless, and are in fact equivalent with respect to : they are both solutions for and thus admit the extension (recall Fig. 3)
For an intuitive understanding of the role of deficiency patterns, consider a prefix and a partial solution U for . In our algorithm, after we have decided on deleting U, we will not delete any further items from ; 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 is a prefix that may or may not become a minimal obstruction after deleting U; clearly we may suppose that has a straight or a slant shape (otherwise it is certainly not a minimal obstruction).
In case contains , the only important properties of U are its size and its intersection with the boundary of : deleting any partial solution with that contains the same items from 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 does not contain but intersects it, all further information necessary to “classify” U is contained in . Indeed, to calculate the number of items in , it suffices to know the number of items in the intersection and the number of items that are contained in . The former can be calculated from the deficiency of . For the latter we also need to know which items, among those occurring at positions of outside , occur also in ; since such items are necessarily contained in the boundary of , it suffices to know the set .
Strong equivalence To formalize the above ideas, we call partial solutions and for strongly equivalent, if
,
, and
.
As the name suggests, strong equivalence is a sufficient condition for equivalence.
Lemma 6
If and are strongly equivalent partial solutions for , then they are equivalent as well.
Proof
Suppose that W is an extension for . We need to prove that it is an extension for as well. Clearly, we have , so it suffices to show that is solvable.
Suppose for contradiction that is a minimal obstruction in . Let us consider the prefix of that has the same size as ; such a prefix exists because . In the remainder of the proof, we argue that is not solvable in , contradicting the assumption that W is an extension for and thus is a solution for . Note that and clearly have the same slots, all of them complete.
Recall that is a partial solution for , so is solvable. Since W is disjoint from , we know that cannot be contained in .
First, let us assume that contains . In this case, and together immediately imply that and contain the same number of items: . Hence, we get , proving our claim.
Second, let us assume now that and are intersecting, and let their intersection be . Similarly, let be the intersection of and . Since is a minimal obstruction and thus has a straight or a slant shape, we know that is contained in the deficiency pattern of . By the third condition of equivalence, the same triple must also be present in the deficiency pattern of . Hence, must have the same deficiency as . By and , we know that and have the same size, and thus has the same size as . This implies .
Moreover, we also get . Recall that is guaranteed by the second condition of strong equivalence. Hence, adding the items contained in but not in increases the size of exactly as adding the items contained in but not in increases the size of . Therefore, we can conclude that , which again implies that is not solvable.
Before giving the details of algorithm , 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 be a minimal obstruction in for a set of items, and let be the largest4 prefix in for which . Let also with be a partial solution for ; then is a partial solution for . Now, let be a minimal obstruction in , and let be the largest prefix of such that . Then either , or there does not exist an extension for .
Proof
First observe that cannot contain , because is solvable, but is a minimal obstruction. Assume now that . Then clearly, cannot contain either. Hence, must intersect with the minimal obstruction .
Consider agents’ preference lists in the profile and the underlying graph . We say that two (or three) positions in the preference lists belong to the same slot in , if they are contained in for some agent x and index . We claim that either
-
(i)
all positions contained in but not in belong to the same slot in , or conversely,
-
(ii)
all positions contained in but not in belong to the same slot in .
This claim can be seen by the heavy use of Lemma 2, distinguishing between cases depending on the shapes and positions of and ; see Fig. 6.
Fig. 6.
Illustration for the proof of Lemma 7. The shapes of prefixes , , and are depicted with solid, dashed, and dotted lines, respectively. Positions contained in but not in are marked by black diamonds, while positions contained in but not in are marked by white diamonds
Let us first assume that has a straight shape, so for some index . Then by we know that contains and is contained in . Hence, the only possible way for to intersect is for to have size , , or ; w.l.o.g. we suppose . But then (i) must hold, because any position contained in but not in must be a position in .
Let us now assume that has a slant shape; w.l.o.g. we may assume that for some index . Now, if is contained in , then (ii) holds, because any position contained in but not in must be a position in . Otherwise, using again , the only way for to intersect is for to have size or , 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 but not in belong; let denote the set of items on these positions in . Then
| 2 |
Since contains items of , we know that they occur on positions belonging to the slot (x, j) in as well (note that is a prefix in not in ). Thus , but observe that . However, by the minimality of , any item present in a last slot of occurs at least once more in (since an item eligible only for (x, j) among all slots in would imply that deleting the positions corresponding to (x, j) from would yield a prefix with slots and at most items). Therefore, any item of occurs at least once more in . By , this implies that any item of occurs at least once in a position of that does not belong to (x, j). However, any such position is contained in as well, by our assumption (i). Thus , which by Equality (2) implies . This proves .
Supposing (ii), let (x, j) be the slot to which all positions contained in but not in belong; let denote the set of items on these positions in . Then it is clear that but , hence arguing as above, we get that . But then , implying that the minimal obstruction in contains only items that are forbidden w.r.t. . Thus, there cannot exist an extension for .
Now, we are ready to describe algorithm in detail. Let be the input for . Throughout the run of the algorithm, we will store all inputs with which has been computed in a table , keeping track of the corresponding extensions as well. Initially, we call with input , where denotes the empty prefix of our input profile , i.e., , and we initialize as empty. For an example of running algorithm on an instance of PID, see Appendix A.
Algorithm :
- Step 0:
-
Check for strongly equivalent inputs.
For each in , check whether and U are strongly equivalent with respect to , and if so, return .
- Step 1:
-
Check for trivial solution.
Check if is solvable. If so, then return the empty extension , and store the entry together with the value in .
- Step 2:
-
Find a minimal obstruction.
Find a minimal obstruction in ; recall that is not solvable in this step.
- Step 3:
-
Compute the new prefix.
Let be the largest prefix of for which . If , then return ‘No’, and store the entry together with the value ‘No’ in .
- Step 4:
-
Compute a branching set.
Using Lemma 5, determine a branching set for forbidding . If , then return ‘No’, and store the entry together with the value ‘No’ in .
- Step 5:
-
Branch.
For each , compute .
- Step 6:
-
Find a smallest extension.
Compute a set for which . Return the set , and store the entry together with the extension in .
Lemma 8
When initially called with input , algorithm is correct, i.e., for any prefix of and any partial solution U for , returns a minimum-size extension for (if existent).
Proof
Observe that it suffices to prove the claim for those cases when algorithm does not return a solution in Step 0: its correctness in the remaining cases (so when a solution contained in 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 . Clearly, if , then is an empty instance, and hence is trivially solvable. Assume now that , and that returns a correct output for any input with .
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 , so is a recursive call, and hence was called when branching on a branching set. Thus, there exists some with for which is a minimal obstruction . 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 forbidding for the minimal obstruction is empty, then this, by the definition of a branching set (forbidding ) and by the soundness of the algorithm of Lemma 5, means that there is no solution S for disjoint from . But then we also know that there is no solution S for for which holds, so there is no extension for . Hence this step is correct as well.
Therefore, we can assume that the algorithm’s output is for some , where and is the largest profile in for which . As for any , the induction hypothesis implies that runs correctly on all inputs , . Hence, is an extension for and so is a solution for . Moreover, since and by Step 3, we know that is disjoint from . Since is contained in a branching set for in forbidding , we get that is disjoint from as well. Thus, is an extension for .
It remains to argue that if E is an extension for , then . Clearly, E is a solution for disjoint from . By the definition of a branching set forbidding and the correctness of Lemma 5, we know that there must exist a solution for disjoint from and having size for which . Define . Observe that an extension for .
Using again the induction hypothesis, we get that returns an extension for of minimum size, so in particular, , implying . Thus, by our choice of , we get that the output of (that is, ) has size at most |E|. This proves our claim. Therefore, we get that if returns an output in Step 6, then this output is correct.
Lemma 8 immediately gives us an algorithm to solve PID: returns a solution S for of minimum size; we only have to compare |S| with the desired solution size k.
The next lemma states that gets called polynomially many times.
Lemma 9
Throughout the run of algorithm initially called with input , the table contains entries.
Proof
Let us consider table at a given moment during the course of algorithm , initially called with the input (and having possibly performed several recursive calls since then). Let us fix a prefix . We are going to give an upper bound on the maximum cardinality of the family of partial solutions U for for which contains the entry .
By Step 0 of algorithm , no two sets in are strongly equivalent. Recall that if and , both in , are not strongly equivalent with respect to , then either , or , or . Let us partition the sets in into groups: we put and in the same group, if and .
Examining Steps 2–4 of algorithm , we can observe that if , then for some of size 1 or 2, the prefix is a minimal obstruction . Since removing items from a prefix cannot increase the size of its boundary, Lemma 3 implies that the boundary of contains at most 3 items. We get , from which it follows that is a subset of of size at least . Therefore, the number of different values that can take is . Since any has size at most |I|, we get that there are groups in . Let us fix some group of . We are going to show that the number of different deficiency patterns for where is constant.
Recall that the deficiency pattern of consists of triples of the form
where is some prefix of with a slant or a straight shape, and is the intersection of and .
First observe that by the definition of a group, holds for any . Let us fix an arbitrary . Since 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 of which intersect and have a slant or a straight shape; in fact, it is not hard to check that the number of such prefixes is at most 5 for any given . Therefore, the number of values taken by the first coordinate of any triple in the deficiency pattern of is constant. Since has the same size for any , we also get that these values coincide for any . Hence, we obtain that (A) the total number of values the first coordinate of any triple in the deficiency pattern of for any can take is constant.
Let be the intersection of and some prefix of straight or slant shape. By definition, is contained in . By , there are only a constant number of positions which are contained in but not in . From this both and follow. As is a minimal obstruction, we also have , implying that (B) the deficiency can only take a constant number of values too; note that we have an upper bound on that holds for any . Considering that is the subset of , and we also know , we obtain that (C) the set can take at most values (again, for all ).
Putting together observations (A), (B), and (C), it follows that the number of different deficiency patterns of taken over all is constant. This implies . Since there are prefixes of , we arrive at the conclusion that the maximum number of entries in is .
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 .
Proof
By Lemma 8, we know that algorithm returns a solution for of minimum size, solving PID.
To bound the running time of , let us first give a bound on the time necessary for the computations performed by on some input when not counting the computations performed in recursive calls. Clearly, Step 0 takes O(|I|) time (assuming we can effectively search within the table ). Steps 1 and 2 can be accomplished in time, as described in Lemma 1. Step 3 can be accomplished in time O(|I|). Using Lemma 5, Step 4 can be performed in time. Since the cardinality of the branching set found in Step 4 is , Steps 5 and 6 can be performed in time. Hence, any call to can be performed in time (when not counting the computations performed in the recursive calls).
Let us distinguish now between two types of recursive calls to : a call 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 . By Lemma 9, contains entries, and therefore the number of regular calls to is also . This gives us an upper bound of on the total time spent on regular calls to .
To bound the time spent on shadow calls, observe that each regular call may give rise to at most shadow calls (and there are no recursive calls performed within a shadow call). Hence, the number of shadow calls is . Since Step 0 takes O(|I|) time, this yields a bound of for the total time spent on shadow calls. Hence the total running time of 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 , an allocation , and an integer . We call a set of items a solution for , if the restriction of to is proportional for the profile ; the task is to find a solution of size at most k for .
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 , if the number of items in assigned to x by is less than i/|N|, but for any smaller index the number of items in 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 , we denote by the other agent, i.e., , .
Algorithm GreedyDel:
- Step 0:
If , then return ‘No’.
- Step 1:
If is proportional for , 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 among all items of assigned to by , and call .
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 .
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 and s is the item deleted by the algorithm in Step 2, then there exists a solution for 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 denote those items of S that are contained in . Suppose that S does not contain the deleted item s. However, since S is a solution, we know that must contain strictly more items assigned by to than to x, i.e.,
| 3 |
Let be the item least preferred by x in . We will show that is a solution for , proving our claim that Step 2 is safe.
Note that by our choice of s, agent prefers to s, so cannot become envious at any index in . If x prefers s to , then x cannot become envious at any index in either (because deleting an item assigned to that comes before in is always preferable for x than deleting ), so in this case is a solution for . Thus, for the sake of contradiction, assume that x also prefers to s, and x becomes envious somewhere in . This means that there exists an index such that
| 4 |
where and denote the set of items in assigned to x and to by , respectively (note that is the preference list of x in the original instance ).
First, if contains either both s and or neither of them, then , so
where the first equality is implied by , and the inequality follows from the fact that S is a solution for . This contradicts (4).
Second, if , then but , because x prefers to s. In this case we know . Using that is the least preferred by x among all items of but it still falls within , we know that all items of fall within and are thus contained in . From this, we get that
where the first inequality follows from (3). Recall that x only becomes envious at i in , and therefore , leading us to
which again contradicts (4).
Interestingly, PID with Fixed Allocation becomes -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 .
Theorem 9
If the number of agents is six, then PID with Fixed Allocation is -complete.
Proof
It is straightforward to see that the problem is in . To prove its -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 as a bipartite graph whose two partitions are the set V of variables and the set of clauses, and a variable is adjacent to a clause 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 -hard.
Given the input formula , we construct an instance of PID with Fixed Allocation such that is satisfiable if and only if admits a solution of size at most k. Let contain variables and clauses ; note that must hold, as G is cubic. We define the set of agents as . The set I of items contains and for each variable , as well as a set containing some newly introduced items for each agent ; we set , , and for any other agent . We let and . Items in U and are assigned by to and f, respectively, while for any agent , items in are assigned to x by . We set .
To finish the definition of profile , it remains to give the preferences of each agent, for which we need additional notation. The three items in will correspond to the three occurrences of variable , each a positive literal, while the items in will correspond to their negated forms. Hence, for each clause , we define as the set of items that, for any , contains item , , or if and only if contains the first, second, or third occurrence, respectively, of variable in . We also define as the set of items containing , , or for some j if and only if contains , , or , 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 ‘
’ 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 , it will be sufficient to distinguish between items of only up to the point of indicating whether they are assigned to x by or not. Thus, we will use ‘’ symbols in to denote items from , and we will use ‘’ symbols to denote items from (these will serve as dummy items). If the number of ‘’ (or ‘’) symbols in is , then they refer to the first items from (or from , 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.
![]() |
||||
![]() |
||||
![]() |
||||
![]() |
||||
![]() |
||||
![]() |
||||
Recall that in a preference list , all ‘’ symbols stand for items in (assigned by to x), while ‘’ symbols stand for items in (assigned by to some other agent in ). 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 , while contains at most 12n dummies. Hence, 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 of size at most k. Note that assigns exactly 4n items to each agent except for f and , while it assigns 6n and 5n items to f and , respectively (recall that f receives all 3n items in , while receives all 3n items in U). By , we get that S contains exactly 2n items of and n items of . In particular, S does not contain any (dummy) item from D.
Fix some agent , and consider the first 7j items in the preference list of x for some . Observe that contains only j items assigned to x by . However, cannot be proportional as long as the set consisting of the first 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 . Let denote the set of items in that are not in D and hence may be included in the solution S; e.g., , , and so on. Then our observation for each can be written as
| 5 |
However, notice that and also , which implies
| 6 |
for any where we abuse notation by setting and ; note that we used Inequality (5) for agent and index . Using that and that the sets , , are mutually disjoint, it is straightforward to verify that Inequalities (5) and (6) can only hold for each value of if
| 7 |
For agents v and , (7) implies that if and only if for any item . Taking into account the statement of (7) for agents w and , we obtain that either and , or and for each .
Let us define a truth assignment by setting variable in to true if and only if . We claim that is valid for , i.e., each clause in contains exactly one variable for which .
Considering the first 7j items from the preference list of f for some and arguing similarly as before, we obtain that
| 8 |
Analogously, from the first 8j items from the preference list of (among which only j are assigned to by ), we get
| 9 |
However, notice that for any . Hence, Inequalities (8) and (9) imply and for every . This means exactly that is valid for .
For the other direction, assume that there exists a valid truth assignment for , and let denote the set of true variables. First observe that must hold, because each variable appears in exactly three clauses, and there are n clauses. We define a solution S for by putting , , and into S for each , and putting , , and into S for each . Hence and . Note that Inequality (5) holds for S for any agent and index . Inequalities (8) and (9) hold as well for any , due to the validity of . Based on these facts, it is easy to check that S is indeed a solution for .
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 -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 and an integer k, with V partitioned into a set of ‘red’ and a set of ‘blue’ vertices. We denote by N(v) the set of neighbors of some vertex . The task is to decide if G contains a set of at most k red vertices that dominates all blue vertices, i.e., such that for each . Red-Blue Dominating Set is known to be -complete and -complete when parameterized by k [12].
Let us construct an instance of PID with Fixed Allocation. We let , and we define the set of agents as where , and contains dummy agents for the smallest integer such that . We define the set of items as where contains copies of each blue vertex, and contains dummy items for each dummy agent. The allocation assigns every item of to agent , while each agent is assigned items , and each agent is assigned items .
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 ‘
’ 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 ).
Note that the preference list of an agent 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 . Note that assigns items to each agent, except for agent who gets s items. Hence, and follows. We claim that S dominates all blue vertices in G: indeed, if for some in G, then agent becomes envious at index in , since contains only one item assigned to 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 as well, because if no agent of becomes envious at index in , then is guaranteed to be proportional in .
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 -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 : it is an open question whether for it holds that any inclusion-wise minimal solution S contains at most items from a minimal obstruction . In fact, it is not even known whether there is a bound f(n) on the number of items in 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 -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 , but proved the problem to be -complete for . This leaves open the case when the number of agents is in ; 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
In this section we show how the algorithm runs on a profile with agents a, b, and c ranking the item set as below:
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 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.
Illustration for the search tree traversed by algorithm 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 on the example of Appendix A. The entries appear according to the order in which the algorithm stores them
| Prefix | Partial solution | Extension |
|---|---|---|
Funding
Open access funding provided by Budapest University of Technology and Economics.
Footnotes
For a complete proof of the correctness of their algorithm, see also the work by Aziz et al. [4].
Here, we use an effective variant of “little o” (see, e.g. Flum and Grohe [15, Definition 3.22]).
Seemingly it may be incorrect to say that is contained in because is a prefix of while is a prefix of ; however, recall that the definition of containment only depends on the notion of size.
If , then also holds (where the union of and is the unique smallest prefix containing both); hence, 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 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)














