1 Introduction
The problem of fair division is concerned with allocating items to agents in a fair and efficient manner. Formally introduced by Steinhaus [29], fair division is an active area of research studied across fields like computer science and economics. Most work has focused on the fair division of goods: items which provide nonnegative value (or utility) to the agents to whom they are allocated. However, several practical scenarios involve chores (or bads). Chores are items which impose a cost (or disutility) to the agent to whom they are allocated. For instance, household chores such as cleaning and cooking often need to be fairly distributed among members of the household. Likewise, teachers have to divide teaching load, stakeholders have to divide liabilities upon dissolution of a firm, etc. These examples highlight the importance of allocating chores in a fair and efficient manner. Agencies responsible for designing such allocations must take into account the differences in preferences of agents in order for the allocation to be acceptable to all those involved.
Arguably, the most popular notion of fairness is envyfreeness (EF) [16, 30], which requires that every agent weakly prefers the bundle of items allocated to them over the bundle of any other agent. When items are divisible, i.e., can be shared among agents, EF allocations are known to exist. However, in the case of indivisible items, EF allocations need not exist. For instance, while dividing one chore between two agents, the agent who is assigned the chore will envy the other. Since the fair division of indivisible items remains an important problem, several relaxations of envyfreeness have been defined, first in the context of goods, and later adapted to chores.
A widely studied relaxation of envyfreeness is envyfreeness up to one item (EF1), defined by Budish [12] in the context of goods. For chores, an allocation is said to be EF1 if for every agent, the envy disappears after removing one chore assigned to her. It is known that an EF1 allocation of chores exists and can be efficiently computed [24, 7]. However, an EF1 allocation may be highly inefficient. Consider for example two agents and and two chores and where has almost zero cost for and high cost for the other chore. The allocation in which is assigned to and is assigned to is clearly EF1. However both agents incur high cost, which is highly inefficient. The allocation in which is assigned to is more desirable since it is both fair as well as efficient.
The standard notion of economic efficiency is Pareto optimality (PO). An allocation is said to be PO if no other allocation makes an agent better off without making someone else worse off. Fractional Pareto optimality (fPO) is a stronger notion requiring that no other fractional allocation makes an agent better off without making someone else worse off. Every fPO allocation is therefore PO, but not viceversa.
An important question is whether the fairness and efficiency notions of EF1 and PO (or fPO) can be achieved in conjunction, and if so, can they be computed in polynomialtime. For the case of goods, Barman et al. [5] showed that an EF1+PO allocation exists and can be computed in pseudopolynomial time. Improving this result, Garg and Murhekar [26] showed that an EF1+fPO allocation can be computed in pseudopolynomial time. For the case of chores, it is unclear whether EF1+PO allocations even exist, except for simple cases like identical valuations. Settling the existence of EF1+PO allocations (and developing algorithms for computing them) has turned out to be a challenging open problem.
In this paper, we present the first nontrivial results on the EF1+PO problem for chores. We study the class of bivalued instances, where there are only two costs, i.e., for every agent a chore costs either or , for two nonnegative numbers^{4}^{4}4In fact, we can assume the two values are positive, since one of them being zero implies the setting is binary, in which case computing an EF1+PO allocation is trivial by first assigning chores to agents which have 0 cost for them, and then allocating almost equal number of chores of cost 1 to everyone. and . Bivalued instances are a wellstudied class in the fair division literature, we list several works in Section 1.1. In particular, Amanatidis et al. [1] showed that allocations that are envyfree upto any good (EFX), which generalizes EF1, can be efficiently computed for bivalued goods. Recently, Garg and Murhekar [21] showed that EFX+fPO allocations can be computed in polynomialtime for bivalued goods. Showing positive results for bivalued chores, our first result is:
Result 1.
For bivalued instances with agents and indivisible chores, an EF1+fPO allocation exists and can be computed in time.
Next, we study the problem of computing an EF+PO allocation of divisible chores. For goods, it is known that an EF+PO allocation always exists [30] and is in fact polynomialtime computable via the EisenbergGale convex program [27]. This is done by computing the competitive equilibrium with equal incomes (CEEI). Here, the idea is to provide each agent with the same amount of fictitious money, and then find prices and an allocation of items such that all items are completely bought and each agent buys her most preferred bundle subject to her budget constraint. This is an example of a market where demand (of agents) equals supply (of items), and is known as the Fisher market. For goods, there are polynomialtime algorithms for computing the competitive equilibrium (CE) [15, 28, 32]. For chores, the problem is harder: Bogomolnaia et al. [9] showed that the CE rule can be nonconvex, multivalued and disconnected. Algorithms with exponential runtimes are known for computing CE for chores [11, 20, 14, 19], but designing a polynomialtime algorithm is an open problem. Working towards this goal, our second result shows:
Result 2.
For bivalued instances with agents and divisible chores, an EF+fPO allocation can be computed in time.
1.1 Further related work
Barman et al. [5] showed that for agents and goods, an EF1+PO allocation can be computed in time , where is the maximum utility value. Their algorithm first perturbs the values to a desirable form, and then computes an EF1+fPO allocation for the perturbed instance, which for a smallenough perturbation is EF1+PO for the original instance. Their approach is via integral market equilibria, which guarantees fPO at every step, and the concept of priceenvyfreeness up to one good (pEF1) which is a strengthening of EF1. Using similar tools, Garg and Murhekar [26] showed that an EF1+fPO allocation can be computed in time. They also showed that an EF1+fPO allocation can be computed in time for ary instances (agents have at most values for the goods) where is a constant. It may seem a natural idea to try and use these approaches for chores, however they do not extend easily. While our algorithm also uses integral market equilibria to obtain the fPO property and pEF1 for chores to argue about EF1, our algorithm and its analysis is much more involved and significantly different from previous works.
Bivalued preferences are a wellstudied class in literature. The following results are for the goods setting. Aziz et al. [2] showed PO is efficiently verifiable for bivalued instances and coNPhard for 3valued instances; Aziz [3], and Vazirani and Yannakakis [31] studied the HyllandZeckhauser scheme for probabilistic assignment of goods in bivalued instances; and Bogomolnaia and Moulin [10] studied matching problems with bivalued (dichotomous) preferences. More generally, instances with few values have also been studied: Barman et al. [6] showed that EF1+PO allocations can be computed for binary valuations; Babaioff et al. [4] studied truthful mechanisms for dichotomous valuations; Golovin [23] presented approximation algorithms and hardness results for computing maxmin fair allocations in 3valued instances;Bliem et al. [8] studied fixedparameter tractability for computing EF+PO allocations with parameter , where is the number of values; and Garg et al. [22] studied leximin assignments of papers ranked by reviewers on a small scale, in particular they present an efficient algorithm for 2 ranks, i.e., “high or low interest” and show NPhardness for 3 ranks. Such instances have also been studied in resource allocation contexts, including makespan minimization with 2 or 3 job sizes [33, 13].
The fairness notion of equitability requires that each agent get the same amount of utility or disutility. Similar to EF1 and EFX, equitability up to one (resp. any) item (EQ1 (resp. EQX)) are relaxations of equitability. Using approaches inspired by [5], pseudopolynomial time algorithms for computing EQ1+PO allocations were developed for both goods [17] and chores [18]. For bivalued goods, an EQX+PO allocation is polynomial time computable [21].
2 Preliminaries
Problem instance.
A fair division instance (of chores) is a tuple , where is a set of agents, is a set of indivisible chores, and is a set of cost or disutility functions, one for each agent . Each cost function is specified by numbers , one for each chore , which denotes the cost agent has for performing (receiving) chore . We assume that the cost functions are additive, that is, for every agent , and for , . For notational ease, we write instead of .
We call a fair division instance a bivalued instance if there exist , with , such that for all and , . That is, the cost of any chore to any agent is one of at most two given numbers. By scaling the costs, we can assume w.l.o.g. for bivalued instances that all costs , where . Such a scaling is w.l.o.g., since our fairness and efficiency properties are scaleinvariant. Given such an instance, we partition the set of chores into sets of lowcost chores and highcost chores :

