Fair and Efficient Allocations of Chores under Bivalued Preferences

We study the problem of fair and efficient allocation of a set of indivisible chores to agents with additive cost functions. We consider the popular fairness notion of envy-freeness up to one good (EF1) with the efficiency notion of Pareto-optimality (PO). While it is known that an EF1+PO allocation exists and can be computed in pseudo-polynomial time in the case of goods, the same problem is open for chores. Our first result is a strongly polynomial-time algorithm for computing an EF1+PO allocation for bivalued instances, where agents have (at most) two disutility values for the chores. To the best of our knowledge, this is the first non-trivial class of indivisible chores to admit an EF1+PO allocation and an efficient algorithm for its computation. We also study the problem of computing an envy-free (EF) and PO allocation for the case of divisible chores. While the existence of an EF+PO allocation is known via competitive equilibrium with equal incomes, its efficient computation is open. Our second result shows that for bivalued instances, an EF+PO allocation can be computed in strongly polynomial-time.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

09/02/2019

A polynomial-time algorithm for computing a Pareto optimal and almost proportional allocation

We consider fair allocation of indivisible items under additive utilitie...
07/03/2019

Algorithms for Competitive Division of Chores

We study the problem of allocating divisible bads (chores) among multipl...
02/24/2020

Equitable Allocations of Indivisible Chores

We study fair allocation of indivisible chores (i.e., items with non-pos...
03/02/2021

Improving EFX Guarantees through Rainbow Cycle Number

We study the problem of fairly allocating a set of indivisible goods amo...
05/27/2015

Fair task allocation in transportation

Task allocation problems have traditionally focused on cost optimization...
02/08/2021

Efficient, Fair, and Incentive-Compatible Healthcare Rationing

As the COVID-19 pandemic shows no clear signs of subsiding, fair and eff...
10/21/2021

How to Fairly Allocate Easy and Difficult Chores

A major open question in fair allocation of indivisible items is whether...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

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 non-negative 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 envy-freeness (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 envy-freeness have been defined, first in the context of goods, and later adapted to chores.

A widely studied relaxation of envy-freeness is envy-freeness 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 vice-versa.

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 polynomial-time. For the case of goods, Barman et al. [5] showed that an EF1+PO allocation exists and can be computed in pseudo-polynomial time. Improving this result, Garg and Murhekar [26] showed that an EF1+fPO allocation can be computed in pseudo-polynomial 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 non-trivial 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 non-negative numbers444In 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 well-studied 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 envy-free 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 polynomial-time 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 polynomial-time computable via the Eisenberg-Gale 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 polynomial-time 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 non-convex, multi-valued and disconnected. Algorithms with exponential run-times are known for computing CE for chores [11, 20, 14, 19], but designing a polynomial-time 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 small-enough 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 price-envy-freeness 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 well-studied class in literature. The following results are for the goods setting. Aziz et al. [2] showed PO is efficiently verifiable for bivalued instances and coNP-hard for 3-valued instances; Aziz [3], and Vazirani and Yannakakis [31] studied the Hylland-Zeckhauser 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 max-min fair allocations in 3-valued instances;Bliem et al. [8] studied fixed-parameter 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 NP-hardness 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], pseudo-polynomial 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 scale-invariant. Given such an instance, we partition the set of chores into sets of low-cost chores and high-cost chores :

  • , and

  • .

Further, we assume that both , since if then re-scaling 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 re-scale 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 envy-free up to one chore (EF1) if for all , there exists a chore such that .

We say that an agent EF1-envies an agent if for all , , i.e., the EF1 condition between and is violated.

A (fractional) allocation is said to be envy-free if for all , . We say that an agent envies an agent if , i.e., the EF condition between and is violated.

Pareto-optimality.

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 vice-versa.

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

price555We 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 spending666This 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 bang-per-buck ratio of chore for an agent as , and the minimum bang-per-buck (mBB) ratio as . We define , called the mBB-set, 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 bang-per-buck, i.e., is on mBB.

Given a market outcome with integral, we say it is price envy-free up to one chore (pEF1) if for all there is a chore such that . We say that an agent pEF1-envies 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 mBB-ratio 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 mBB777Note 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 highest-priced 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 pEF1-envy 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 pEF1-envies 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 pEF1-envies . ∎

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 polynomial-time.

We prove Theorem 1 by showing that our Algorithm 2 computes an EF1+fPO allocation in polynomial-time. 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 ).

Input: Fair division instance with
Output: Integral alloc. , prices , agent groups

1: initial cost minimizing integral market allocation, where for .
2:,
3:while  do
4:      Big Spender
5:      Component of See Definition 2
6:     while  agent s.t. ,  
7:         Let be the shortest alternating path from to
8:          Chore transfer
9:         
10:               
11:      Partial component
12:      Agent group
13:     ,
14:return
Algorithm 1

