 # Approximately EFX Allocations for Indivisible Chores

In this paper we study how to fairly allocate a set of m indivisible chores to a group of n agents, each of which has a general additive cost function on the items. Since envy-free (EF) allocation is not guaranteed to exist, we consider the notion of envy-freeness up to any item (EFX). In contrast to the fruitful results regarding the (approximation of) EFX allocations for goods, very little is known for the allocation of chores. Prior to our work, for the allocation of chores, it is known that EFX allocations always exist for two agents, or general number of agents with IDO cost functions. For general instances, no non-trivial approximation result regarding EFX allocation is known. In this paper we make some progress in this direction by showing that for three agents we can always compute a 5-approximation of EFX allocation in polynomial time. For n>=4 agents, our algorithm always computes an allocation that achieves an approximation ratio of O(n^2) regarding EFX.

## Authors

##### 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

Fairness is receiving increasing attention in a broad range of research fields, including but not limited to computer science, economics and mathematics. A fair allocation problem focuses on allocating a set of items to a group of agents, where different agents may have different valuation functions on the items. When the valuation functions give positive values, the items are considered as goods, e.g., resources; when the valuation functions give negative values, the items are considered as chores, e.g., tasks. In the later case we refer to the valuation functions as cost functions. Arguably two of the most well-studied fairness notions are envy-freeness (EF) [foley1967resource] and proportionality (PROP) [steihaus1948problem]. Proportionality means that each agent received at least her proportional share of all items. Envy-freeness is even stronger. Informally speaking, an allocation is EF if no agent wants to exchange her bundle of items with another agent in order to increase her utility. In contrast to the case of divisible items, where EF and PROP allocations always exist [alon1987splitting, edward1999rental, conf/focs/AzizM16], when items are indivisible, they are not guaranteed to exist even for some simple cases. For example, consider allocating a single indivisible item to two agents. This example also defies approximations of EF and PROP allocation. Therefore, researchers have turned their attention to relaxations of these fairness notions. Envy-free up to one item (EF1) [conf/sigecom/LiptonMMS04] and envy-free up to any item (EFX) [journals/teco/CaragiannisKMPS19] are two widely studied relaxations of EF. Informally speaking, an EF1 allocation requires that the envy between any two agents can be eliminated by removing some item; while an EFX allocation requires that the envy can be eliminated by removing any item.

It has been shown that EF1 allocations are guaranteed to exist and can be found in polynomial time for goods [conf/sigecom/LiptonMMS04], chores and even mixture of the two [journals/corr/abs-2012-06788]. However, EF1 could sometimes lead to extremely unfairness, even if a much fairer allocation exists. EFX, on the other hand, puts a much stronger constraint on the allocation and is arguably the most compelling fairness notion. There are fruitful results regarding the existence and computation of (approximations of) EFX allocations since the notion was first proposed by Caragiannis et al.[journals/teco/CaragiannisKMPS19]. For the allocation of goods, it has been shown that EFX allocations exist for two agents with general valuations and any number of agents with identical ordering (IDO) valuations [journals/siamdm/PlautR20], and recently for three agents [conf/sigecom/ChaudhuryGM20]. It remains a fascinating open problem whether EFX allocations always exist in general. For general number of agents with additive valuations, there are efficient algorithms for the computation of -approximate EFX allocations [journals/siamdm/PlautR20, conf/atal/Chan0LW19] and -approximate EFX allocations [conf/aaai/AmanatidisMN20].

In contrast to the allocation of goods, very little regarding EFX allocations for chores is known to this day. It can be easily shown that the divide-and-choose algorithm computes an EFX allocation when there are two agents with general valuations. Very recently, it is shown that EFX allocations always exist for IDO instances [journals/corr/abs-2103-11849]. However, even for three agents with general additive valuations, it is unknown whether constant approximations of EFX allocations exist, let alone the existence of EFX allocations.

### 1.1 Main Results

In this paper, we propose polynomial-time algorithms for the computation of approximately EFX allocations for indivisible chores. For three agents, our algorithm achieves an approximation ratio of while for agents the approximation ratio is . Prior to our work, no non-trivial results regarding the approximation of EFX allocation for chores are known, except for some special cases [journals/corr/abs-2103-11849].