, and

.
Further, we assume that both , since if then rescaling the values transforms the instance into the simpler binary case, for which efficient algorithms are known (Footnote 4). We can additionally assume for bivalued instances that for every agent , there is at least one chore s.t. . This is w.l.o.g., since if for all , then we can rescale costs to set for all .
Allocation.
An allocation of chores to agents is an partition of the chores, where agent is allotted and gets a total cost of . A fractional allocation is a fractional assignment such that for each chore , . Here, denotes the fraction of chore allotted to agent .
Fairness notions.
An allocation is said to be envyfree up to one chore (EF1) if for all , there exists a chore such that .
We say that an agent EF1envies an agent if for all , , i.e., the EF1 condition between and is violated.
A (fractional) allocation is said to be envyfree if for all , . We say that an agent envies an agent if , i.e., the EF condition between and is violated.
Paretooptimality.
An allocation dominates an allocation if and there exists s.t. . An allocation is said to be Pareto optimal (PO) if no allocation dominates it. Further, an allocation is said to be fractionally PO (fPO) if no fractional allocation dominates it. Thus, a fPO allocation is PO, but not viceversa.
Fisher markets.
A Fisher market or a market instance is a tuple , where the first three terms are interpreted as before, and is the set of agents’ minimum payments, where , for each
. In this model, chores can be allocated fractionally. Given a payment vector, also called a
price^{5}^{5}5We refer to payments as prices for sake of similarity with the Fisher market model in the goods case. vector, , each chore pays per unit of chore. Agents perform chores in exchange for payment. Given chore payments, each agent aims to obtain the set of chores that minimizes her total cost subject to her payment constraint, i.e., receiving a total payment of at least .Given a (fractional) allocation with a price vector , the spending^{6}^{6}6This is actually the earning of agent , but we refer to earning as spending for sake of similarity with the Fisher market model in the goods case. of an agent under is given by . We define the bangperbuck ratio of chore for an agent as , and the minimum bangperbuck (mBB) ratio as . We define , called the mBBset, to be the set of chores that give mBB to agent at prices . We say is ‘on mBB’ if for all agents and chores , . For integral , this means that for all .
A market equilibrium or market outcome is a (fractional) allocation of the chores to the agents and set of prices of the chores satisfying the following properties:

the market clears, i.e., all chores are fully allocated. Thus, for all , ,

each agent receives their minimum payment, for all , , and,

agents only receive chores that give them minimum bangperbuck, i.e., is on mBB.
Given a market outcome with integral, we say it is price envyfree up to one chore (pEF1) if for all there is a chore such that . We say that an agent pEF1envies an agent , if for all , , i.e., the pEF1 condition between and is violated. For integral market outcomes on mBB, the pEF1 condition implies the EF1 condition.
Lemma 1.
Let be an integral market outcome on mBB. If is pEF1 then is EF1 and fPO.
Proof.
We first show that forms a market equilibrium for the Fisher market instance , where for every , . It is easy to see that the market clears and each agent receives their minimum payment. Further is on mBB as per our assumption. Now the fact that is fPO follows from the First Welfare Theorem [25], which shows that for any market equilibrium , the allocation is fPO.
Since is pEF1, for all pairs of agents , there is some chore s.t. . Since is on mBB, . Let be the mBBratio of at the prices . By the definition of mBB, , and . Combining these implies is EF1. ∎
Our Algorithm 2 begins with and maintains an integral market outcome on mBB^{7}^{7}7Note that although our algorithm only maintains the allocation and prices , the associated Fisher market instance is always implicitly present by setting as in the proof of Lemma 1, and modifies and appropriately to eventually arrive at an outcome on mBB where the pEF1 condition is satisfied. Lemma 1 then ensures that is EF1+fPO.
We now define least spenders as agents with minimum spending, and big spenders as agents with maximum spending after the removal of their highestpriced chore.
Definition 1 (Least and big spenders).
An agent is referred to as a least spender (LS). An agent is referred to as a big spender (BS).
We break ties arbitrarily to decide a unique LS and BS. Together with Lemma 1, the following lemma shows that in order to obtain an EF1 allocation, it is sufficient to focus on the pEF1envy the big spender has towards the least spender.
Lemma 2.
Let be an integral market outcome on mBB. If is not EF1, then the big spender pEF1envies the least spender .
Proof.
If is not EF1, then Lemma 1 implies that is not pEF1. Hence there is a pair of agents s.t. for every chore , . By the definition of big spender, we know , for every . By the definition of least spender, . Putting these together we get for every , implying that pEF1envies . ∎
Given a market outcome on mBB, we define the mBB graph to be a bipartite graph where for an agent and chore , iff . Further, an edge is called an allocation edge if , otherwise it is called an mBB edge.
For agents and chores , a path in the mBB graph, where for all , , is called a special path. We define the level of an agent w.r.t. to be half the length of the shortest special path from to , and to be if no such path exists. A path is an alternating path if it is special, and if , i.e. the path visits agents in increasing order of their level w.r.t. . Further, the edges in an alternating path alternate between allocation edges and mBB edges. Typically, we consider alternating paths starting from a big spender agent.
Definition 2 (Component of a big spender ).
For a big spender , define to be the set of all chores and agents which lie on alternating paths of length starting from . Call the component of , i.e., the set of all chores and agents reachable from through alternating paths.
3 EF1+fPO allocation of indivisible chores
In this section, we present our main result:
Theorem 1.
Given a bivalued fair division instance of indivisible chores with all for some , an EF1+fPO allocation can be computed in strongly polynomialtime.
We prove Theorem 1 by showing that our Algorithm 2 computes an EF1+fPO allocation in polynomialtime. To ensure smooth presentation, we defer some proofs to Appendix A.
3.1 Obtaining Initial Groups
Recall that we can scale the costs so that they are in , for some . The first step of Algorithm 2 is to obtain a partition of the set of agents into groups with desirable properties. For this, we use Algorithm 1 (called ).
Algorithm 1 starts with a costminimizing market outcome where each chore is assigned to an agent who has minimum cost for . This ensures the allocation is fPO. The chore prices are set as follows. Each lowcost chore is assigned to an agent s.t. . If an agent values all chores at , then we can rescale all values to . Each lowcost chore is priced at 1, and each highcost chore is priced at . This pricing ensures that the mBB ratio of every agent is 1. The algorithm then eliminates pEF1envy from the component of the big spender by identifying an agent in that is pEF1envied by , and transferring a single additional chore to from an agent who lies along a shortest alternating path from to (Lines 7 & 8). Note that the identity of the big spender may change after transferring if belonged to , so we must check who the big spender is after each transfer (Line 10). Once the component of the current big spender is pEF1, the same process is applied to the next big spender outside the previously made components. Repeated application of this process creates disjoint partial components of agent sets , where , all of which are pEF1. We refer to as agent groups, and as initial (partial) components. Note also that the spending (up to the removal of the biggest chore) of the big spender of is weakly decreasing with . We now record several properties of the output of Algorithm 1 .
Lemma 3.
Algorithm 1 returns in time a market outcome with agents partitioned into groups , with the following properties:

For all lowcost chores , , and for all highcost chores , .

The mBB ratio of every agent is .

Let be the collection of agents and chores allocated to them in . Then each is a partial component of some agent. That is, for each , there is an agent s.t. comprises of all agents and chores not in reachable through alternating paths from . Further, is the big spender among agents not in :

The spending (up to removal of the largest chore) of the big spender in weakly decreases with . Here .

Each group is pEF1, i.e., an agent does not pEF1envy other agents in the same group.

For every agent and chore with , .

All highcost chores belong to .
Proof.
Properties (i) and (ii) follow from the construction of the initial allocation in Line 1.
Property (iii) follows from the construction of the set in Line 11. The agent is the last agent chosen in Line 10. Property (iv) then follows from the last result of (iii).
To see why (v) holds, we examine the loop in Lines 610. This loop terminates only once the big spender in the component does not pEF1envy any other agent in the component. Since every agent spends (up to the removal of one chore) less than the big spender, it must be that every agent does not pEF1envy any other agent in the component. Thus, the component is pEF1.
Next, suppose for some agent and some chore for , . Then is a lowcost chore and must be priced at 1. Hence, , implying that . However this means that would have been added to , since there is an alternating path from to via . This is a contradiction, thus showing (vi).
Next, we show (vii). Suppose a highcost chore belongs to for . We know is priced at . Then for an agent , , implying that . However this means belongs to since there is an alternating path from to via , which is a contradiction.
Finally, we argue that in making a group starting with the a new big spender in outside of previously established pEF1 groups, we do not disturb the previously established groups. Let be the current group being made, and let , where , be a previously established group. Let and be the big spenders in and , respectively. We show that no agent in gains or loses a chore. Note that there are no highcost chores in , as highcost chores are mBB for all agents so a group containing a highcost chore must be the last group . Since all chores are priced and is pEF1, every agent in has total spending either or . We also have that by construction. Thus, it cannot be that pEF1envies any agent in , so agents in will not receive any chores. Agents in also will not lose any chores, since they can only transfer chores to another agent in . However, we have already shown that agents in cannot receive chores since they will not be pEF1envied by , so these transfers are impossible. Thus, all previous groups remain undisturbed while establishing a later group. ∎
Finally, we argue that:
Lemma 4.
Algorithm 1 terminates in time .
3.2 Overview of Algorithm 2
Our main algorithm (Algorithm 2) begins by calling Algorithm 1, which returns a market outcome and a set of agent groups (with associated partial components ) satisfying properties in Lemma 3. In the subsequent discussion, we refer to as the initial allocation. Also in the subsequent discussion, all mentions of an agent receiving or losing chores are relative to this initial allocation. The following is an important invariant of Algorithm 2 (after the initial allocation is constructed).
Lemma 5.
The spending of the least spender does not decrease in the run of Algorithm 2.
We say that a group is above (resp. below) group if (resp. ). Lemma 3 shows that each group is initially pEF1. Hence if the initial allocation is not pEF1, then the big spender and the least spender must be in different components. Since , it must be the case that for some . Since we want to obtain an fPO allocation, we can only transfer along mBB edges. Hence we raise the prices of all chores in . We show that doing so creates an mBB edge from all agents to all chores (Lemma 9 below). In particular, there is an mBB edge from to a chore assigned to . Hence we transfer a chore directly from to , thus reducing the pEF1envy of . This may change the identity of the big and least spenders. If the allocation is not yet pEF1, we must continue this process.
At an arbitrary step in the run of the algorithm, let and be the big and least spenders. If the allocation is not pEF1, then pEF1envies (Lemma 2). We consider cases based on the relative positions of and . First we argue that and cannot lie in the same group, by showing that:
Lemma 6.
Throughout the run of Algorithm 2, each group remains pEF1.
Hence and must lie in different groups. Once again, since we want to transfer chores away from to reduce the pEF1envy, and we want to obtain an fPO allocation, we only transfer chores along mBB edges. Doing so may require that we raise the prices of all chores belonging to certain agents in order to create new mBB edges to facilitate chore transfer. In our algorithm, all agents in a group undergo pricerise together. We call a group a raised group if its agents have undergone pricerise, else it is called an unraised group. The set (Line 2) records the set of unraised components.
We will use the terms timestep or iteration interchangeably to denote either a chore transfer or a pricerise step. We say ‘at timestep ’, to refer to the state of the algorithm just before the event at happens. We denote by the allocation and price vector at timestep .
Let be the first timestep that the current LS enters a raised group. Note that such an event may or may not happen. Our algorithm performs instructions in Lines 614 before , and Lines 1524 after , as we describe below.
3.3 Algorithm prior to (Lines 614)
We first record some properties of the algorithm prior to . These observations follow directly from the algorithm.
Lemma 7.
Prior to , the following hold:

Any transfer of chores only takes place directly from the big spender to the least spender . Thus, an agent receives a chore only if she is a least spender, and an agent loses a chore only if she is a big spender.

An agent ceases to be a least spender only if she receives a chore. An agent ceases to be a big spender only if she loses a chore.

A group undergoes pricerise at only if the group contains the big spender at .
We now show that:
Lemma 8.
If at any point in the run of Algorithm 2 prior to , the big spender lies in a group which contains a former least spender, then the allocation is pEF1.
This allows us to show that:
Lemma 9.
Prior to , the following hold:

Let be the number of pricerise steps until timestep , where . Then the raised groups are exactly . Furthermore they underwent pricerise exactly once and in that order.

For any chore allocated to an agent in a raised group and any agent in an unraised group , where , .

For each , at the time of pricerise of , no agent in has either received or lost a chore since the initial allocation.
Proof.
We prove (i), (ii) and (iii) by induction. For , they are trivially true since there are no raised groups. Assume that at some timestep , (i) groups have undergone pricerise, once and in that order, for some , and (ii) and (iii) hold.
Note that our algorithm only raises the prices of chores owned by a group if the group contains the big spender at the time (Lemma 7). If the current BS is in a raised group, then the induction hypothesis ensures that there is an mBB edge from the LS (who is in an unraised group prior to ) to chores owned by the BS. The algorithm therefore performs a direct chore transfers and no pricerise is necessary.
If eventually the BS enters an unraised group, then a pricerise step is potentially necessary. Suppose is an agent who has received a chore prior to timestep . If this happens then must have been a former LS by Lemma 7. Then Lemma 8 shows that the allocation must already be pEF1.
Hence we assume has not received a new chore since the initial allocation in Line 1. Furthermore since pEF1envies the LS , it must be the case that where . Lemma 3 shows that there is no mBB edge from to chores owned by , hence a direct chore transfer is not possible and it is necessary for to undergo pricerise. This shows (i).
Now if an agent had previously received a chore, then is a former LS at . Then is in a group containing a former LS , hence Lemma 8 shows that the allocation is pEF1. Similarly Lemma 7 shows that no agent in can have lost a chore. This is because only BS agents lose chores. Prior to , no agent of can be the BS. Hence no agent in has received or lost a chore since the initial allocation at the time undergoes pricerise, thus showing (iii).
The algorithm next raises the prices of all chores owned by by a factor of , and becomes a raised group. Consider an agent for and a chore allocated to an agent in . Since the mBB ratio only changes upon a pricerise, the mBB ratio of is 1 since does not undergo a pricerise before .
Observe that since , there is no alternating path from agents in to . Hence before the pricerise. Thus , showing and . After the pricerise, we have that , and . Thus, after the pricerise, which shows (ii). ∎
To summarize the behavior of the Algorithm prior to , we have argued in the above proof that if the allocation is not pEF1, we can always (i) transfer a chore directly from to , or (ii) perform a pricerise on the group of and then transfer a chore from to . Further, we argue that the algorithm makes progress towards getting a pEF1 allocation.
Lemma 10.
Algorithm 2 performs at most steps prior to .
Proof.
Prior to , the LS always remains in an unraised group. Chores are transferred away from agents who become big spenders in raised groups. Once an agent undergoes pricerise, she cannot gain any additional chores, since doing so would mean she is the LS in a raised group, which cannot happen prior to . When the BS is in an unraised group, the group undergoes a pricerise. Thus, effectively, either agents in raised components only lose chores, or the BS ‘climbsdown’ in the group list , while the LS remains below the BS. Since there are groups, and at most chores allocated to raised groups, after steps either of two events happen: (i) the LS and BS both belong to the same group, or (ii) the LS enters a raised group. In the former case, the allocation is pEF1 due to Lemma 6, and the algorithm terminates in steps. We discuss the latter case in the next section. Thus, there are at most steps prior to . ∎
3.4 Algorithm after (Lines 1524)
We now describe the algorithm after , i.e., once the LS enters a raised group (Lines 1524). We show that subsequent to , as long as the allocation is not pEF1, we can either (i) transfer a chore directly from to , or (ii) transfer chores via an alternating path containing 3 agents. We do not perform any pricerises subsequent to .
From Lemma 9, we know that at , groups have undergone pricerise, for some . Let , and . The allocation at need not be pEF1, but we argue that it is already very close to being pEF1. Specifically, we show:
Lemma 11.
At , agents in are pEF1 towards others.
Lemma 12.
At , agents in are pEF1 towards others.
The above two lemmas imply that if the BS is not in , then the allocation is pEF1. Let us assume that the allocation is not pEF1 at . Let , the BS at be in , and , the LS at be in , since the LS is in a raised group at .
Suppose has never lost a chore. Let , where , and be the time when underwent pricerise. Let the BS at . Since the spending of the BS (up to removal of one chore) just after pricerises does not increase, we have:
for some chores . The intermediate transition follows from the property that is pEF1. This shows that the allocation is pEF1.
On the other hand, suppose has lost at least one chore prior to . At , must be assigned to some unraised agent (Lemma 9). Further, there is a chore s.t. . Thus, is an alternating path. The algorithm now transfers chores along this alternating path.
Note that as long as does not own a chore that she initially owned, such a path is available, and such a transfer is possible. If not, then it is as if has never lost a chore, and in that case the previous argument shows that the allocation must be pEF1.
Once again, doing such transfers may change the identities of the BS and LS, and we must continue the algorithm. We show that:
Lemma 13.
After , the following are invariant:

Agents in do not pEF1envy any other agent.

Agents in do not pEF1envy any other agent.

Each group is pEF1.
Just after , the BS is in and the LS is in . After a chore transfer, the identity of the LS or BS can change. If the BS enters either or , then using Lemma 13 the allocation would be pEF1. While the BS is in : (i) if the LS is in , the allocation would be pEF1, (ii) if the LS is in , then we can transfer from BS to LS directly along an mBB edge (which exists due to Lemma 9), (iii) if the LS is in , then we can transfer from the BS to LS via an alternating path with three agents as described above.
Finally we argue termination in polynomialtime:
Lemma 14.
Algorithm 2 performs at most steps after and terminates with a pEF1 allocation.
Proof.
Call the difference between the spending (up to the removal of the biggest chore) of the big spender and the spending of the least spender as the spending gap. If the allocation is not pEF1, the spending gap is positive. After , there are no pricerises, hence the spending gap weakly decreases. As long as the allocation is not pEF1, the BS must be in . Based on whether the LS is in or we can perform chore transfers which weakly decrease the spending gap. While the allocation is not pEF1, such a transfer is always possible. Further, each such transfer reduces the number of chores owned by agents in , and such agents do not receive any chores again. Hence there can only be steps after eventually terminating in a pEF1 allocation. ∎
3.5 Summarizing our EF1+fPO algorithm
We summarize Algorithm 2.

