Beyond Exact Fairness: Envy-Free Incomplete Connected Fair Division
Abstract
We study the problem of Envy-Free Incomplete Connected Fair Division, where exactly vertices of an undirected graph must be allocated to agents such that each agent receives a connected share and does not envy another agent’s share. Focusing on agents with additive valuations, we show that the problem remains computationally hard when parameterized by and the number of agents. This result holds even for star graphs and with the input numbers given in unary representation, thereby resolving an open problem posed by Gahlawat and Zehavi (FSTTCS 2023).
In stark contrast, we show that if one is willing to tolerate even the slightest amount of envy, then the problem becomes efficient with respect to the natural parameters. Specifically, we design an Efficient Parameterized Approximation Scheme parameterized by and the number of agent types. Our algorithm works on general graphs and remains efficient even when the input numbers are provided in binary representation.
Keywords and phrases:
Envy-Free Incomplete Connected Fair Division, Efficient Parameterized Approximation Scheme, W[1]-hardnessCopyright and License:
2012 ACM Subject Classification:
Theory of computation W hierarchy ; Theory of computation Fixed parameter tractabilityFunding:
NSF Grant No. 2505099, Collaborative Research: AF Medium: Structure and Quasi-Polynomial Time Algorithms.Editors:
C. Aiswarya, Ruta Mehta, and Subhajit RoySeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Fair division is a critical problem in resource allocation, focused on distributing resources among multiple agents in a way that meets certain fairness criteria. The theoretical study of this problem has been a core area of research, with work dating as far back back as the 1940s [33]. Fair division, beyond its theoretical appeal, has numerous practical applications, as demonstrated by platforms like Spliddit [24], which use fair allocation algorithms to solve real-world problems such as sharing rent, splitting taxi fares, and assigning goods. However, for many of these practical scenarios, one ends up having to address more complex constraints. An example of this is the case where the goods are indivisible and the bundle of items corresponding to each agent must satisfy some connectivity requirements. The -Connected Fair Division (-CFD) problem, introduced by Bouveret et al. [11] models this using a graph whose vertices represent items, where the bundles allocated to agents are required to form connected subsets of the vertices, where specifies some desired notion of fairness.
However, this model requires that every vertex of the graph be allocated to some agent, which fails to cover some natural scenarios where there is a need to be economic in the allocation. As an example consider a museum that plans to allocate sections of a large exhibition hall for various temporary art exhibits. Each exhibit needs a connected space to display its artwork effectively, but the museum must also reserve areas for future events or special exhibits. The challenge then becomes to assign some part of the available space fairly among the groups, ensuring each receives a connected section, while leaving enough space unallocated for other purposes. Another scenario where being economic is crucial involves allocating resource-intensive goods, such as when a company rents office spaces or a startup purchases equipment for its employee teams.
Motivated by these considerations, Gahlawat and Zehavi [21] introduced the -Incomplete Connected Fair Division problem (-ICFD). In this, the goal is to find a valid and -allocation, that is, an allocation of exactly vertices of the graph where each agent receives a distinct connected bundle that satisfies the fairness criterion specified by . From the perspective of parameterized complexity, they consider this problem for various well known notions of fairness, one of them being envy-freeness. An allocation of vertices to agents is envy-free if, for every agent, the value they assign to their own bundle is at least as large as the value they assign to any other agent’s bundle. They show that, if the valuations are provided in binary representation, then the Envy-Free Incomplete Connected Fair Division problem becomes W[1] hard parameterized by and the number of agents. However, their work leaves behind the following open problem: does Envy-Free Incomplete Connected Fair Division admit a Fixed-Parameter Tractable (FPT) algorithm parameterized by number of agents and , if the valuations are given in unary representation?
1.1 Our Contribution
We resolve the open problem posed by Gahlawat and Zehavi [21] by proving that Envy-Free Incomplete Connected Fair Division is W[1]-hard when parameterized by , where is the set of agents, when the input numbers are in unary representation, even for highly restricted input instances such as star graphs. Our result follows via a reduction from -Vector-Sum, a multidimensional variant of the classic NP-hard problem Subset Sum, shown to be W[1]-hard by Abboud et al. [1], parameterized by , where is the dimension of the input vectors, even when the input numbers are in unary representation.
Theorem 1.1.
Envy-Free Incomplete Connected Fair Division is W[1]-hard parameterized by , with the input numbers provided in unary representation, even on star graphs.
To address the intractability implied by Theorem 1.1, we approach the problem from the perspective of approximate fairness. The study of finding approximately fair allocations, meaning allocations that are at most a small multiplicative (or additive factor) unfair to the agents, was initiated by Lipton et al. [29] in the context of cake-cutting and has since been investigated in other settings. For a comprehensive overview of this topic, we refer the reader to the survey by Amanatidis et al. [4], which discusses approximate fairness in various settings. In our case, an allocation is -envy-free if, for every agent, the value they assign to their own bundle scaled up by a multiplicative factor of , is at least as large as the value they assign to any other agent’s bundle.
In this setting, it is very natural to apply a geometric rounding scheme to round the involved numbers to the nearest power of and make some guesses regarding the agents valuation of allocated items. This is especially tempting given that the hardness of the instance in the proof of Theorem 1.1 arises precisely from the inability to iterate over all possible valuations that agents may assign to the allocated items. This does in fact lead to a straightforward FPT algorithm, parameterized by , that finds a valid and -envy-free allocation or correctly concludes that the input instance has no valid and envy-free allocation, if the input numbers are provided in unary representation. But, in the case where the input numbers are provided in binary representation, the agents could have wildly different valuations for the same items and consequently the number of guesses will no longer be FPT in terms of the relevant parameters. In fact, due to this reason, for some time we believed that there exists a positive real number such that, assuming the Exponential Time Hypothesis [27], no FPT algorithm can either find a valid and -envy-free allocation or correctly conclude that the input instance admits no valid and envy-free allocation. Surprisingly, this is not the case – the problem admits an algorithm with the aforementioned guarantees that runs in FPT time parameterized by and , the number of agent types, which is a smaller parameter than the number of agents.
Theorem 1.2.
There exists an algorithm that, given an instance of Envy-Free Incomplete Connected Fair Division with input numbers in binary representation, and a positive real number , runs in time and outputs either a valid and -envy-free allocation , or correctly states that does not admit a valid and envy-free allocation.
We now give a sketch of the algorithm asserted in Theorem 1.2. The algorithm begins by applying a simple reduction rule that allows us to upper bound the number of agents by a function of and . After this, we proceed to apply the standard technique of color coding [3] (see also [17]) to color the vertices of the graph with colors, and make some guesses regarding the color of the vertices that end up being assigned to each agent.
At this point, we draw inspiration from the polynomial-time algorithm of Gan et al. [22], which addresses the special case where each agent is allocated exactly one item, sometimes referred to as the house allocation problem. To illustrate, consider a more restricted setting in which every agent is assigned a unique color and must be allocated exactly one vertex which has the same color. In this setting, for each agent, we consider the set of items they value the most. If there exists an agent such that none of their most-valued items have the same color as them, then these items can be safely discarded, as allocating them to any agent would make this agent envious. On the other hand, if for every agent there exists at least one most-valued item that has the same color as them, then assigning each agent such an item yields an envy-free allocation. The key idea here is that we can either find an envy-free allocation, or restrict the search-space by a significant amount.
Our setting is more technically challenging since we need to work with approximate envy-freeness, enforce connectivity constraints, and accommodate agents that receive multiple items. For this reason, we encode the restriction of the search space using a target vector , and an allocation attains the target for agent , if the valuation that agent has for their own bundle is between and . The algorithm guesses a set of properties (of which there are only FPT many) of the valid and envy-free allocation we are searching for, sets the target vector so that , where denotes the valuation of agent ’s favorite item, and runs a subroutine that searches for a valid and envy-free allocation that respects these guesses.
The subroutine has an outer loop which, following the key idea from the simpler setting, either finds a solution or decreases the target in each iteration. To prove correctness, we must show that if there exists a valid and envy-free allocation that respects the guesses and attains a target that is at most the current one, then the algorithm does one of the following: it either returns a valid and -envy-free allocation, or identifies an agent such that no valid and envy-free allocation that respects the guesses and attains a target that is at most the current one attains the current target for agent . We design a procedure that achieves this by observing that the guesses constrain the instances to the point that the allocations corresponding to each agent can be searched for independently of each other. Finding such a feasible assignment for each individual agent is done by reducing to a weighted version of the well studied Graph Motif problem, first introduced by Lacroix et al. [28]. This concludes our sketch.
We remark that a subtle but crucial aspect for the correctness of the algorithm is that the feature guessing must be performed outside the subroutine. Additionally, we draw the reader’s attention to the fact that we consider two subtly different versions of the problem. In the optional setting, agents may be assigned an empty bundle, whereas in the mandatory setting, each agent must receive a non-empty set of items. Gahlawat and Zehavi [21] study only the mandatory setting. Our results apply to both the optional and mandatory settings. We first establish our results for the optional setting and then show how they extend to the mandatory case.
1.2 Related Work
Fair division of indivisible goods have recieved a considerable amount of attention in the computational social choice literature, an interested reader can refer some of the recent surveys [4, 34]. The work introducing the fair division of indivisible items with connectivity requirements on the players’ bundles was carried out by Bouveret et al. [11]. Their initial results inspired a series of follow-up studies on the model. This body of work includes studies on conditions guaranteeing the existence of fair allocations [8], achieving various fairness notions such as Pareto-optimal allocations [26] and maximin share allocations [25]. Additionally, Aziz et al. [5] examined scenarios where the items to be allocated could be either goods or bads. There has also been work, examining the price of connectivity [6], which evaluates the loss in fairness when allocation are required to be connected, when compared to an optimal disconnected allocation. The study of connected fair division where only a subset of the items are to be allocated, was initiated by Gahlawat and Zehavi [21]. Related notions that have been explored in literature include donating a few items to achieve fairness [16] and imposing cardinality constraints on the number of items of different types that an agent can receive [9].
The concept of finding approximately fair allocations that are at most a small multiplicative (or additive factor) unfair to the agents was introduced by Lipton et al. [29] in the concept of cake-cutting and later on by Budish [15] in the context of indivisible goods. Since then, it has been studied across a variety of settings and fairness notions, including envy-freeness [32], Nash social welfare [2], and max–min fairness [23, 20], among others.
The area of parameterized complexity has found notable use in fair division literature, as many fundamental problems in this domain are (unsurprisingly) NP-hard. The works most relevant to ours include that of Deligkas et al. [18], which provides a comprehensive overview of the parameterized complexity of -CFD with respect to the natural parameters as well as several structural parameters of the graph for various fairness notions, and that of Gahlawat and Zehavi [21] which does the same for for the -ICFD problem. There is a large body of work separate from this [31, 10], which consider fair division problems from a parameterized perspective with the added requirement of Pareto-optimality. The works of Bredereck et al. [13, 12] apply -fold Integer Programming to solve problems concerning envy-free and Pareto-efficient allocations of items, with the latter even handling instances where input numbers are given in binary representation. Furthermore, the problem of finding locally envy-free allocations, where the input includes a graph in which vertices represent agents, and an agent can only envy their neighbors in the graph have also been explored [7, 14].
2 Preliminaries
For a positive integer , let be the set , and denote the set of integers that satisfies and . Let . For vectors , we write (respectively, ) to mean that (respectively, ), where and denote the -th coordinates of and , for every . Furthermore, we use to denote the vector that satisfies for every . We consider finite, simple, undirected graphs. For standard graph terminology we refer to the book by Diestel [19]. We make a slight departure from standard notations by denoting the number of vertices in a graph by .
An input instance of the Envy-Free Incomplete Connected Fair Division problem consists of a tuple , where,
-
, the utility graph, is a graph on vertices
-
is the set of agents, where
-
is an -tuple of valuation functions
-
is a non-negative integer
The vertices of are referred to as items. As is standard in literature, we assume that agents have additive valuations and use to denote for any . An allocation of items is a tuple , where is referred to as the bundle of agent . When clear from the context, we sometimes abuse notations and use to denote , the set of allocated vertices. An allocation is valid if it allocates exactly vertices in total, with each bundle being connected and no vertex allocated to multiple bundles. An allocation is envy-free if no agent desires another agent’s bundle more than their own. Formally, an allocation that is both valid and envy-free must satisfy,
-
-
is connected
-
for every pair of distinct agents
-
for every pair of agents
Similarly, an allocation is -envy-free, for some positive real number , if it satisfies for every agent and . Given an instance , the Envy-Free Incomplete Connected Fair Division problem asks whether there exists an allocation in that is both valid and envy-free. Here we remark that there are two subtly different versions of the problem. In the mandatory setting, each agent must be assigned a non-empty bundle; that is, for every agent . In contrast, the optional setting allows agents to receive empty bundles, meaning for all . Throughout this paper, we use the shorthand EF-ICFD to refer to the envy-free incomplete connected fair division problem in the optional setting.
Two agents have the same type if for every . We use to denote the set of all agent types in an instance of EF-ICFD. Thus is a partition of such that two agents , belong to the same part if and only if they have the same type. For ease of notation, we shall drop the subscript whenever it is clear from the context. We say that an instance of EF-ICFD is in unary (respectively, in binary) if the valuation functions in are encoded in unary (respectively, binary). This means there exists a polynomial (respectively, exponential) function such that .
For standard terminology in parameterized algorithms, we refer to the book Parameterized Algorithms [17] by Cygan et al. An -perfect hash family [30] is a family of functions from to such that for every with , there exists a function in the family that is injective on . The following is known regarding -perfect hash families.
An Efficient Parameterized Approximation Scheme (EPAS) for an optimization problem with input size and parameter is an algorithm that, for every , runs in time for some computable function , and returns a -approximate solution (or -approximate solution for maximization problems) to .
3 W[1] Hardness of EF-ICFD Parameterized by p and |A|
To show W[1]-hardness of EF-ICFD parameterized by and , we reduce from -Vector-Sum, a multidimensional version of the classic NP-hard problem Subset Sum. We begin by formally defining the problem and stating a known result regarding its complexity.
Definition 3.1.
For positive integers , , , and , the -Vector-Sum problem is defined as follows: given a tuple , where , and , determine whether there exists a subset of cardinality , such that .
Proposition 3.2 (Lemma 4.1 - [1]).
-Vector-Sum is W[1]-hard parameterized by even when .
With the definition of -Vector-Sum in place, we are now prepared to describe the reduction.
3.1 The Reduction
Let be an instance of -Vector-Sum with dimensions. We define the following instance of EF-ICFD:
-
Let be a star with center , and leaves. We assign a unique label to each leaf using elements of the set , where and . With a slight abuse of notation, we use the label to refer to the corresponding vertex.
-
Let . We assign a unique label to each agent using elements of the set . Here as well, we slightly abuse notation, and use the label to refer to the corresponding agent.
-
.
-
For every , we define
-
For every , we define
-
for every
3.2 Proof of Correctness
We shall prove that has a valid and envy-free allocation if and only if has a subset of cardinality , such that . To this end, we make some observations about the properties that any valid and envy-free allocation in the instance must satisfy. Note that since the graph is a star and since the bundles must be connected, only the agent who is allocated the center of the star gets more than one vertex. Furthermore, every agent must receive at least one vertex. Otherwise, as each agent has zero valuation for at most vertices, and since a total of vertices must be allocated, any agent with an empty bundle would be envious of some other agent. Hence, for exactly vertices to be assigned in total, one agent must receive and the others must receive one vertex each. Now, since values every vertex equally, they must receive exactly vertices; otherwise, they would envy the agent who has more than one vertex. With this, we are ready to prove a key property of this instance.
Lemma 3.3.
In any valid and envy-free allocation in , every agent except must be allocated the vertex they value the most.
Proof.
Let us consider agent . Observe that, if contains a vertex for some , then it cannot be assigned to , since is valid. Therefore, irrespective of which vertex is assigned to , we have , which contradicts the assumption that is envy-free. Hence must not contain any vertex from the set and by a similar argument from . Now observe that, according to any agent distinct from , we have . Therefore, for to not be envious of , we must have . But this can only be achieved if is assigned the vertex they value the most. Hence, in the allocation , agent must receive and agent must receive for every . This concludes the proof of the lemma.
This gives us all the tools we need to prove the main lemma.
Lemma 3.4.
The instance admits a valid and envy-free allocation if and only if there exists a subset of cardinality such that in the instance .
Proof.
Let be a valid and envy-free allocation in . According to lemma 3.3, in , agent and must be allocated and respectively, for every . Furthermore, we also have that agent must be allocated exactly vertices. Let these vertices be . We claim that the set satisfies in the instance . Observe that, as is envy-free, is at most and is at most . This implies that,
Hence if has a valid and envy-free allocation, then there exists a set that satisfies in the instance .
Let be a set of cardinality , such that, in the instance . Consider an allocation which allocates to , to , and to for every . We claim that is a valid and envy-free allocation in . Observe that, for every agent , we have, . Furthermore, for every and agent , we have . Finally, for every and agent , we have . Consequently, is envy-free for the instance . Since allocates a total of vertices as disjoint, connected subsets to the agents by definition, its validity follows. This completes the proof of the lemma.
By combining Proposition 3.2 and Lemma 3.4 with the properties of the reduction, we obtain Theorem 1.1
Theorem 1.1. [Restated, see original statement.]
Envy-Free Incomplete Connected Fair Division is W[1]-hard parameterized by , with the input numbers provided in unary representation, even on star graphs.
Proof.
Given an instance of -Vector-Sum with dimensions, let be an instance of EF-ICFD constructed according to Subsection 3.1. Observe that in our construction is a star graph, and . Furthermore, the range of all valuation functions are bounded above by which implies that the instance is in unary and that . Finally, given , we can construct in time. Therefore, the statement of the theorem follows from Proposition 3.2 and Lemma 3.4.
We conclude by remarking that this hardness proof extends to the mandatory setting without modification, as the properties of the constructed instance ensure that, in any envy-free allocation, every agent is assigned a non-empty set. Consequently, both directions of the proof remain valid even in this context.
4 Approximation Scheme for EF-ICFD Parameterized by p and
We begin this section by stating and proving the reduction rule that helps us upper bound the number of agents in an instance of EF-ICFD by a function of and .
Lemma 4.1.
There exists an algorithm that takes as input an instance of EF-ICFD, runs in time, and outputs an instance of EF-ICFD such that admits a valid and envy-free allocation if and only if admits one, and furthermore, the number of agents of type in is at most , for every .
Proof.
We define , , and . To define , consider each agent type . If there are at most agents of type in , we include all of them in . Otherwise, we include an arbitrary selection of agents of type in . It is clear from definition of that the number of agents of type in is at most , for every . Hence to prove the lemma, it suffice to prove that admits a valid and envy-free allocation if and only if admits one.
To this end, let be a valid and envy-free allocation in . We define an allocation in , where for agent , we have if and otherwise. Since the validity of follows directly from that of we are left with proving envy-freeness. Note that no agent is envious of agents in , since they are allocated the empty bundle. Furthermore, agents in are not envious of each other since is an envy-free allocation. Finally, agents of are not envious of agents in , since corresponding to an agent , there exists an agent who has the same type and is not envious of anyone in . Therefore, we conclude that is a valid and envy-free allocation in .
Now, let be a valid and envy-free allocation in . Let be an injective function with the property that and are of the same type, and every agent in who is allocated a non-empty bundle under lies in the image of . Such a function exists because at most agents receive non-empty bundles under , and includes all agents from types with at most agents, as well as at least agents from types that has more than agents in . We define an allocation in by setting for each . Since is a valid and envy-free allocation in , and is obtained by relabeling agents via a injection that preserves types, it follows that is also valid and envy-free in . This concludes the proof of the lemma.
Observation 4.2.
If is an instance of EF-ICFD obtained after applying the algorithm of Lemma 4.1, then
Observation 4.3.
If is the instance of EF-ICFD obtained after applying the algorithm of Lemma 4.1 to , then given a valid and envy-free allocation for , we can construct one for in time.
Observation 4.2 follows from the fact that each agent is associated with a type in , and the lemma guarantees that no type in the output instance has more than agents. Observation 4.3 follows from the construction described in the proof of Lemma 4.1, which shows how to obtain a valid and envy-free allocation for the original instance from one for the output instance.
Now, we state a lemma that serves as a subroutine in the algorithm. Since it is not central to the main discussion, we defer its proof to the end of the section.
Lemma 4.4.
There exists an algorithm that, given a graph , a weight function , and a partition of into parts, runs in time and outputs a connected subgraph of that maximizes subject to the constraint that for every , if such a subgraph exists, and correctly reports that no such subgraph exists otherwise.
Now, let be an instance of EF-ICFD and be a positive real number. We make the following definitions corresponding to and . Let denote the positive root of the equation , and define and . Finally, for positive real number and , let denote , if and otherwise.
Definition 4.5.
We define a bucket profile to be a tuple , where is a partition of , is a partition of , and is a function such that, for every pair of distinct agents , we have .
Referring back to the high-level sketch of the algorithm in Section 1, we note that the set corresponds to the partitioning obtained through color coding, captures the guess that maps colors to agents, and encodes the guessed features of the allocation. In particular, represents the guess on how far apart (in terms of powers of ) the valuation of a vertex in color class and the valuation of the bundle allocated to agent is, with respect to , in the valid and envy-free allocation we are searching for. The following definition formalizes what it means for an allocation to be consistent with the guesses.
Definition 4.6.
An allocation in respects a bucket profile if it satisfies the following:
-
For every agent and , we have if , and otherwise;
-
For every agent , , and , we have
-
–
or if , and,
-
–
and otherwise.
-
–
Finally, we formally define the target vector and what it means for an allocation to be consistent with it.
Definition 4.7.
Let . We define a target vector and use to denote the entry of associated with agent . An allocation attains the target for agent , if .
For the rest of the discussion, for ease of notation, we drop the subscript and , whenever it is clear from context.
The following lemma is the main subroutine of the algorithm.
Lemma 4.8.
There exists an algorithm that, given an instance of EF-ICFD, a positive real number , a bucket profile , and a target vector , runs in time and returns one of the following:
-
A valid and -envy-free allocation , or
-
An agent such that no valid and envy-free allocation that respects the bucket profile attains a target vector , where with .
Proof.
We define vertex to be eligible if, letting be such that , for every agent with , we have or . Let be the subgraph of induced by the eligible vertices in . We define a subgraph of to be colorful, if for every . Before describing the algorithm, we prove the following claims:
Claim 4.9.
If for every agent there exists a connected, colorful subgraph of satisfying the inequality , then the allocation defined by is a valid and -envy-free allocation.
Proof.
We begin by observing that are pairwise disjoint. Otherwise, if there exists a vertex for some pair of distinct agents , then which implies that either belongs to two distinct sets in , which contradicts the fact that is a partition of , or the set containing belongs to both and , which contradicts the fact that is a partition of . Moreover, we have , since is a partition of . Finally, as each is connected by definition, it follows that is a valid allocation.
Now, to prove -envy-freeness, consider , agent such that , and vertex . If is positive, then . Moreover, since is non-negative and is eligible, it follows that . Therefore, whenever is positive, we have the following inequality, :
| (1) |
Thus, if are distinct agents, then,
where the first transition follows from the fact that contains exactly one vertex from each for ; the second follows from inequality (4); the third uses the observation that there are at most elements with and the assumption that is a bucket profile, which implies ; the fourth and fifth follow from the definitions of , , and . Therefore, is -envy-free, which completes the proof of the claim.
Claim 4.10.
If there exists an agent such that no connected, colorful subgraph of satisfies , then there does not exist a valid and envy-free allocation that respects and attains a target vector , where is a target vector that satisfies and .
Proof.
Let be an agent such that no connected, colorful subgraph of satisfies . Let be a target vector that satisfies and . Suppose for contradiction that there exists a valid and envy-free allocation that respects , and attains .
Since is valid, is connected. Moreover, as attains , we have . Furthermore, observe that since respects , each vertex in belongs to a distinct set in whose indices belong to , which ensures that is colorful. Finally, to show that is a subgraph of , note that for every , , and agent that is distinct from , if then we have . As attains , it follows that , which implies . Hence, every vertex in is eligible, and consequently, is a subgraph of . Hence, is a connected, colorful subgraph of satisfying , which contradicts the definition of . This completes the proof of the claim.
Algorithm.
For each agent , the algorithm computes the graph , defined to be the subgraph of induced by the eligible vertices in . It calls the algorithm of Lemma 4.4 with input as a subroutine to compute a maximum-weight connected, colorful subgraph of . If for every agent a subgraph is found, for which , then the algorithm returns the allocation defined by . Otherwise, it returns an agent for which no connected, colorful subgraph satisfying could be found.
The correctness of the algorithm follows from Claims 4.9 and 4.10, along with the correctness of the subroutine. The running time bound follows from the fact that the subroutine takes time, along with the observation that all other steps of the algorithm run in time. This completes the proof of Lemma 4.8.
With this we are ready to prove Theorem 1.2.
Theorem 1.2. [Restated, see original statement.]
There exists an algorithm that, given an instance of Envy-Free Incomplete Connected Fair Division with input numbers in binary representation, and a positive real number , runs in time and outputs either a valid and -envy-free allocation , or correctly states that does not admit a valid and envy-free allocation.
Proof.
If the instance satisfies , then we apply the algorithm from Lemma 4.1 to obtain a new instance , for which we have , by Observation 4.2. We then solve and, using Observation 4.3 and Lemma 4.1, reconstruct a solution for the original instance , incurring only a negligible overhead of time. Therefore, for the remainder of the proof, we may assume that we are working with an instance that satisfies .
Now, let us fix an arbitrary labeling on using the set . We say that a partition of is induced by a function , if for every , we have that if and only if , where denotes the label of . Let denote the set of all bucket profiles that belong to the set , where is the set of partitions of induced by elements of an -perfect hash family of size whose existence is guaranteed by Proposition 2.1, is the set of all partitions of the set into parts, where some parts may be empty, and is the set of all functions from to . Let , and define a target vector , where for each .
Algorithm.
For each bucket profile in , the algorithm initializes the target vector to . It then invokes the algorithm from Lemma 4.8 as a subroutine. If it returns a valid and -envy-free allocation , the algorithm outputs and terminates. Otherwise, upon receiving an agent , it updates by reducing by one and iterates by invoking the algorithm from Lemma 4.8 again. This loop continues until some entry of becomes equal to negative two, at which point the algorithm proceeds to the next bucket profile in . If no allocation is found after all elements of have been considered, the algorithm concludes that the instance admits no valid and envy-free allocation.
To prove correctness of the algorithm, assume that is an instance of EF-ICFD that has a valid and envy-free allocation . We only need to show that the algorithm returns an allocation, since by Lemma 4.8, any allocation that is returned by the subroutine and consequently the algorithm will be valid and -envy-free. Toward this end, we make the following claim.
Claim 4.11.
If is an instance of EF-ICFD that has a valid and envy-free allocation , then there exists a bucket profile that is respected by .
Proof.
Let be an element of , such that for every , we have that . To see that such an element exists, observe that since is a valid allocation, the sets are pairwise disjoint and , which implies that . Thus, the set of labels assigned to vertices in forms a subset of of size . By the definition of an -perfect hash family, there exists a function that is injective on this set, and this function induces a partition of satisfying the desired property. Let be a partition of such that belongs to if and only if . Finally, for every agent , and , define, if it is less than and , and otherwise. The tuple is a bucket profile, since for any pair of distinct agents , we have:
Finally, since respects the bucket profile by definition, the lemma follows.
Let be the bucket profile in that is respected by , whose existence is guaranteed by Claim 4.11. Let denote the target vector attained by , where for each . We claim that, while the algorithm processes the bucket profile , it never considers any target vector for which for some . Suppose, for contradiction, that it does. Let be the first such target vector considered by the algorithm and be the target vector of the previous iteration. Let be the agent returned by the subroutine while considering and . By definition of , we have that and for every such that , which implies and . But, since is a valid and envy-free allocation that respects and attains for agent , by the correctness of Lemma 4.8, agent cannot be returned by the subroutine in the iteration corresponding to and target vector . Thus, we conclude that while the algorithm processes the bucket profile , it never considers any target vector for which for some . Observe that this suffices to prove that the algorithm returns an allocation, since the algorithm begins the iteration corresponding to with , and in every iteration where it does not return an allocation, it decreases for some . Therefore, if the algorithm never encounters a target vector with for any , it must eventually consider , before reaching a target vector with at least one entry equal to negative two. By the correctness of the subroutine in Lemma 4.8, an allocation must be returned at this point, since is a valid and envy-free allocation that respects and attains for every agent . This concludes the proof of correctness of the algorithm.
Finally, the running time bound of follows from the fact that the subroutine runs in time, together with the observation that the algorithm considers at most bucket profiles in , and that the entries of can be decreased at most times before at least one of them becomes negative.
We remark that this algorithm extends to the mandatory setting with only minor modification. In particular, it suffices to strengthen the definition of a bucket profile to ensure that the partition only contains non-empty sets. The correctness of the algorithm then follows with straightforward changes to account for this additional constraint.
Finally, we conclude the section by restating Lemma 4.4 and describing the algorithm it refers to.
Lemma 4.4. [Restated, see original statement.]
There exists an algorithm that, given a graph , a weight function , and a partition of into parts, runs in time and outputs a connected subgraph of that maximizes subject to the constraint that for every , if such a subgraph exists, and correctly reports that no such subgraph exists otherwise.
Proof.
Let be a subgraph of . We use the term weight of to mean the quantity . We describe a dynamic programming algorithm that computes the weight of the maximum-weight connected subgraph of that satisfies for every , if such a subgraph exists. Using standard backtracking techniques or self-reduction, a subgraph that realizes this value can be recovered with, in the worst case, an additional overhead of in the running time.
First, let us describe a function , where denotes the set of all subsets of .
| (2) |
It is straightforward to observe that computes the weight of the maximum-weight connected subgraph of that contains the vertex . The algorithm constructs a dynamic programming table , where and , by filling entries in increasing order of starting with singleton sets. The entries corresponding to larger sets, are computed using the recurrence of function in Definition (2), after replacing recursive calls to with lookups to the table at the corresponding indices. After populating the table states, the algorithm checks the value of . If it is the algorithm reports that no such subgraph exists, otherwise it returns the value. The correctness of the algorithm follows from an induction on the size of the subset in the definition of the table entries. Finally, we observe that the running time is upper bounded by , which concludes the proof of the lemma.
5 Concluding Remarks and Discussion
We prove that EF-ICFDis W[1]-hard parameterized by , even when the input numbers are in unary representation and provide an EPAS parameterized by for the problem even when input is in binary representation. We remark that our algorithm outperforms the brute force algorithm running in when . This regime remains practically relevant, particularly in scenarios involving the allocation of expensive or limited goods.
Beyond envy-freeness, other fairness notions have been explored in the incomplete and connected setting. Gahlawat and Zehavi [21] investigated three such notions, including EF1 and EFX, which relax envy-freeness by requiring that envy disappears once the most (respectively, least) valuable item is removed from every other agent’s bundle. They showed that finding an EF1 (EFX) allocation parameterized by is W[1]-hard when the input is given in binary representation. Our results may provide a starting point for answering related questions to these relaxed fairness concepts.
References
- [1] Amir Abboud, Kevin Lewi, and Ryan Williams. Losing weight by gaining edges. In Andreas S. Schulz and Dorothea Wagner, editors, Algorithms - ESA 2014, pages 1–12, Berlin, Heidelberg, 2014. Springer Berlin Heidelberg. doi:10.1007/978-3-662-44777-2_1.
- [2] Hannaneh Akrami, Bhaskar Ray Chaudhury, Martin Hoefer, Kurt Mehlhorn, Marco Schmalhofer, Golnoosh Shahkarami, Giovanna Varricchio, Quentin Vermande, and Ernest van Wijland. Maximizing nash social welfare in 2-value instances. Proceedings of the AAAI Conference on Artificial Intelligence, 36(5):4760–4767, June 2022. doi:10.1609/aaai.v36i5.20402.
- [3] Noga Alon, Raphael Yuster, and Uri Zwick. Color-coding. J. ACM, 42(4):844–856, July 1995. doi:10.1145/210332.210337.
- [4] Georgios Amanatidis, Haris Aziz, Georgios Birmpas, Aris Filos-Ratsikas, Bo Li, Hervé Moulin, Alexandros A Voudouris, and Xiaowei Wu. Fair division of indivisible goods: Recent progress and open questions. Artificial Intelligence, 322:103965, 2023. doi:10.1016/j.artint.2023.103965.
- [5] Haris Aziz, Ioannis Caragiannis, Ayumi Igarashi, and Toby Walsh. Fair allocation of indivisible goods and chores. Auton. Agents Multi Agent Syst., 36(1):3, 2022. doi:10.1007/s10458-021-09532-8.
- [6] Xiaohui Bei, Ayumi Igarashi, Xinhang Lu, and Warut Suksompong. The price of connectivity in fair division. SIAM journal on Discrete Mathematics, 36(2):1156–1186, 2022. doi:10.1137/20m1388310.
- [7] Aurélie Beynier, Yann Chevaleyre, Laurent Gourvès, Ararat Harutyunyan, Julien Lesca, Nicolas Maudet, and Anaëlle Wilczynski. Local envy-freeness in house allocation problems. Autonomous Agents and Multi-Agent Systems, 33:591–627, 2019. doi:10.1007/s10458-019-09417-x.
- [8] Vittorio Bilò, Ioannis Caragiannis, Michele Flammini, Ayumi Igarashi, Gianpiero Monaco, Dominik Peters, Cosimo Vinci, and William S Zwicker. Almost envy-free allocations with connected bundles. Games and Economic Behavior, 131:197–221, 2022. doi:10.1016/j.geb.2021.11.006.
- [9] Arpita Biswas and Siddharth Barman. Fair division under cardinality constraints. In Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI 2018, July 13-19, 2018, Stockholm, Sweden, IJCAI’18, pages 91–97. ijcai.org, 2018. doi:10.24963/ijcai.2018/13.
- [10] Bernhard Bliem, Robert Bredereck, and Rolf Niedermeier. Complexity of efficient and envy-free resource allocation: Few agents, resources, or utility levels. In Subbarao Kambhampati, editor, Proceedings of the Twenty-Fifth International Joint Conference on Artificial Intelligence, IJCAI 2016, New York, NY, USA, 9-15 July 2016, IJCAI’16, pages 102–108. AAAI Press, 2016. URL: http://www.ijcai.org/Abstract/16/022.
- [11] Sylvain Bouveret, Katarína Cechlárová, Edith Elkind, Ayumi Igarashi, and Dominik Peters. Fair division of a graph. In Carles Sierra, editor, Proceedings of the Twenty-Sixth International Joint Conference on Artificial Intelligence, IJCAI 2017, Melbourne, Australia, August 19-25, 2017, IJCAI’17, pages 135–141. ijcai.org, 2017. doi:10.24963/ijcai.2017/20.
- [12] Robert Bredereck, Andrzej Kaczmarczyk, Dušan Knop, and Rolf Niedermeier. High-multiplicity fair allocation using parametric integer linear programming. In ECAI 2023, pages 303–310. IOS Press, 2023. doi:10.3233/FAIA230284.
- [13] Robert Bredereck, Andrzej Kaczmarczyk, Dušan Knop, and Rolf Niedermeier. High-multiplicity fair allocation: Lenstra empowered by n-fold integer programming. In Proceedings of the 2019 ACM Conference on Economics and Computation, EC ’19, pages 505–523, New York, NY, USA, 2019. Association for Computing Machinery. doi:10.1145/3328526.3329649.
- [14] Robert Bredereck, Andrzej Kaczmarczyk, and Rolf Niedermeier. Envy-free allocations respecting social networks. Artificial Intelligence, 305:103664, 2022. doi:10.1016/j.artint.2022.103664.
- [15] Eric Budish. The combinatorial assignment problem: approximate competitive equilibrium from equal incomes. In Proceedings of the Behavioral and Quantitative Game Theory: Conference on Future Directions, BQGT ’10, New York, NY, USA, 2010. Association for Computing Machinery. doi:10.1145/1807406.1807480.
- [16] Ioannis Caragiannis, Evi Micha, and Nisarg Shah. A little charity guarantees fair connected graph partitioning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 36, pages 4908–4916, 2022. doi:10.1609/aaai.v36i5.20420.
- [17] Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Daniel Marx, Marcin Pilipczuk, Michal Pilipczuk, and Saket Saurabh. Parameterized Algorithms. Springer Publishing Company, Incorporated, 1st edition, 2015. doi:10.1007/978-3-319-21275-3.
- [18] Argyrios Deligkas, Eduard Eiben, Robert Ganian, Thekla Hamm, and Sebastian Ordyniak. The parameterized complexity of connected fair division. In Zhi-Hua Zhou, editor, Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence, IJCAI-21, pages 139–145. International Joint Conferences on Artificial Intelligence Organization, August 2021. Main Track. doi:10.24963/ijcai.2021/20.
- [19] Reinhard Diestel. Graph Theory, volume 173 of Graduate texts in mathematics. Springer, 5th edition, 2012.
- [20] Uriel Feige, Ariel Sapir, and Laliv Tauber. A tight negative example for mms fair allocations. In International Conference on Web and Internet Economics, pages 355–372. Springer, 2021. doi:10.1007/978-3-030-94676-0_20.
- [21] Harmender Gahlawat and Meirav Zehavi. Parameterized Complexity of Incomplete Connected Fair Division. In Patricia Bouyer and Srikanth Srinivasan, editors, 43rd IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2023), volume 284 of Leibniz International Proceedings in Informatics (LIPIcs), pages 14:1–14:18, Dagstuhl, Germany, 2023. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.FSTTCS.2023.14.
- [22] Jiarui Gan, Warut Suksompong, and Alexandros A Voudouris. Envy-freeness in house allocation problems. Mathematical Social Sciences, 101:104–106, 2019. doi:10.1016/j.mathsocsci.2019.07.005.
- [23] Jugal Garg and Setareh Taki. An improved approximation algorithm for maximin shares. In Proceedings of the 21st ACM Conference on Economics and Computation, EC ’20, pages 379–380, New York, NY, USA, 2020. Association for Computing Machinery. doi:10.1145/3391403.3399526.
- [24] Jonathan Goldman and Ariel D. Procaccia. Spliddit: unleashing fair division algorithms. SIGecom Exch., 13(2):41–46, January 2014. doi:10.1145/2728732.2728738.
- [25] Gianluigi Greco and Francesco Scarcello. The complexity of computing maximin share allocations on graphs. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 2006–2013, 2020. doi:10.1609/aaai.v34i02.5572.
- [26] Ayumi Igarashi and Dominik Peters. Pareto-optimal allocation of indivisible goods with connectivity constraints. In Proceedings of the AAAI conference on artificial intelligence, volume 33, pages 2045–2052, 2019. doi:10.1609/aaai.v33i01.33012045.
- [27] Russell Impagliazzo and Ramamohan Paturi. On the complexity of k-sat. Journal of Computer and System Sciences, 62(2):367–375, 2001. doi:10.1006/jcss.2000.1727.
- [28] Vincent Lacroix, Cristina G Fernandes, and Marie-France Sagot. Motif search in graphs: application to metabolic networks. IEEE/ACM transactions on computational biology and bioinformatics, 3(4):360–368, 2006. doi:10.1109/TCBB.2006.55.
- [29] Richard J Lipton, Evangelos Markakis, Elchanan Mossel, and Amin Saberi. On approximately fair allocations of indivisible goods. In Proceedings of the 5th ACM Conference on Electronic Commerce, pages 125–131, 2004. doi:10.1145/988772.988792.
- [30] Moni Naor, Leonard J. Schulman, and Aravind Srinivasan. Splitters and near-optimal derandomization. In 36th Annual Symposium on Foundations of Computer Science, FOCS 1995, Milwaukee, Wisconsin, USA, 23-25 October 1995, FOCS ’95, pages 182–191, USA, 1995. IEEE Computer Society. doi:10.1109/SFCS.1995.492475.
- [31] Trung Thanh Nguyen and Jörg Rothe. Fair and efficient allocation with few agent types, few item types, or small value levels. Artificial Intelligence, 314:103820, 2023. doi:10.1016/j.artint.2022.103820.
- [32] Benjamin Plaut and Tim Roughgarden. Almost envy-freeness with general valuations. SIAM Journal on Discrete Mathematics, 34(2):1039–1068, 2020. doi:10.1137/19M124397X.
- [33] Hugo Steinhaus. The problem of fair division. Econometrica, 16:101–104, 1948.
- [34] Warut Suksompong. Constraints in fair division. SIGecom Exch., 19(2):46–61, December 2021. doi:10.1145/3505156.3505162.