Result 1 (Theorem 3.1). There exists a polynomial time algorithm that computes a -approximate EFX allocation for three agents with additive valuations.

Result 2 (Theorem 4.1). There exists a polynomial time algorithm that computes an -approximate EFX allocation for agents with additive valuations.

While being two seemingly similar problems, the EFX allocations of goods and chores admit distinct difficulties in approximability. For the allocation of goods, while computing an EFX allocation seems difficult, getting a constant approximation ratio turns out to be quite straightforward. Existing algorithms [conf/aaai/AmanatidisMN20, journals/siamdm/PlautR20] for the computation of approximately EFX allocation for goods follow the common framework of Sequential Picking equipped with the Envy-Cycle Elimination technique [conf/sigecom/LiptonMMS04, journals/corr/abs-2012-06788]. Roughly speaking, in these algorithms, in each round an “un-envied” agent will be chosen to pick her favourite unallocated item, where the envy-cycle elimination technique ensures that there will always be an un-envied agent in each round. The result of [journals/corr/abs-2103-11849] also follows this framework to compute an EFX allocation for chores on IDO instances. The key to the analysis is by showing that the value/cost of an agent increases by at most a small constant factor in each round. However, it seems quite challenging to extend this framework to handle general instances for the allocation of chores. For the allocation of goods, it can be shown that the utilities of agents are non-decreasing in each round: the picking operation and envy-cycle elimination do not decrease the value of any agent. In contrast, for the allocation of chores, when an agent picks an item, its cost increases; when an envy-cycle is eliminated, the cost of the involved agents decreases. This introduces a main difficulty in computing an (approximation of) EFX allocation for chores: if the cost of an agent is very small when it picks an item with large cost, the approximation ratio of EFX can be arbitrarily bad.

To get around this main difficulty, we adopt a completely different approach in dividing the items. Our first observation is that when all items have small costs to all agents, then there is likely to exist a partition that looks “even” to all agents. To handle this case, we propose the Round-Robin Placement algorithm, which computes a partition of the items for a group of agents such that the ratios between the cost of any two bundles are bounded, under every agent’s cost function. On the other hand, if there exists an item that has large cost to an agent , then by allocation the item to some other agent , we can ensure that agent does not seriously envy agent , no matter what items agent

received eventually. Our algorithms rely on a careful combination of the above two observations. For three agents, we show that by classifying the agents into different types depending on the number of large items they have, we are able to get a

-approximate EFX allocation. To extend the ideas to general number agents, we borrow some existing techniques for the computation of PROP1 allocation for goods [conf/sigecom/LiptonMMS04], and bound the approximation ratio by .

### 1.2 Other Related Works

For the allocation of goods, there are also works that study partial EFX allocations, i.e., EFX allocations with some of the items unallocated. To name a few, Chaudhury et al. [conf/soda/ChaudhuryKMS20] show that EFX allocations exist if we are allowed to leave at most items unallocated. The result has recently been improved to items by Berger et al. [journals/corr/abs-2102-10654]. They also show that an EFX allocation that leaves at most one item unallocated exists for four agents. Very recently, Chaudhury et al. [conf/sigecom/ChaudhuryGMMM21] show that a -approximate EFX allocation with sublinear number of unallocated goods and high Nash welfare exists. It remains unknown whether similar results hold for the allocation of chores.

Besides EFX, there are other well-studied fairness notions, e.g., MMS [conf/bqgt/Budish10] and PROPX [journals/annurev/Herve19], for the allocation of chores. While it has been shown that MMS allocations are not guaranteed to exist for indivisible chores [conf/aaai/AzizRSW17], there are many works that study its approximations  [conf/aaai/AzizRSW17, journals/corr/abs-2012-13884, conf/ijcai/00010W19, conf/sigecom/HuangL21]. The state-of-the-art approximation ratio for MMS allocation for indivisible chores is by Huang and Lu [conf/sigecom/HuangL21]. Regarding PROPX allocations, in contrast to the allocation of goods, where PROPX allocation is not guaranteed to exist [journals/annurev/Herve19, journals/orl/AzizMS20], it is shown that PROPX allocation always exists and can be computed efficiently for chores [journals/corr/abs-2103-11849].