Algorithm 1 starts with a cost-minimizing 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 low-cost chore is assigned to an agent s.t. . If an agent values all chores at , then we can re-scale all values to . Each low-cost chore is priced at 1, and each high-cost chore is priced at . This pricing ensures that the mBB ratio of every agent is 1. The algorithm then eliminates pEF1-envy from the component of the big spender by identifying an agent in that is pEF1-envied 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:

  1. For all low-cost chores , , and for all high-cost chores , .

  2. The mBB ratio of every agent is .

  3. 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 :

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

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

  6. For every agent and chore with , .

  7. All high-cost 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 6-10. This loop terminates only once the big spender in the component does not pEF1-envy 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 pEF1-envy any other agent in the component. Thus, the component is pEF1.

Next, suppose for some agent and some chore for , . Then is a low-cost 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 high-cost 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 high-cost chores in , as high-cost chores are mBB for all agents so a group containing a high-cost 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 pEF1-envies 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 pEF1-envied 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 .

Input: Fair division instance with
Output: An integral allocation

1:
2: Unraised groups
3: Copy of initial allocation, used in Line 22
4: Big Spender
5: Least Spender
6:while  is not pEF1 and  do
7:     
8:     
9:     Let s.t. ,
10:     if  then
11:         Raise prices of chores owned by agents in by a factor of
12:         
13:     else
14:         Transfer a chore from to along an mBB edge      
15:while  is not pEF1 do
16:     
17:     
18:     Let s.t. ,
19:     if  then
20:         Transfer a chore from to along an mBB edge
21:     else if  then
22:          s.t. and s.t.
23:         Transfer from to
24:         Transfer a chore from to      
25:return
Algorithm 2 Computing an EF1+fPO allocation

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 pEF1-envy 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 pEF1-envies (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 pEF1-envy, 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 price-rise together. We call a group a raised group if its agents have undergone price-rise, else it is called an unraised group. The set (Line 2) records the set of unraised components.

We will use the terms time-step or iteration interchangeably to denote either a chore transfer or a price-rise step. We say ‘at time-step ’, to refer to the state of the algorithm just before the event at happens. We denote by the allocation and price vector at time-step .

Let be the first time-step that the current LS enters a raised group. Note that such an event may or may not happen. Our algorithm performs instructions in Lines 6-14 before , and Lines 15-24 after , as we describe below.

3.3 Algorithm prior to (Lines 6-14)

We first record some properties of the algorithm prior to . These observations follow directly from the algorithm.

Lemma 7.

Prior to , the following hold:

  1. 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.

  2. 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.

  3. A group undergoes price-rise 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:

  1. Let be the number of price-rise steps until time-step , where . Then the raised groups are exactly . Furthermore they underwent price-rise exactly once and in that order.

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

  3. For each , at the time of price-rise 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 time-step , (i) groups have undergone price-rise, 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 price-rise is necessary.

If eventually the BS enters an unraised group, then a price-rise step is potentially necessary. Suppose is an agent who has received a chore prior to time-step . 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 pEF1-envies 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 price-rise. 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 price-rise, 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 price-rise, the mBB ratio of is 1 since does not undergo a price-rise before .

Observe that since , there is no alternating path from agents in to . Hence before the price-rise. Thus , showing and . After the price-rise, we have that , and . Thus, after the price-rise, 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 price-rise 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 price-rise, 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 price-rise. Thus, effectively, either agents in raised components only lose chores, or the BS ‘climbs-down’ 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 15-24)

We now describe the algorithm after , i.e., once the LS enters a raised group (Lines 15-24). 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 price-rises subsequent to .

From Lemma 9, we know that at , groups have undergone price-rise, 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 price-rise. Let the BS at . Since the spending of the BS (up to removal of one chore) just after price-rises 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:

  1. Agents in do not pEF1-envy any other agent.

  2. Agents in do not pEF1-envy any other agent.

  3. 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 polynomial-time:

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 price-rises, 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.

  1. Algorithm 2 first calls Algorithm 1 to partition agents into groups with properties as in Lemma 3 to obtain an initial allocation. Lemma 4 shows this takes steps.

  2. When the current allocation is not pEF1, the BS pEF1-envies 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.

  3. Let be the first time-step 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 price-rise 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 .

  4. Once the LS enters a raised group at , there are no more price-rise steps. The algorithm then performs chore transfers from the BS to LS via alternating paths with at most 3 agents. Lemma 13 and Lemma 14 show that the algorithm performs at most steps after and terminates with a pEF1 allocation.

  5. 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, Algorithm 2 first calls Algorithm 1 which returns the following initial allocation .

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 pEF1-envies the LS . Thus, the prices of ’s chores are raised, and a chore is transferred from to . We now have the following allocation .