When the current allocation is not pEF1, the BS pEF1envies the LS . While there is an mBB edge from to a chore owned by , we transfer a chore directly from to . If not, in order to transfer along mBB edges, we may have to raise the prices of chores belonging to the group of , creating raised groups.

Let be the first timestep when the LS enters a raised group. Prior to , while the allocation is not pEF1, the algorithm either performs a direct chore transfer from the BS to the LS, or performs pricerise on the group of . Lemma 9 shows that the groups are raised exactly once and in order of . Lemma 10 shows the algorithm runs for steps before .

Finally, we note that allocation is always fPO, since (i) Algorithm 1 returns a market outcome which is fPO, and (ii) any transfer of chores happens along mBB edges.
3.6 Examples
We illustrate two examples of an execution of Algorithm 2 for a fair division instance, one in which the algorithm terminates before a time where the LS enters a raised component, and one in which the algorithm terminates after such a time .
3.6.1 Algorithm terminates before
Consider the instance captured by the table of disutilities below.
Chores  

Agents  1  1  1  1  1  
1  1  1  1  
1  
1  
1  
1 
Algorithm 2 begins by calling Algorithm 1 which returns the following initial allocation .
Suppose . Note that here each agent lies in its own group. Since is not pEF1, Algorithm 2 proceeds to raises the prices of the chores of by a factor of . Then, a chore is transferred from to each of , , , and . This gives us the following pEF1 (and thus EF1) allocation .
3.6.2 Algorithm terminates after
We now consider a slight alteration of the previous instance, with an additional agent and additional chore . The table of disutilities is given below.
Chores  

Agents  1  1  1  1  1  
1  1  1  1  
1  
1  
1  
1  
1 
Again let . As before, Algorithm 2 raises the prices of the chores of by a factor of and transfers a chore from to each of , , , and . Now, however, the allocation is not pEF1. The BS, , still pEF1envies the LS . Thus, the prices of ’s chores are raised, and a chore is transferred from to . We now have the following allocation .
Comments
There are no comments yet.