## 2 Preliminaries

We consider how to fairly allocate a set of indivisible chores to a group of agents . A bundle is a subset of items . An allocation is represented by a -partition of the items, where for all and . In allocation , agent received bundle . Each agent has an additive cost function . That is, for any and , .

When there is no confusion, we use and to denote for convenience. Further, given any set and , we use and to denote and , respectively.

###### Definition 2.1 (α-Efx).

For any , an allocation is -approximate envy-free up to any item (-EFX) if for any and any ,

 ci(Xi−e)≤α⋅ci(Xj).

When , the allocation is EFX.

Without loss of generality, we assume that all cost functions are normalized. That is, for any , . Let be the -th most costly item under (with tie broken deterministically, e.g., by item ID). In other words, for all agent , we have

 ci(σi(1))≥ci(σi(2))≥⋯≥ci(σi(m)).

For each agent , we define as the set of tail items. Observe that we have and for all and . With this observation, we show that for every instance there exists a simple allocation that is -EFX.

###### Lemma 2.2.

There exists a -EFX allocation for every instance with items and agents.

###### Proof.

Fix an arbitrary agent, e.g., agent , and define the allocation as follows. For all , let . Let be the set containing the remaining items. Obviously, the resulting allocation is EFX for all agents since . By the definition of , for every , every , we have

 cn(M−n−e)≤(m−n)⋅cn(σn(i))=(m−n)⋅cn(Xi)

Consequently, the allocation is -EFX. ∎

Unfortunately the above approximation ratio is large, especially when is large and is small. In the following sections, we present algorithms that compute allocations with approximations of EFX that depends only on . In particular, our algorithm computes a -EFX allocation when and -EFX allocation for .

## 3 5-EFX Allocation for Three Agents

In this section we present the algorithm that computes a -EFX allocation when . The ideas we use to compute the allocation in this part inspires our design of approximation algorithm for general .

###### Theorem 3.1.

There exists a polynomial-time algorithm that computes a -EFX allocation for three agents.

Given an allocation , we say that agent envies agent if ; strongly-envies agent if there exists such that . In other words, an allocation is -EFX if and only if no agent strongly-envies another agent. For three agents we have for all . Observe that if there exists an agent with , then by allocating and to the other two agents and to agent , we end up having a -EFX allocation (following an analysis similar to the proof of Lemma 2.2). Hence it suffices to consider the case in which every agent has

 ci(M−i)>5⋅ci(σi(2)).

In other words, item (and thus every item other than ) is “small” to agent in the sense that it contributes at most a fraction to the total cost of . Depending on whether has large cost, we classify the agents into two types: large agent and small agent.

###### Definition 3.2 (Large/Small Agent).

We call agent a large agent if ; small otherwise.

The main intuition behind the definition is as follows. Recall that we are aiming for a -EFX allocation. For a large agent , if for some agent , then as long as , agent does not strongly-envy agent , even if . On the other hand, for a small agent , every item has cost . Thus we can partition the items into bundles of roughly the same cost, under , so that no matter which of these bundles agent eventually receives, she will not strongly-envy any other agent.

Following the above intuitions, we proceed by considering how many small agents there are.

### 3.1 At Least Two Small Agents

We first consider the case when there are at least two small agents. Without loss of generality, suppose agent and are small. Agent can be either small or large.

###### Lemma 3.3.

We can compute in polynomial-time a -partition of such that for both , we have for all .

Note that Lemma 3.3 immediately implies Theorem 3.1 when there are at least two small agents for the following reasons. Since the costs of the three bundles and differ by a factor of at most , agent and will not strongly-envy any other agent as long as every agent gets exactly one bundle. Therefore, by letting agent pick her favourite bundle, i.e., the one with minimum , and allocating the remaining two bundles to agents and arbitrarily, we end up with a -EFX allocation: agent does not envy agents and ; agents and do not strongly-envy any other agent.

