Reforming an Unfair Allocation by Exchanging Goods
Abstract
Fairly allocating indivisible goods is a frequently occurring task in everyday life. Given an initial allocation of the goods, we consider the problem of reforming it via a sequence of exchanges to attain fairness in the form of envy-freeness up to one good (EF1). We present a vast array of results on the complexity of determining whether it is possible to reach an EF1 allocation from the initial allocation and, if so, the minimum number of exchanges required. In particular, we uncover several distinctions based on the number of agents involved and their utility functions. Furthermore, we derive essentially tight bounds on the worst-case number of exchanges needed to achieve EF1.
Keywords and phrases:
fair division, indivisible goods, envy-freeness, exchangesCopyright and License:
2012 ACM Subject Classification:
Theory of computation Algorithmic game theory ; Theory of computation Design and analysis of algorithms ; Theory of computation Problems, reductions and completenessFunding:
This work was partially supported by the Singapore Ministry of Education under grant number MOE-T2EP20221-0001, by JST PRESTO under grant number JPMJPR20C1, by JSPS KAKENHI under grant number JP20H05795, by JST ERATO under grant number JPMJER2301, and by an NUS Start-up Grant.Acknowledgements:
We would like to thank the anonymous reviewers for their valuable comments.Editors:
Ho-Lin Chen, Wing-Kai Hon, and Meng-Tsung TsaiSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Fair division is a research area that studies how to allocate scarce resources to interested agents in a fair manner. Over the past several decades, a large body of work has developed on concepts and algorithms for fairly allocating various types of resources [6, 27, 28, 30]. The developed theory has also been applied to many allocation scenarios in practice [9, 17, 19, 23].
A ubiquitous fair division problem is the allocation of indivisible goods, such as books, furniture, paintings, and human resources. While numerous fairness notions have been proposed for allocating indivisible goods, one of the most prominent notions is envy-freeness up to one good (EF1). This notion requires that if an agent envies another agent, there must exist a good in the latter agent’s bundle whose removal would make the envy disappear. Besides its simplicity, a salient feature of EF1 is that an allocation satisfying it always exists and can be found, e.g., by the round-robin algorithm, which lets the agents pick their favorite goods in a round-robin fashion. The allocation returned by this algorithm is also balanced, meaning that the numbers of goods that any pair of agents receive differ by at most one.
The fair division literature typically assumes that there is a set of unallocated goods and the objective is to allocate them fairly. In certain scenarios, however, an existing (possibly unfair) allocation of the goods is already in place, and the goal is to “reform” it in order to arrive at a fair allocation. This is the case, for instance, in the allocation of personnel among teams in an organization. As the personnel experience individual growth or decline, and as the needs of the teams evolve, these changes can necessitate a reevaluation and potential reformation of the current allocation by the organization leadership. Another example is the distribution of a museum’s exhibits across its branches – the museum director may decide to adjust the distribution so as to ensure fairness based on the most recent valuations. Such scenarios fall under the umbrella of control problems, which assume a central authority with the power to control the outcome and have been studied extensively in fair division and computational social choice [11, 15].
In this work, we shall allow agents to exchange pairs of goods in the reformation process, and use EF1 as our fairness criterion. Exchanges constitute a fundamental type of operation and preserve the size of each agent’s bundle, thereby ensuring that any cardinality constraints remain fulfilled.111Capacity constraints are prevalent in fair division applications and have accordingly received interest in the literature [4, 21, 32, 33]. Naturally, given an initial allocation, we wish to reach an EF1 allocation using a small number of exchanges. However, it is sometimes impossible to reach an EF1 allocation via any finite number of exchanges (e.g., if one agent receives many more goods than another agent in the initial allocation), so we start by exploring whether the corresponding decision problem can be answered efficiently. Since this problem is equivalent to determining whether an EF1 allocation with a certain size vector exists in a given instance, it is also meaningful independently of exchange considerations.222A size vector specifies the number of goods that each agent receives in an allocation. When an EF1 allocation is not guaranteed to exist in some instances due to cardinality requirements, an approach taken by previous work is to relax the EF1 condition (e.g., [33]). However, this leads to unnecessarily weak guarantees in instances where EF1 can be attained. We also investigate other important questions in this setting. Namely, if it is possible to reach an EF1 allocation, can we efficiently determine the smallest number of exchanges required to achieve this goal? And how many exchanges might we need to make in the worst case in order to attain EF1?
1.1 Our Results
In our model, there is an initial allocation of a set of goods. As is often assumed in fair division, each agent has an additive utility function over the goods. At each step of the reformation process, two agents can exchange a pair of goods with each other to obtain another allocation, and the goal is to reach an EF1 allocation at the end of the process. More details on our model are provided in Section 2.
In Section 3, we consider the decision problem of determining whether a given initial allocation can be reformed into an EF1 allocation. As mentioned earlier, this problem is equivalent to determining whether an EF1 allocation with a given size vector exists, so we focus on the latter decision problem instead. We demonstrate interesting distinctions in the complexity based on the number of agents and their utility functions. Specifically, in the case of two agents, the problem can be solved in polynomial time if the agents have identical utilities, but becomes (weakly) NP-complete otherwise. For three or more agents, the problem is NP-complete even with identical utilities; however, it can be solved efficiently when the utilities are binary333This means that each agent has utility or for each good. provided that the number of agents is constant. Finally, for an arbitrary (non-constant) number of agents, the problem is strongly NP-hard even for identical utilities and NP-hard for binary utilities,444For binary utilities, there is no distinction between weak and strong NP-hardness. but can be solved in polynomial time if the utilities are identical and binary. The results of this section are summarized in Table 1.
Having determined the reformability of the initial allocation, we next explore in Section 4 the problem of deciding whether the optimal (i.e., minimum) number of exchanges required to reach an EF1 allocation is at most some given number . For (a) two agents with identical utilities, (b) a constant number of agents with binary utilities, and (c) any number of agents with identical binary utilities, we show that this problem can be solved in polynomial time, just like the corresponding decision problem in Section 3. For the remaining scenarios, since deciding whether an allocation is reformable is already NP-complete (from Section 3), we instead focus on the special case where the allocation is balanced – an EF1 allocation is guaranteed to be reachable in this case (see Proposition 2). We show that the problem for this special case remains NP-complete.
Finally, in Section 5, instead of considering specific instances, we derive worst-case bounds on the number of exchanges necessary to reach an EF1 allocation. We assume that each of the agents possesses goods – this again ensures that an EF1 allocation is reachable. We show that roughly exchanges always suffice for instances with general utilities or with binary utilities; moreover, our bound is essentially tight for any and , and exactly tight when as well as when is divisible by . For instances with identical binary utilities, we show that an essentially tight bound for the number of exchanges is for even and for odd .
All omitted proofs can be found in the full version of our paper [34].
1.2 Additional Related Work
As mentioned earlier, the majority of work in fair division assumes that there is no initial allocation of the resources – we now discuss the key exceptions and their differences from our model. Boehmer et al. [5] studied the problem of discarding goods from an initial allocation in order to reach an envy-free or EF1 allocation. As it is possible to reallocate the goods in several practical situations, discarding them can be unnecessarily wasteful for the agents involved. In a similar vein, Dorn et al. [14] investigated deleting goods to attain another fairness notion called proportionality; they assumed that agents have ordinal preferences (rather than cardinal utilities) over the goods, and considered both the settings with and without an initial allocation.555When there is no initial allocation, Dorn et al. [14] considered deleting goods so that a proportional allocation of the remaining goods exists. Aziz et al. [2] examined discarding or adding goods to achieve envy-freeness, also in the absence of an initial allocation and under ordinal preferences. Instead of deleting goods, Bredereck et al. [8] allowed agents to share goods in order to improve their allocations, while Bentert et al. [3] analyzed the resolution of envy by adding goods. Aziz et al. [1] focused on reallocating goods to make agents better off, but did not delve into the aspect of fairness. Igarashi et al. [22] aimed to transition from an initial allocation to a target allocation, both of which are EF1, while maintaining EF1 throughout the process. Chandramouleeswaran et al. [10] examined transferring goods starting from a “near-EF1” allocation with the goal of reaching an EF1 allocation. Segal-Halevi [31] considered the reallocation of a divisible good and explored the trade-off between guaranteeing a minimum utility for every agent and ensuring each agent a certain fraction of her original utility. Chevaleyre et al. [12] also strived to reach fair allocations but via exchanges with money.
Further afield, the idea of improving an initial allocation has also been examined when each agent receives only one good, a setting sometimes known as a housing market. Gourvès et al. [18] assumed an underlying social network and allowed beneficial exchanges between agents who are neighbors in the network – their work led to a series of follow-up papers on similar models [20, 25, 26, 29]. Damamme et al. [13] also considered exchanges but without an underlying graph structure, while Brandt and Wilczynski [7] used Pareto-optimality as their target notion. The papers mentioned so far in this paragraph did not have fairness as their objective. Ito et al. [24] incorporated fairness in the form of envy-freeness into this setting – starting with an envy-free allocation, they let each agent exchange her current good with a preferred unassigned good as long as the exchange keeps the allocation envy-free.
2 Preliminaries
Let be a set of agents, and be a set of goods typically denoted by . A bundle is a (possibly empty) subset of goods. An allocation is an ordered partition of into bundles such that bundle is allocated to agent . An (allocation) size vector is a vector of non-negative integers such that . We say that an allocation has size vector if for all . A size vector is balanced if for all , and an allocation is balanced if it has a balanced size vector.
Each agent has an additive utility function that maps bundles to non-negative real numbers; additivity means that for all and . We write instead of for a single good . The utility functions are identical if for all – we shall use to denote the common utility function in this case. The utility functions are binary if for all and . Agent is EF1 towards agent in an allocation if either or there exists a good such that . An allocation is EF1 if every agent is EF1 towards every other agent in . A (fair division) instance consists of a set of agents , a set of goods , and the agents’ utility functions .
An exchange involves an agent giving one good from her bundle to agent and simultaneously receiving one good from agent ’s bundle. We say that allocations and can be reached via an exchange if there exist distinct , , and such that , , and for all . An allocation can be reached from an allocation if there exist a non-negative integer and a sequence of allocations such that , , and for each , and can be reached via an exchange. The optimal number of exchanges required to reach from is the smallest across all such sequences of allocations – if no such exists (i.e., cannot be reached from ), then the optimal number of exchanges is defined to be .666The optimal number of exchanges can be viewed as the distance between the two allocations in the implicit exchange graph, where the allocations are vertices and the edges connect allocations that can be reached via an exchange [22]. When there is no path connecting two vertices of a graph, it is common to define the distance between them as infinity. Observe that two allocations can be reached from each other if and only if they share the same size vector.
Proposition 1.
Given an instance, let and be allocations in the instance. Then, can be reached from if and only if and have the same size vector.
Next, we state a simple proposition that characterizes the existence of EF1 allocations based on the size vector.
Proposition 2.
Let , and let .
-
(a)
If is balanced, then every instance with agents and goods admits an EF1 allocation with size vector .
-
(b)
If is not balanced, then there exists an instance with agents and goods that does not admit any EF1 allocation with size vector .
Finally, we introduce an NP-hard decision problem called the Balanced Multi-Partition problem, which we will use later in the proofs of several results. In Balanced Multi-Partition, we are given positive integers and a multiset of positive integers such that for all , and the sum of all the integers in is . The problem is to decide whether can be partitioned into multisets of equal cardinalities and sums, i.e., for each , the cardinality of is and the sum of all the integers in is . The NP-hardness of this problem is based on a reduction from the equal-cardinality version of the NP-hard problem Partition [16, p. 223].
Proposition 3.
For any fixed , Balanced Multi-Partition is NP-hard.
3 Reformability of Allocations
We start by investigating the decision problem of whether a given initial allocation can be reformed into an EF1 allocation. By Proposition 1, this reformation is possible if and only if there exists an EF1 allocation with the same size vector as the initial allocation. Therefore, in the rest of this section, we shall equivalently focus on the problem of deciding the existence of an EF1 allocation with a given size vector – this problem can be of interest independently of reformation considerations, e.g., when space constraints are present.
Now, Proposition 2 tells us that an EF1 allocation with a balanced size vector always exists. This means that the only time when we may have difficulties in ascertaining whether an EF1 allocation exists is when the given size vector is not balanced. In fact, as some of our proofs in this section show, the decision problem is NP-hard even when the sizes of the agents’ bundles differ by exactly two (e.g., in Theorem 6).
We discuss the cases of two agents, a constant number of agents, and a general number of agents separately. For each case, we explore how the hardness of the decision problem varies across different classes of utility functions. Our results are summarized in Table 1.
For convenience, we refer to as Reformability the problem of deciding whether an EF1 allocation with a given size vector exists in a given instance. Note that Reformability is in NP regardless of the number of agents, as we can verify in polynomial time whether a given allocation satisfies the condition by simply checking its size vector and comparing the bundles of every pair of agents for EF1.
3.1 Two Agents
For two agents, interestingly, the computational complexity of the problem turns out to be different depending on whether the agents have identical utilities or not. We begin our discussion with the case of identical utilities.
For two agents with identical utilities, we first provide a characterization for the existence of a desired EF1 allocation based on the size vector and the utilities of the goods. We show that an EF1 allocation with a given size vector exists if and only if the agent with fewer goods (say, agent ) is EF1 towards the other agent (say, agent ) in the allocation where agent receives the most valuable goods. Note that the condition in the lemma only requires checking that agent is EF1 towards agent ; in particular, it does not require checking that agent is EF1 towards agent .
Lemma 4.
Given an instance with two agents with identical utilities, let be a size vector with . Assume that the goods are arranged in non-increasing order of utility, and let . Then, there exists an EF1 allocation with size vector if and only if agent is EF1 towards agent in the allocation .
Proof.
We say in this proof that for any nonempty set , the good is the most valuable good in if is the good with the smallest index in ; likewise, is the least valuable good in if is the good with the largest index in . Note that the most (resp. least) valuable good in is the one with the highest (resp. lowest) utility among all the goods in , with ties broken by index.
Let be an EF1 allocation with size vector . Let and be the most valuable good in and respectively. Since is the set containing the most valuable goods, we have . Since is an EF1 allocation, we have . Moreover, since is the set containing the least valuable goods, we have . Combining the three inequalities, we get . It follows that agent is EF1 towards agent in the allocation .
Suppose that agent is EF1 towards agent in the allocation . If agent is also EF1 towards agent in , then we are done; therefore, assume that agent envies agent by more than one good. For notational simplicity, let for , so that the goods arranged in non-increasing order of utility are . Let and .
Let . In the allocation , agent is EF1 towards agent , but agent envies agent by more than one good. Since is the most valuable good in , we have . Let and be the bundles after exchanging and . Then, we have
so agent is EF1 towards agent in . If agent is also EF1 towards agent , then is an EF1 allocation and we are done. Otherwise, agent envies agent by more than one good, and we increment by and repeat the discussion in this paragraph.
If we still have not found an EF1 allocation after , then agent is EF1 towards agent in , where and , and is the most valuable good in . This implies that
which means that agent is not EF1 towards agent in . This is a contradiction; therefore, must be EF1 for some .
Since the condition in Lemma 4 can be checked in polynomial time, we can derive the following result.
Theorem 5.
Reformability is in P for two agents with identical utilities.
While deciding whether an EF1 allocation with a given size vector exists can be done efficiently for two agents with identical utilities, we remark here that deciding whether an envy-free allocation exists is NP-hard for two agents with identical utilities even if we allow any size vector – this follows directly from a reduction from Partition.777If we require both agents to receive the same number of goods, the problem for envy-freeness remains NP-hard by a reduction from the equal-cardinality version of Partition.
We now proceed to general utilities. Lemma 4 assumes identical utilities, and there is no obvious way to generalize it to non-identical utilities. In fact, perhaps surprisingly, we show that the decision problem becomes NP-hard when we drop the assumption of identical utilities. The proof follows from a reduction from Balanced Multi-Partition with , an NP-hard problem by Proposition 3.
Theorem 6.
Reformability is weakly NP-complete for two agents.
Proof.
Clearly, this problem is in NP. The “weak” aspect is demonstrated later in Lemma 7, which says that there exists a pseudopolynomial-time algorithm that solves this problem for any constant number of agents. Therefore, it suffices to show that this problem is NP-hard.
To demonstrate NP-hardness, we shall reduce from the NP-hard problem Balanced Multi-Partition with (see Proposition 3). Let a Balanced Multi-Partition instance be given with . Without loss of generality, assume that . Let be a multiset such that for , , and . We claim that can be partitioned into two multisets and of equal cardinalities (i.e., of size each) with sums and respectively if and only if can be partitioned into two multisets and of equal cardinalities and sums. If the latter condition holds, then let (resp. ) contain the corresponding elements in (resp. ), and let and – this gives an appropriate partition of . Conversely, if the former condition holds, then we show that can be partitioned appropriately. Note that if , then there are at least integers in that are also in . Since every integer in is more than , the sum of will be more than , which is a contradiction. This means that . Similarly, if , then there are exactly integers in that are in . The sum of will be more than , which is a contradiction. Hence, . Now, this means that must be partitioned into two multisets of equal cardinalities with sum each. This induces an appropriate partition of .
Next, define a fair division instance as follows. There are agents and a set of goods . Agent ’s utility is such that for , , and . Agent ’s utility is such that for all . The size vector is . This reduction can be done in polynomial time. We claim that there exists an EF1 allocation with size vector in this instance if and only if can be partitioned into two multisets and of equal cardinalities (i.e., of size each) with sums and respectively.
Let and be a partition of of equal cardinalities such that and . Let and be the two agents’ bundles respectively. From agent ’s perspective, agent ’s bundle has utility , agent ’s bundle has utility , and a most valuable good in agent ’s bundle (e.g., ) has utility , so agent is EF1 towards agent . From agent ’s perspective, agent ’s bundle has utility , agent ’s bundle has utility , and a most valuable good in agent ’s bundle (e.g., ) has utility , so agent is EF1 towards agent . Accordingly, is an EF1 allocation with size vector .
Let be an EF1 allocation with size vector . From agent ’s perspective, and a most valuable good (e.g., ) has utility . For agent to be EF1 towards agent , we must have and . This means that and . On the other hand, from agent ’s perspective, and a most valuable good has utility . For agent to be EF1 towards agent , we must have and . This means that and . By combining these inequalities, we conclude that these inequalities are tight, i.e., agent ’s utilities for both agents’ bundles are exactly and respectively so that the sum is , and agent ’s utilities for both agents’ bundles are exactly and respectively so that the sum is . Additionally, both agents must each have a most valuable good worth and to them respectively. Without loss of generality, we may assume that and (note that is also a most valuable good, but we use and for simplicity).
Since , there are goods in and . These goods are chosen from and . Recall from the construction that for all , and for all . If contains at least goods from , then , a contradiction. Therefore, contains at most goods from , and at least goods from . Since , we must have . Note that , so . Therefore, the goods from in agent ’s bundle have a total utility of . These goods, together with , induce the set with cardinality and sum . Then, and give a required partition of .
The proof of Theorem 6 suggests that the problem is NP-hard even when the sizes of the two agents’ bundles differ by exactly two. Note that this problem is in P when the sizes of the agents’ bundles differ by at most one (in fact, every such instance is a Yes-instance by Proposition 2). For two agents with binary utilities, we shall show later that the decision problem is in P (see Theorem 10).
3.2 Constant Number of Agents
Next, we discuss the complexity of the decision problem for a constant number of agents. In this case, we devise a pseudopolynomial-time algorithm for deciding the existence of an EF1 allocation with a given size vector. This algorithm uses dynamic programming to check for such an allocation.
Lemma 7.
Let an instance with agents and a size vector be given, where is a constant. Suppose that the utility of each good is an integer, and let . Then, there exists an algorithm running in time polynomial in and that decides whether the instance admits an EF1 allocation with the size vector.
Proof.
The algorithm uses dynamic programming. We construct a table with columns and rows, where will be specified later. The index of each row is represented by a tuple containing , , and for each , i.e., . The value of is the utility of agent ’s bundle from agent ’s perspective, i.e., ; the value of is the utility of a most valuable good in agent ’s bundle from agent ’s perspective, i.e., (note that this value is zero if ); and the value of is the number of goods in agent ’s bundle. Note that and , so there are rows, which is polynomial in and . An entry in column represents whether an allocation involving is possible for the tuple representing the row, and is either positive or negative.
Initialize every entry to negative. Consider the possibilities of adding to each of the agents’ bundles respectively, and set the corresponding entries in the first column of the table to positive. In particular, for each , the row represented by the tuple such that and for all , and zero for all other values in the tuple, has the entry (in the first column) set to positive.
Now, for each in ascending order, for each positive entry in column , consider the possibilities of adding into each of the agents’ bundles respectively, and set the corresponding entry for each of these possibilities in column to positive. Once this procedure is done, consider all positive entries in column . If some positive entry corresponds to an EF1 allocation with the required size vector, then the instance admits such an EF1 allocation; otherwise, no such allocation exists.
Since is a constant, the number of entries in the table is polynomial in and . At each column, there is a polynomial number of rows with positive entries, and hence the update is polynomial. Finally, checking for a feasible EF1 allocation at the last column can also be done in polynomial time.
We now move to polynomial-time algorithms that determine the existence of an EF1 allocation with a given size vector. Recall that such an algorithm exists for two agents with identical utilities (Theorem 5). However, it turns out that such an algorithm does not exist for three or more agents with identical utilities, unless . In particular, we establish the NP-hardness of the decision problem via a reduction from Balanced Multi-Partition with , an NP-hard problem by Proposition 3.
Theorem 8.
Reformability is weakly NP-complete for agents with identical utilities, where is a constant.
Proof.
Clearly, this problem is in NP. The “weak” aspect is demonstrated in Lemma 7. Therefore, it suffices to show that this problem is NP-hard.
To show NP-hardness, we shall reduce from the NP-hard problem Balanced Multi-Partition with (see Proposition 3). Let a Balanced Multi-Partition instance with be given. Define a fair division instance as follows. There are agents with identical utilities, and a set of goods such that for and for . The size vector is such that and for all . This reduction can be done in polynomial time. We claim that there exists an EF1 allocation with size vector in this instance if and only if can be partitioned into multisets of equal cardinalities and sums.
Let be such a partition. Define an allocation such that agent receives for , agent additionally receives the goods corresponding to the integers in , and agent additionally receives the goods corresponding to the integers in . We show that this allocation is EF1. The utilities of agent ’s and agent ’s bundles are each, and the utilities of the other agents’ bundles are each, so agents and do not envy anyone else. Therefore, it remains to check that agent is EF1 towards agents and for . Upon the removal of the single good (resp. ) from agent ’s (resp. agent ’s) bundle, the remaining bundle has utility , so agent is EF1 towards agent (resp. agent ). Therefore, the allocation is EF1, as desired.
Let be an EF1 allocation with size vector . If agent ’s bundle has at least two goods from , then her bundle without the most valuable good has utility more than since her bundle also contains other goods with positive utility. Agent , having a bundle of utility at most , will not be EF1 towards agent , contradicting the assumption that the allocation is EF1. Therefore, agent ’s bundle has at most one good from ; likewise for agent ’s bundle. This means that every agent receives exactly one good from . Having established this, agent ’s bundle has a utility of , and agent is EF1 towards agent . This means that agent ’s bundle without a most valuable good (say, some ) must have utility at most . The same argument can be used to show the same statement for agent ’s bundle. This means that the goods must be divided between agents and with each agent receiving a utility of exactly . Such a division of induces a partition of into two multisets of equal cardinalities and sums, as desired.
Since the decision problem is NP-hard even for identical utilities, it must also be NP-hard for general utilities. We now consider another class of utilities: binary utilities. When there are agents, every good belongs to one of types of goods represented by the vector . For the purpose of determining whether an EF1 allocation exists, it suffices to consider different goods of the same type as indistinguishable. We say that two allocations are in the same equivalence class if the number of goods of each type that each agent has is the same in both allocations. If is an EF1 allocation, then all allocations in the same equivalence class as are also EF1 and are reachable from . We shall proceed with a result which enumerates all (essentially equivalent) EF1 allocations in time polynomial in the number of goods, provided that the number of agents is a constant.
Lemma 9.
Let an instance with agents with binary utilities and a size vector be given, where is a constant. Then, there exists an algorithm running in time polynomial in that outputs all equivalence classes of EF1 allocations with the size vector.
Proof.
An agent’s bundle can be represented by a -vector where each component of the vector is the number of goods of that type in her bundle. Since the number of goods of each type is an integer between and , there are possible values for each component, and hence at most possible vectors to represent each agent’s bundle. Allocations in an equivalence class can be represented by an ordered collection of such vectors – one for each agent – and there are at most such collections. Since is polynomial in whenever is a constant, there is at most a polynomial number of possible equivalence classes of allocations in the instance. For each of these equivalence classes of allocations, we can check whether an allocation in the equivalence class is EF1 and has the required size vector in polynomial time, and output the equivalence class if so. Therefore, the overall running time is polynomial in , as claimed.
Lemma 9 implies that the decision problem can be solved efficiently for binary utilities.
Theorem 10.
Reformability is in P for a constant number of agents with binary utilities.
3.3 General Number of Agents
For any constant number of agents, the problem of determining the existence of an EF1 allocation with a given size vector is weakly NP-hard by Theorem 8 (even for identical utilities). For a general number of agents, the pseudopolynomial-time algorithm as described in Lemma 7 does not work, since that algorithm is at least exponential in the number of agents. Therefore, the decision problem for a general number of agents might not be weakly NP-hard. We show that the problem is indeed strongly NP-hard, even for identical utilities, by a reduction from -Partition, a strongly NP-hard problem [16, p. 224].
Theorem 11.
Reformability is strongly NP-complete for identical utilities.
The reduction in Theorem 11 requires us to check whether the set of agents holding the goods with utilities equal to the integers in the partition problem is EF1 towards the remaining agents. This stands in contrast to the reduction in Theorem 8, which entails checking whether the complementary set of agents is EF1 towards the remaining agents.
For binary utilities, the decision problem for a constant number of agents is in P (Theorem 10). The crucial reason is that in this case, the number of different types of goods is also a constant, which allows us to enumerate all the (essentially equivalent) EF1 allocations in polynomial time (Lemma 9). This is no longer possible when the number of agents is non-constant. In fact, we show that the decision problem is NP-hard for a general number of agents with binary utilities. To this end, we reduce from Graph -Colorability, which is NP-hard for any fixed [16, p. 191].
Theorem 12.
Reformability is NP-complete for binary utilities.
Proof.
Clearly, this problem is in NP. Therefore, it suffices to show that it is NP-hard.
To this end, we shall reduce from Graph -Colorability with . In Graph -Colorability, we are given a graph and a positive integer , and the problem is to decide whether is -colorable, i.e., whether each of the vertices in can be assigned one of colors in such a way that no two adjacent vertices are assigned the same color. This decision problem is known to be NP-hard for any fixed [16, p. 191].
Let an instance of Graph -Colorability be given with a fixed , where and . Define a fair division instance as follows. There are agents where the first agents are called edge agents and the last agents are called color agents. There are goods. Each color agent assigns zero utility to every good. For , if , then the edge agent assigns a utility of to each of and , and zero utility to every other good. Note that only the first goods correspond to vertices and are valuable to the edge agents whose corresponding edges are incident to the vertices; the remaining goods are not valuable to any agent. The size vector is such that for each edge agent and for each color agent . This reduction can be done in polynomial time. We claim that there exists an EF1 allocation with size vector in this instance if and only if is -colorable.
Let a proper -coloring of be given. For , if vertex is assigned the color , then allocate to the color agent . Since there are such goods and each color agent is supposed to have goods in her bundle, it is possible to allocate all of these goods. Subsequently, allocate the remaining goods arbitrarily among the color agents until every color agent has exactly goods. We claim that this allocation is EF1. Every color agent assigns zero utility to every good and is thus EF1 towards every other agent. Each edge agent assigns a utility of to only two goods, so we only need to check that these two goods are in different bundles. Indeed, these two goods correspond to vertices which are adjacent to each other in , and proper coloring of implies that the vertices are of different colors, so the corresponding goods are in different color agents’ bundles. Hence, the allocation is EF1.
Let an EF1 allocation with size vector be given. For , if the good is with color agent , assign to color . We claim that this coloring is a proper -coloring of . Since there are color agents, at most colors are used. Therefore, it suffices to check that adjacent vertices are assigned different colors. Let be adjacent vertices. Then, there exists an edge . The edge agent assigns a utility of to each of and . Since agent ’s bundle is empty, and must be in different (color agents’) bundles in order for agent to be EF1 towards every other agent. This implies that and are assigned different colors.
Even though the decision problem is NP-hard for identical or binary utilities, we prove next that it can be solved in polynomial time for identical and binary utilities. Indeed, this can be done by checking whether the total number of valuable goods is within a certain threshold which can be computed in polynomial time. This threshold is in fact the sum over all agents of the minimum between and . If the number of valuable goods is within this threshold, then we can distribute the valuable goods in a round-robin fashion first, thereby ensuring EF1. Conversely, if the number of valuable goods is beyond this threshold, then some agent with the minimum will not be EF1 towards another agent who receives at least valuable goods.
Theorem 13.
Reformability is in P for identical binary utilities.
4 Optimal Number of Exchanges
In this section, we consider the complexity of computing the optimal number of exchanges required to reach an EF1 allocation from an initial allocation.
Recall that the decision problem in Section 3 is to determine whether there exists an EF1 allocation that can be reached from a given initial allocation. This is equivalent to determining whether the optimal number of exchanges to reach an EF1 allocation is finite or not. We have established a few scenarios where there exist polynomial-time algorithms for this task: (a) two agents with identical utilities (Theorem 5), (b) any constant number of agents with binary utilities (Theorem 10), and (c) any number of agents with identical binary utilities (Theorem 13). For these scenarios, we can run the respective polynomial-time algorithms to decide whether such an EF1 allocation exists – if none exists, then the optimal number of exchanges is . Therefore, for the proofs in this section pertaining to these scenarios, we proceed with the assumption that such an EF1 allocation exists. We will show that the problem of computing the optimal number of exchanges for these scenarios is also in P; our algorithms can be modified to compute an optimal sequence of exchanges as well.
For the remaining scenarios where the decision problem in Section 3 is NP-hard, it is NP-hard to even decide whether the optimal number of exchanges to reach an EF1 allocation is finite or not. Therefore, for these scenarios, we shall focus on the special case where the given size vector is balanced, so that the optimal number of exchanges is guaranteed to be finite (see Proposition 2). Even with this assumption, we will show that the computational problem for these scenarios remains NP-hard.
For convenience, we refer to as Optimal Exchanges the problem of deciding – given an instance, an initial allocation in the instance, and a number – whether the optimal number of exchanges required to reach an EF1 allocation is at most . Note that the optimal number of exchanges in the scenarios mentioned above are finite. By the proof of Proposition 1, the optimal number of exchanges in these scenarios is polynomial in the number of agents and the number of goods. As a result, Optimal Exchanges is in NP regardless of the number of agents, as we can easily verify whether an exchange path starting from the given initial allocation indeed reaches an EF1 allocation using at most exchanges.
We begin with the case of two agents. For two agents with identical utilities, we show that there exists a polynomial-time algorithm that computes the optimal number of exchanges. This algorithm performs the exchanges until an EF1 allocation is reached, while keeping track of the number of exchanges required. The algorithm is “greedy” in the sense that at each step, it performs an exchange involving the most valuable good from the agent whose bundle has the higher utility, and the least valuable good from the other agent. We demonstrate that this choice is the best for the number of exchanges required to reach an EF1 allocation.
Theorem 14.
Optimal Exchanges is in P for two agents with identical utilities.
Proof.
We show that we can compute the optimal number of exchanges in polynomial time. We assume that an EF1 allocation with the given size vector exists. If the initial allocation is EF1, we are done. Otherwise, assume without loss of generality that agent has a higher utility than agent in . Let be the size vector. By rearranging the labels of the goods, assume that the goods are in non-increasing order of utility, i.e., . The algorithm proceeds as follows: repeatedly exchange the most valuable good in agent ’s bundle with the least valuable good in agent ’s bundle until agent is EF1 towards agent . The optimal number of exchanges required is then the number of exchanges made in this algorithm.
First, we claim that in each exchange, a good from in agent ’s bundle is always exchanged with a good from in agent ’s bundle. Suppose on the contrary that this is not true. Let be the allocation just before we make the exchange that violates this claim. The only way for the claim to be violated is when and . If , then by Lemma 4, there does not exist an EF1 allocation with size vector – this would contradict our assumption that an EF1 allocation with size vector exists. Otherwise, , and every good in has a higher utility than every good in , so agent is EF1 towards agent . This would contradict our assumption that the algorithm has not terminated. Hence, the claim is true.
By the claim in the previous paragraph, the total number of exchanges made is at most . Each exchange can be performed in polynomial time, and so the algorithm terminates in polynomial time. We show next that an EF1 allocation is obtained when the algorithm terminates. It suffices to show that agent is EF1 towards agent in the final allocation. To this end, we show that agent is EF1 towards agent at every step of the algorithm. Let the initial allocation be , and let be the allocation after steps of the algorithm. Note that satisfies the condition that agent is EF1 towards agent , since agent has a higher utility than agent in . We show that if has the property that agent is EF1 towards agent and agent is not EF1 towards agent , then has the property that agent is EF1 towards agent . Suppose that is exchanged with ; note that is a good with the highest utility in . This means that . Then,
showing that agent is EF1 towards agent in .
Finally, we show that the optimal number of exchanges required to reach an EF1 allocation is at least the number of exchanges made in this algorithm. Let be the number of exchanges made in this algorithm. For each , let (resp. ) be the good in agent ’s bundle (resp. agent ’s bundle) that is exchanged at the step of the algorithm. Note that . Also, we have , where is a good with the highest utility in agent ’s bundle in . Suppose on the contrary that only exchanges are required to reach an EF1 allocation. Since is not EF1, we have . Let be the EF1 allocation after the exchanges. The utility of is upper-bounded by the utility of after adding goods of the highest utility from and removing goods of the lowest utility from , so
On the other hand, the utility of without the most valuable good is lower-bounded by the utility of after adding goods of the lowest utility from and removing goods of the highest utility from , so we have
for every . This gives the inequality for all . Hence, agent is not EF1 towards agent in , contradicting the assumption that is EF1. It follows that at least exchanges are required to reach an EF1 allocation.
However, if the utilities are not identical, then computing the optimal number of exchanges is NP-hard, even for balanced allocations. To show this hardness, we modify the construction from the proof of Theorem 6.
Theorem 15.
Optimal Exchanges is NP-complete for two agents, even when the initial allocation is balanced.
Proof.
Clearly, this problem is in NP. To demonstrate NP-hardness, we modify the construction from the proof of Theorem 6. Recall that we have with for , , and . A fair division instance is defined with agents and a set of goods . Agent ’s utility is such that for , , and . Agent ’s utility is such that for all . The size vector is . In Theorem 6, it was proven that there exists an EF1 allocation with size vector in this instance if and only if can be partitioned into two multisets and of equal cardinalities (i.e., of size each) with sums and respectively. Both problems were proven to be NP-hard.
Define a new fair division instance as follows. There are agents and a set of goods . For , the utility of for each agent is identical to that in the original fair division instance . For , we have for . The size vector is . In the initial allocation , agent has and agent has . This reduction can be done in polynomial time. We claim that the optimal number of exchanges required to reach an EF1 allocation from is at most in if and only if there exists an EF1 allocation with size vector in .
Let be an EF1 allocation with size vector in . Note that and . In , exchange the goods from with any goods in . This requires a total of exchanges. The new allocation has exactly the same goods as that in along with other goods with zero utility, and so is EF1. Therefore, the optimal number of exchanges to reach an EF1 allocation from is at most .
Suppose that an EF1 allocation is reached from after exchanges in . We may assume that every good is not exchanged more than once. By the same reasoning as in the proof of Theorem 6, we must have and . Since goods are transferred from , we have . This means that the inequalities for are tight, and we have and . Letting , we have and . Since is an EF1 allocation, the allocation that removes all goods with zero utility is also EF1, namely, . This induces an EF1 allocation with size vector in .
While a polynomial-time algorithm to compute the optimal number of exchanges exists for two agents with identical utilities, this is not the case for three or more agents unless . Indeed, we establish the NP-hardness of this problem via a reduction from Balanced Multi-Partition with , an NP-hard problem by Proposition 3.
Theorem 16.
Optimal Exchanges is NP-complete for agents with identical utilities, where is a constant, even when the initial allocation is balanced.
Next, we consider binary utilities. We have shown that deciding whether the optimal number of exchanges to reach an EF1 allocation is finite can be done in polynomial time (Theorem 10). We now establish that the same is true for computing this exact number.
Theorem 17.
Optimal Exchanges is in P for a constant number of agents with binary utilities.
Let us now consider a non-constant number of agents. We have shown that computing the optimal number of exchanges required to reach an EF1 allocation is NP-hard, even for identical utilities (Theorem 16). We thus consider binary utilities.
Although this problem belongs to P when the number of agents is a constant (Theorem 17), we show that it is NP-hard for a general number of agents, even for the special case where the initial allocation is balanced. To this end, we reduce from Exact Cover by 3-Sets.
Theorem 18.
Optimal Exchanges is NP-complete for binary utilities, even when the initial allocation is balanced.
Finally, we consider identical binary utilities. We show that for this class of utilities, the computational problem can be solved efficiently regardless of whether the size vector of the initial allocation is balanced or not. To show this, we demonstrate that the greedy algorithm allows an EF1 allocation to be reached using the smallest number of exchanges.
Theorem 19.
Optimal Exchanges is in P for identical binary utilities.
5 Worst-Case Bounds
In this section, instead of instance-specific optimization, we turn our attention to the worst-case number of exchanges required to reach an EF1 allocation from some initial allocation. Since an EF1 allocation may not always be reachable (as can be seen from Section 3), we shall focus on the special case where the number of goods in each agent’s bundle is the same. We say that a size vector is -balanced for a positive integer if for all , and an allocation is -balanced if it has an -balanced size vector. We shall consider the worst-case number of exchanges starting from an -balanced allocation for agents.
Given and , let be the smallest integer such that for every instance with agents and goods and every -balanced allocation in the instance, there exists an EF1 allocation that can be reached from using at most exchanges. We shall examine the bounds for .
We first derive an upper bound for . At a high level, we use an algorithm by Biswas and Barman [4] to find an EF1 allocation under cardinality constraints such that every agent retains roughly of her goods from her original bundle. The algorithm also distributes the goods in each agent’s initial bundle to the other agents as evenly as possible in order to maximize the number of goods that can be exchanged one-to-one, thereby minimizing the total number of exchanges. One can check that roughly exchanges are required to reach this EF1 allocation from the initial allocation.
Theorem 20.
Let and be positive integers, and let and be the quotient and remainder when is divided by respectively. Then,
Moreover, we have for all .
Proof.
Let be an -balanced allocation. It suffices to find an EF1 -balanced allocation such that the optimal number of exchanges to reach from is at most the expression given in the theorem statement.
When , allocate the goods in to the two agents in a round-robin fashion with agent going first, and allocate the goods in to the two agents in a round-robin fashion with agent going first. Call this new allocation . Note that is clearly -balanced. We have for , so the optimal number of exchanges required to reach from is (exactly) . To see that is EF1, observe that agent does not envy agent with respect to the goods chosen from and is EF1 towards agent with respect to the goods chosen from , so agent is EF1 towards agent in ; likewise, agent is EF1 towards agent in . This shows that .
When , we shall find an EF1 -balanced allocation by generalizing the method for two agents. We define categories of goods as follows. For , category contains goods arbitrarily selected from only; note that goods remain unselected in . Next, we form recursively as follows: let be the smallest index such that does not have goods yet, let be the smallest index such that still has unselected goods, arbitrarily select a good in , and add it to . At the end of this process, every category has exactly goods from , and every category has exactly goods from consecutive agents’ bundles, say, .
We now proceed to form using the algorithm by Biswas and Barman [4] which finds an EF1 allocation under cardinality constraints. In particular, there exists an EF1 allocation such that for all and for all . Also, is -balanced because for all . We shall bound the number of exchanges required to reach from .
For each unordered pair of distinct , exchange the goods from (which are in ) with the goods from (which are in ). This requires a total of exchanges. Call this intermediate allocation . At this point, the only goods that are possibly in the wrong bundles in (as compared to ) are the goods in all the , and there are at most such goods. For each , let .
If , then , and we are done since the total number of exchanges is . Else, . Consider the directed graph where the vertices are the agents and each edge represents a good such that if , then . Igarashi et al. [22, Prop. 4.1] showed that the number of exchanges required to reach from is , where is the maximum possible cardinality of a partition of the edges of the graph into (directed) circuits. In , goods from all the are in the correct bundle by the previous process, and each of the edges representing these goods has its own circuit, say, if the good is in . We shall show that the edges representing the goods in all the can be partitioned into at least disjoint circuits. This will give at least as the cardinality of one such partition of the edges of the graph into circuits. Accordingly, , and the number of exchanges required to reach from is . Then, the number of exchanges required to reach from (via ) is at most , establishing the theorem.
Let be given. We shall show that there exists a cycle formed with a subset of the edges representing the goods in . The goods in come from consecutive agents’ bundles in , say, agents to . Every agent receives exactly one good from in ; in particular, agents to receive exactly one good from each. Consider the good in . If is in , then the edge is a desired cycle. Otherwise, belongs to some agent in . Then, the edge is . Next, we consider the good in , and find the agent that has in . The edge representing then points to from that agent. By repeating this, we eventually find a cycle formed with some of these edges and with a subset of the agents to as vertices. Let be the set of goods that are represented by the edges in this cycle. Note that each for contains at most one good in , and each for does not contain any good in .
Now, consider the goods represented by the edges of the cycles – one for each . Note that these cycles are disjoint since the sets are pairwise disjoint. Let . We claim that . Since the goods in are entirely contained in , we have and for , which implies that . Now, for each , the goods in can only be contained in at most two – to see this, observe that if the goods are contained in , , and , then , which implies that , a contradiction. Thus, we have for all , and for at most two , and so . Since , we have , proving the claim.
Finally, consider the edges representing the goods in all the . We have shown that fewer than of these edges can be used to form disjoint circuits (in fact, cycles). There are more than edges remaining. Since we can always require every circuit to have length at most , there exists a partition of the remaining edges into more than disjoint circuits, i.e., at least disjoint circuits. The total number of circuits in this partition is at least . This completes the proof.
If no good is involved in more than one exchange, then exchanges means that a total of goods are exchanged. When is large, the fraction of goods involved in the exchanges becomes close to . While this bound might not seem impressive, we show next that it is, in fact, already essentially tight. Specifically, we establish a lower bound for by constructing an instance (with binary utilities) and an -balanced allocation in the instance such that roughly exchanges are necessary to reach an EF1 allocation from .
Theorem 21.
Let and be positive integers, and let and be the quotient and remainder when is divided by respectively. Then,
For two agents, Theorems 20 and 21 give a tight bound of . This means that in the worst-case scenario, the number of exchanges required to reach an EF1 allocation is roughly one-quarter of the total number of goods between the two agents, or equivalently, roughly half of the goods need to be exchanged between the two agents to reach an EF1 allocation.
Theorems 20 and 21 also give a tight bound of whenever is divisible by . By observing the proof of Theorem 20, we can achieve an EF1 allocation with exchanges without involving each good in more than one exchange. This means that a fraction of all goods need to be exchanged in the worst-case scenario. Intuitively, this happens when each agent only values the goods in the bundle of every agent except her own in the initial allocation, and therefore needs to ensure that these goods are evenly distributed among all agents including herself.
Define as the smallest integer such that for every binary instance with agents and goods and every -balanced allocation in the instance, there exists an EF1 allocation that can be reached from using at most exchanges. The proof of Theorem 21 uses a binary instance, which means that the lower bound of the theorem works for as well. Clearly, the upper bound of Theorem 20 works for , so the discussion in the preceding paragraphs also applies to binary instances too.
Given and , let be the smallest integer such that for every instance with agents with identical binary utilities and goods and every -balanced allocation in the instance, there exists an EF1 allocation that can be reached from using at most exchanges. We show that is roughly for even and for odd – note that this is approximately half of the bound for arbitrary utilities, which is roughly as seen earlier. The upper bounds (of and respectively) correspond to the case where half of the agents have all the valuable goods while the remaining half have all the non-valuable goods.
Theorem 22.
Let and be positive integers. If is even, then . If is odd, then .
6 Conclusion and Future Work
We have studied the reformability of unfair allocations and the number of exchanges required in the reformation process. We uncovered several distinctions in the complexity of these problems based on the number of agents and their utility functions, and showed that the number of exchanges required to reach an EF1 allocation is relatively high in the worst case.
While our worst-case bounds for general utilities are already exactly tight in certain scenarios and almost tight generally, an open question is to tighten them for more than two agents when the number of goods in each agent’s bundle is not divisible by the number of agents. Another interesting direction is to require each exchange to be beneficial for both agents involved. One could also consider the model of transferring goods instead of exchanging them – an EF1 allocation is always reachable from any allocation in this model, so a natural question is to determine the optimal number of exchanges needed for this goal.
References
- [1] Haris Aziz, Péter Biró, Jérôme Lang, Julien Lesca, and Jérôme Monnot. Efficient reallocation under additive and responsive preferences. Theoretical Computer Science, 790:1–15, 2019. doi:10.1016/J.TCS.2019.05.011.
- [2] Haris Aziz, Ildikó Schlotter, and Toby Walsh. Control of fair division. In Proceedings of the 25th International Joint Conference on Artificial Intelligence (IJCAI), pages 67–73, 2016. URL: http://www.ijcai.org/Abstract/16/017.
- [3] Matthias Bentert, Robert Bredereck, Eva Deltl, Pallavi Jain, and Leon Kellerhals. How to resolve envy by adding goods. In Proceedings of the 34th International Joint Conference on Artificial Intelligence (IJCAI), 2025.
- [4] Arpita Biswas and Siddharth Barman. Fair division under cardinality constraints. In Proceedings of the 27th International Joint Conference on Artificial Intelligence (IJCAI), pages 91–97, 2018. doi:10.24963/IJCAI.2018/13.
- [5] Niclas Boehmer, Robert Bredereck, Klaus Heeger, Dušan Knop, and Junjie Luo. Multivariate algorithmics for eliminating envy by donating goods. Autonomous Agents and Multi-Agent Systems, 38(2):43:1–43:35, 2024.
- [6] Steven J. Brams and Alan D. Taylor. Fair Division: From Cake-Cutting to Dispute Resolution. Cambridge University Press, 1996.
- [7] Felix Brandt and Anaëlle Wilczynski. On the convergence of swap dynamics to Pareto-optimal matchings. Journal of Artificial Intelligence Research, 80:1063–1098, 2024. doi:10.1613/JAIR.1.15305.
- [8] Robert Bredereck, Andrzej Kaczmarczyk, Junjie Luo, Rolf Niedermeier, and Florian Sachse. Improving resource allocations by sharing in pairs. Journal of Artificial Intelligence Research, 78:1069–1109, 2023. doi:10.1613/JAIR.1.15001.
- [9] Eric Budish, Gérard P. Cachon, Judd B. Kessler, and Abraham Othman. Course Match: a large-scale implementation of approximate competitive equilibrium from equal incomes for combinatorial allocation. Operations Research, 65(2):314–336, 2017. doi:10.1287/OPRE.2016.1544.
- [10] Harish Chandramouleeswaran, Prajakta Nimbhorkar, and Nidhi Rathi. Fair division in a variable setting. In Proceedings of the 24th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 472–480, 2025. doi:10.5555/3709347.3743562.
- [11] Jiehua Chen, Joanna Kaczmarek, Paul Nüsken, Jörg Rothe, Ildikó Schlotter, and Tessa Seeger. Control in computational social choice. In Proceedings of the 34th International Joint Conference on Artificial Intelligence (IJCAI), 2025.
- [12] Yann Chevaleyre, Ulle Endriss, Sylvia Estivie, and Nicolas Maudet. Reaching envy-free states in distributed negotiation settings. In Proceedings of the 20th International Joint Conference on Artifical Intelligence (IJCAI), pages 1239–1244, 2007. URL: http://ijcai.org/Proceedings/07/Papers/200.pdf.
- [13] Anastasia Damamme, Aurélie Beynier, Yann Chevaleyre, and Nicolas Maudet. The power of swap deals in distributed resource allocation. In Proceedings of the 14th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 625–633, 2015. URL: http://dl.acm.org/citation.cfm?id=2773235.
- [14] Britta Dorn, Ronald de Haan, and Ildikó Schlotter. Obtaining a proportional allocation by deleting items. Algorithmica, 83(5):1559–1603, 2021. doi:10.1007/S00453-020-00794-4.
- [15] Piotr Faliszewski and Jörg Rothe. Control and bribery in voting. In Felix Brandt, Vincent Conitzer, Ulle Endriss, Jérôme Lang, and Ariel D. Procaccia, editors, Handbook of Computational Social Choice, chapter 7, pages 146–168. Cambridge University Press, 2016. doi:10.1017/CBO9781107446984.008.
- [16] Michael R. Garey and David S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman & Co., 1979.
- [17] Jonathan Goldman and Ariel D. Procaccia. Spliddit: Unleashing fair division algorithms. ACM SIGecom Exchanges, 13(2):41–46, 2014. doi:10.1145/2728732.2728738.
- [18] Laurent Gourvès, Julien Lesca, and Anaëlle Wilczynski. Object allocation via swaps along a social network. In Proceedings of the 26th International Joint Conference on Artificial Intelligence (IJCAI), pages 213–219, 2017. doi:10.24963/IJCAI.2017/31.
- [19] Jiatong Han and Warut Suksompong. Fast & Fair: a collaborative platform for fair division applications. In Proceedings of the 38th AAAI Conference on Artificial Intelligence (AAAI), pages 23796–23798, 2024. doi:10.1609/AAAI.V38I21.30568.
- [20] Sen Huang and Mingyu Xiao. Object reachability via swaps under strict and weak preferences. Autonomous Agents and Multi-Agent Systems, 34(2):51:1–51:33, 2020.
- [21] Halvard Hummel and Magnus Lie Hetland. Maximin shares under cardinality constraints. In Proceedings of the 19th European Conference on Multi-Agent Systems (EUMAS), pages 188–206, 2022. doi:10.1007/978-3-031-20614-6_11.
- [22] Ayumi Igarashi, Naoyuki Kamiyama, Warut Suksompong, and Sheung Man Yuen. Reachability of fair allocations via sequential exchanges. Algorithmica, 86(12):3653–3683, 2024. doi:10.1007/S00453-024-01271-Y.
- [23] Ayumi Igarashi and Tomohiko Yokoyama. Kajibuntan: a house chore division app. In Proceedings of the 37th AAAI Conference on Artificial Intelligence (AAAI), pages 16449–16451, 2023. doi:10.1609/AAAI.V37I13.27075.
- [24] Takehiro Ito, Yuni Iwamasa, Naonori Kakimura, Naoyuki Kamiyama, Yusuke Kobayashi, Yuta Nozaki, Yoshio Okamoto, and Kenta Ozeki. Reforming an envy-free matching. Algorithmica, 87(4):594–620, 2025. doi:10.1007/S00453-025-01294-Z.
- [25] Takehiro Ito, Naonori Kakimura, Naoyuki Kamiyama, Yusuke Kobayashi, Yuta Nozaki, Yoshio Okamoto, and Kenta Ozeki. On reachable assignments under dichotomous preferences. Theoretical Computer Science, 979:114196, 2023. doi:10.1016/J.TCS.2023.114196.
- [26] Fu Li, C. Gregory Plaxton, and Vaibhav B. Sinha. Object allocation over a network of objects: Mobile agents with strict preferences. In Proceedings of the 20th International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 1578–1580, 2021. doi:10.5555/3463952.3464165.
- [27] Hervé Moulin. Fair Division and Collective Welfare. MIT Press, 2003.
- [28] Hervé Moulin. Fair division in the internet age. Annual Review of Economics, 11:407–441, 2019.
- [29] Luis Müller and Matthias Bentert. On reachable assignments in cycles. In Proceedings of the 7th International Conference on Algorithmic Decision Theory (ADT), pages 273–288, 2021. doi:10.1007/978-3-030-87756-9_18.
- [30] Jack Robertson and William Webb. Cake-Cutting Algorithms: Be Fair if You Can. Peters/CRC Press, 1998.
- [31] Erel Segal-Halevi. Redividing the cake. Autonomous Agents and Multi-Agent Systems, 36(1):14:1–14:36, 2022.
- [32] Hila Shoshan, Noam Hazon, and Erel Segal-Halevi. Efficient nearly-fair division with capacity constraints. In Proceedings of the 22nd International Conference on Autonomous Agents and Multiagent Systems (AAMAS), pages 206–214, 2023. doi:10.5555/3545946.3598638.
- [33] Xiaowei Wu, Bo Li, and Jiarui Gan. Approximate envy-freeness in indivisible resource allocation with budget constraints. Information and Computation, 303:105264, 2025. doi:10.1016/J.IC.2024.105264.
- [34] Sheung Man Yuen, Ayumi Igarashi, Naoyuki Kamiyama, and Warut Suksompong. Reforming an unfair allocation by exchanging goods. CoRR, abs/2412.19264, 2024. doi:10.48550/arXiv.2412.19264.