Thus it remains to give the polynomial-time algorithm for the computation of . The main idea behind the algorithm is quite simple: since agents and have small costs on every item, round-robin like algorithms should work in computing such a partition.

#### The Algorithm.

We initialize as an empty bundle for all . Then we let agents and take turns to put the unallocated item with maximum cost into the bundle with smallest cost, both under her own cost function, until all items are allocated (refer to Algorithm 1).

Next we show that for both , we have for all .

Proof of Lemma 3.3: Fix any , say . We assume w.l.o.g. that . We show that and . Recall that each agent allocates one item to some bundle in each round. We say that it is agent ’s round if during this round agent gets to allocate an item to one of the bundles.

Consider the last item agent allocates an item to the bundle , and let be the next agent ’s round. If agent never assigns any item to , then let be the first agent ’s round. In other words, is defined as the earliest agent ’s round such that starting from round , agent never assigns any item to bundle . Let be the three bundles at the beginning of round . Let

be the set of unallocated items at this moment.

• If is the first agent ’s round, then we have , since at most one item is allocated and each item has cost at most under .

• Otherwise, since agent allocates one item to in the previous agent ’s round, we know that at the beginning of that round, the cost of bundle is the minimum among the three. Thus we have

 c1(S′3)≤c1(S′1)+2×1/8=c1(S′1)+1/4, (1)

since at most one item is allocated in each round.

In both case we have .

Let (resp. ) be the set of items in that are allocated by agent (resp. ). Note that all these items are allocated at or after round . Since agent allocates the items from the most costly to the least, we have . We first give an upper bound on .

We have .

###### Proof.

Recall that

 c1(P2)≤12⋅c1(P)=12⋅(1−c1(S′1)−c1(S′2)−c1(S′3)).

We have

 c1(S′3)+c1(P2)≤ c1(S′3)+12⋅(1−c1(S′1)−c1(S′2)−c1(S′3)) ≤ 12+12⋅(c1(S′3)−c1(S′1)) ≤ 12+12⋅14=58,

where the last inequality follows from (1). ∎

Recall that all items in are allocated by agent after round , by Claim 3.1 we have

 c1(S3)≤c1(S′3)+c1(P2)≤58.

Next we give a lower bound for . If agent allocates all items in to , then we have

 c1(S1)≥c1(S′1)+c1(P1)≥c1(S′3)−14+c1(P2)≥c1(S3)−14.

Consequently we have (recall that )

 1=c1(S1)+c1(S2)+c1(S3)≤3⋅c1(S1)−12,

which gives . Figure 1: An illustration of the assignment of items in the three bundles, where the items within each bundle are ordered by the time they are included, and the items in the shaded areas belong to P2.

Otherwise we consider the last item agent allocates to (see Figure 1 for an illustrative example). Let and be the two bundles right before the allocation. Note that , and we have . Since is the last item agent allocates to , we know that all items in are from . Also recall that after time , agent 1 did not assign any item to . In other words, all items in are from . Thus we have

 M∖(S1∪S′′2∪{e})⊆S3∪P2=S′3∪P2.

By Claim 3.1 we have

 1−c1(S1)−c1(S′′2)−c1(e)≤c1(S′3)+c1(P2)≤58.

Since , we have

 c1(S1)≥12⋅(1−58−c1(e))≥18,

where the second inequality holds due to .

### 3.2 One Small Agent

Next we consider the case when there is exactly one small agent, say agent . Let and be the most costly item under and , respectively. Note that since agents and are large, we have and .

If , then we can compute a -EFX easily as follows. Let , and we compute an EFX allocation between agents and on items . In this allocation agent obviously does not strongly-envy agents and because , and agents and do not envy each other by more than one item. On the other hand, since is an EFX allocation on items , by removing any item from (resp. ), we have (resp. ). Since and , the allocation is -EFX.

If , then we use the fact that agent is a small agent to compute an allocation that is fair to all as follows. Let . Note that we have since items and have cost at most under . We first compute an EFX allocation for three agents under cost function , on items . Consequently for every we have

 c3(M−)=c3(S1)+c3(S2)+c3(S3)≤3⋅c3(Si)+2×18,

which implies .

#### Allocation.

Assume w.l.o.g. that , we decide the allocation as follows. Let , let agent pick a bundle between and ; then agent gets the remaining bundle.

We show that the resulting allocation is -EFX.

• Agent does not strongly-envy agent and because , which implies

 c3(X3)≤4/6≤4⋅min{c3(X1),c3(X2)}.
• Agent does not envy agent because she gets to pick a bundle between and , while agent gets the other bundle. For the same reason we also have . Agent does not strongly-envy agent because .

• Agent does not envy bundle because and . Agent does not strongly-envy bundle because and

 c1(e2)≤15⋅c1(M−1)≤15⋅c1(M−)≤c1(S3),

where the last inequality holds since is the most costly bundle among , e.g., . Thus no matter which bundle agent picks, the resulting allocation is -EFX.

### 3.3 All Agents are Large

Finally, we consider the case when all agents are large. Let , and . By definition we have , and .

As before, if there exist two of that are the same item, say , then we can easily compute an -EFX by assigning to and computing an EFX allocation between agent and on the remaining items. Hence we assume and are three different items, and let .

#### Allocation.

Let . We first compute an EFX allocation on items under cost function . Assume w.l.o.g. that . We let agent pick a bundle between and , and assign the other bundle to agent .

We show that the resulting allocation is -EFX.

• Agent does not strongly-envy bundle because . Agent does not envy bundle because

 c3(S2)≥12⋅c3(M−)≥12⋅45⋅c3(M−3)≥25⋅c3(M−3)≥c3(X3),

where the second and third inequality hold since all items other than are small, i.e., have cost at most to agent .

• Agent does not envy agent because she gets to pick first. Agent does not strongly-envy agent because while .

• Recall that agent gets the bundle in that is not picked by . Moreover, and is an EFX allocation under . Since every item has cost , we have . Thus for every . Consequently, we have

 max{c1(S1),c1(S2)}≤58⋅c1(M−)andmin{c1(S1),c1(S2)}≥38⋅c1(M−),

because otherwise , which contradicts the fact that is an EFX partition. Hence we have

 max{c1(S1+e3),c1(S2)}≤ 58⋅c1(M−)+15⋅c1(M−1) ≤ 78⋅c1(M−)≤3⋅min{c1(S1+e3),c1(S2)}.

In other words, agent does not strongly-envy agent . In the following, we show that for all we have . If then the claim is trivially true because is an EFX partition of . Otherwise we have . If , then

 c1(X1−e)=c1(S1)≤c1(S2+e1).

If , then we have

 c1(X1−e)=c1(S1−e)+c1(e3)≤c1(S2+e1).

In both case we have . Since and are disjoint, we have

 c1(X1−e)≤12⋅(c1(X1−e)+c1(S2+e3))≤12.

Since , agent does not strongly-envy agent either.

In summary, in all cases we can compute a -EFX allocation for three agents in polynomial-time, which proves Theorem 3.1. From the above analysis we observe that it is crucial to distinguish whether an item is large to an agent : if it is, then by allocating the item to another agent who values it small, we can eliminate the strong envyness from to ; if it is not, then putting item in does not hurt the approximation ratio too much.

In the following section, we show how these ideas can be extended to the general case when .

## 4 General Number of Agents

In this section, we give a polynomial-time algorithm that computes an -EFX allocation for any given instance with agents.

###### Theorem 4.1.

There exists a polynomial-time algorithm that computes a -EFX allocation for any instance with agents.

For each agent , we define . As before (refer to Lemma 2.2 for a formal analysis), if there exists an agent with then we can easily compute a -EFX allocation by allocating exactly one item in to each agent in , and assigning the remaining items to agent . Since each agent other than receives only one item, and agent receives a set of items with total cost at most times the cost of any other agent, the allocation is -EFX.

In the following we say that agent strongly-envies agent if for some it holds

### 4.1 The Allocation Algorithm

We define , and let be the set of large items of agent . Note that by the above discussion we have for all . The main intuition behind the definition of large items is as follows. Our algorithm will compute an allocation ensuring that for each agent , either , i.e., no large item in is assigned to agent ; or . We show that as long as no large item is assigned to agent , does not strongly-envy any other agent that receives at least one item in .

###### Lemma 4.2.

For any agent , if and , then does not strongly-envy agent .

###### Proof.

By definition each item has cost

 ci(e)≥bi=13n2−n+2⋅ci(M−i).

Hence we have

 ci(Xi) ≤ci(M∖Li)=ci(M−i)+ci(M∖(M−i∪Li)) ≤(3n2−n+2)⋅ci(Xj)+(n−2)⋅ci(Xj) ≤3n2⋅ci(Xj),

where the last inequality holds because contains at least one item that is large to agent , and there are at most items that are not included in , all of which are small to agent . ∎

#### Remark.

A few difficulties arise when we try to extend the ideas we develop for three agents to general number of agents. First, for a large number of agents, it is no longer feasible to classify agents depending on how many large items they have because there are too many cases. Instead, our new algorithm removes the large items of each agent, and treat all agents as “small agents”. Second, even if all agents have no large items, i.e., for all , it is not clear how to extend the Round Robin Placement algorithm (Lemma 3.3) to compute subsets with upper and lower bounded costs for general number of agents. To get around this, we borrow existing results for the PROP1 allocation of goods, and show that when items are small to the agents, we can partition the items into bundles such that the ratio between the costs of any two bundles are bounded by .

Let be the set of items that are large to at least one agent. Let . Note that each item is large to all agents. Let be the set of items that are small to all agents.

###### Claim 4.1.

For each and , we have .

###### Proof.

Recall that item is small to agent . Thus

 ci(e)≤bi=13n2−n+2⋅ci(M−i).

Moreover, we have . Since there are at most items in , and each of them has cost at most to agent , we have

 ci(M−)≥ci(M−i)−(n−1)⋅(n−2)⋅bi≥(2n2+2n)⋅bi. (2)

By the above lower bound on , we have . ∎

Recall that now we have three sets of items , and , each of which will be handled as follows.

• Since each item in is large to all agents, we assign each of them to a unique agent chosen arbitrarily. Let be these agents, and . Note that . Our algorithm will not assign any further items to agents in . Obviously these agents do not envy any other agents by more than one item. Moreover, if we can ensure that in the final allocation for all , then no agent strongly-envies any agent in , by Lemma 4.2.

• By Claim 4.1, for all agent , all items in have small cost compared to . We show in Lemma 4.3 that we can partition the items in to into bundles evenly under every cost function of agents, and assign them to the agents in . The key to the computation of the partition is to ensure that each bundle has a considerably large cost to every agent in .

• It remains to assign items in . Recall that these are items that are large to some agent but not to all agents. Our algorithm assigns each to an arbitrary agent for which .

###### Lemma 4.3.

Given a set of items and a group of agents such that for all and ,

 ci(e)≤12n2+2n⋅ci(M−),

there exists a partition of such that for all ,

 ci(Sj)≥12n2+2n⋅ci(M−).
###### Proof.

Let . Our goal is to partition into such that for all , . Since we need to partition the items into bundles whose cost is lower bounded, it is natural to borrow ideas from the allocation of goods.

In particular, we treat items in as goods, where each agent has value on item . Then we compute a -partition of that is PROP1 using the Round Robin algorithm [conf/sigecom/LiptonMMS04]. The fairness notion PROP1 is defined as follows. An allocation of items to agents is PROP1 if for all , there exists such that .

Since each has cost to agent , we have

 ci(Qi)≥1n⋅ci(M−)−12n2+2n⋅ci(M−)≥2n+12n2+2n⋅ci(M−).

However, is not the desired partition since can be arbitrarily small, for some . Thus for each we further compute a -partition of that is PROP1 under . Again, since each has , for each we have

 ci(Qij) ≥1n⋅ci(Qi)−12n2+2n⋅ci(M−) (3) ≥2+1/n−12n2+2n⋅ci(M)≥12n2+2n⋅ci(M−), (4)

where the second inequality follows from Equation (4.1).

Finally, we regroup the bundles into bundles: let