Weighted Maxmin Fair Share Allocation of Indivisible Chores

We initiate the study of indivisible chore allocation for agents with asymmetric shares. The fairness concept we focus on is the weighted natural generalization of maxmin share: WMMS fairness and OWMMS fairness. We first highlight the fact that commonly used algorithms that work well for the allocation of goods to asymmetric agents, and even for chores to symmetric agents do not provide good approximations for allocation of chores to asymmetric agents under WMMS. As a consequence, we present a novel polynomial-time constant-approximation algorithm, via linear program, for OWMMS. For two special cases: the binary valuation case and the 2-agent case, we provide exact or better constant-approximation algorithms.


page 1

page 2

page 3

page 4


Approximating Nash Social Welfare under Rado Valuations

We consider the problem of approximating maximum Nash social welfare (NS...

Almost Proportional Allocations for Indivisible Chores

In this paper, we consider how to fairly allocate m indivisible chores t...

Optimizing a Generalized Gini Index in Stable Marriage Problems: NP-Hardness, Approximation and a Polynomial Time Special Case

This paper deals with fairness in stable marriage problems. The idea stu...

Computing envy-freeable allocations with limited subsidies

Fair division has emerged as a very hot topic in AI, and envy-freeness i...

Approximating Nash Social Welfare under Submodular Valuations through (Un)Matchings

We study the problem of approximating maximum Nash social welfare (NSW) ...

Fairness in Slot Allocation

The recent interpretations of fairness in slot allocation of flights are...

1 Introduction

We consider fair allocation of indivisible chores when agents have asymmetric shares. In contrast to the case of goods for which agents have positive value, chores are disliked by agents and they have negative values for them. The fairness concept we focus on is the maxmin share (MMS) fairness which was designed for allocation of indivisible items. MMS is based on the thought experiment that if the items are partitioned into bundles and an agent would always get the least preferred bundle of items, what is the best way she can partition the items. The value of such a bundle is the maxmin share of the agent. An allocation is deemed MMS fair if each agent gets her required share.

Maxmin share fairness was proposed by [Budish2011] as a fairness concept for allocation of indivisible items. It is a relaxation of proportionality fairness that requires each of the agents should get a value that is at least of the total value she has for the set of all items. When items are divisible, maxmin share fairness coincides with proportionality. Maxmin share fairness is a weaker concept when items are indivisible. It was conjectured that a maxmin fair allocation always exists but [Procaccia and Wang2014] identified a counter-example. Since the work of [Procaccia and Wang2014], there are several papers on algorithms that find an approximate MMS allocation [Amanatidis et al.2015, Barman and Murthy2017, Ghodsi et al.2018, Aziz et al.2017]. All these works make a typical assumption that agents are symmetric and should be treated in a similar manner.

[Farhadi et al.2017] were the first to consider MMS fairness for the case where indivisible goods are allocated and the agents are not symmetric because they may have different entitlement share of the goods. Ideally, an agent would expect to get a share of the total value that is proportional to her entitlement. However, when items are indivisible, MMS fairness needs to be suitably generalized to the cater for asymmetric entitlement shares. FHG+17a generalized MMS fairness to that of the more general MMS concept as weighted MMS (WMMS) that caters for entitlements. They devised a simple ordinal (that only used the qualitative ranking information of items) algorithm that ensures an -approximation guarantee for WMMS where each agent’s allocation is at least of her value in a WMMS allocation. Beyond the results for goods [Farhadi et al.2017, Farhadi et al.2019], not much is known about chore allocation when the agents are asymmetric despite the recent active research in fair allocation of goods and chores. Furthermore, it is not clear whether the results for goods from one setting could carry over the other [Aziz2016].

In this paper, we focus on the fair allocation of chores rather than goods for asymmetric agents. In the case of chores, agents do not have entitlements but relative shares. If an agent has a higher share, she is expected to take a higher load of the chores. Treating agents asymmetrically may be a requirement for several reasons. For example, countries with a larger population and CO2 emission may be liable to undertake more responsibility to clean up the environment. In this paper, the central research question we examine is the following one. When indivisible chores are to be allocated among agents with asymmetric shares, for what approximation factor do approximately WMMS fair allocations exist and how efficiently can they be computed?


We consider a model of allocation of chores in which agents have relative shares as compared to entitlements. Different to the case of symmetric agents, we first prove that even with only two agents, no algorithm can simultaneously guarantee each agent’s value to be higher than of her weighted maxmin share. Moreover, we show that many greedy algorithms widely used in the literature, including [Farhadi et al.2017] and [Aziz et al.2017], may have arbitrarily bad performance.

Then we design a polynomial-time algorithm which provides a 4-approximation to the minimal relaxation of WMMS value (OWMMS) under which a WMMS allocation exists. To present this algorithm, we first study a special case when all agents have an identical valuation. The algorithm combines (1) the use of a greedy algorithm for the case of identical valuations and (2) linear programming and rounding techniques.

Finally, we study two restricted cases: a two-agent setting and a binary valuation setting. For the two-agent case, we present a variant of divide-and-choose protocol which ensures each agent’s value is at least of her weighted maxmin share; For binary valuations, we show that a WMMS allocation exists and can be efficiently computed. For asymmetric agents and indivisible items, this is the first algorithmic result for binary valuations.

2 Related Work

The fair allocation problem has been extensively studied in the cake cutting literature [Dubins and Spanier1961, Stromquist1980, Alon1987, Brams and Taylor1995, Brams and Taylor1996, Robertson and Webb1998, Aziz and Mackenzie2016]. In this line of work, researchers study how to fairly allocate a divisible item (e.g., cake) among a number of agents. Solution concepts such as envy-freeness and proportionality are prominent criteria for fairness. In the context of divisible goods, researchers have extended results for the case of equal entitlements to those of unequal entitlements (see e.g., [Cseh and Fleiner2018]).

As for MMS fairness, it is already known that even for additive valuations, there exists an instance such that no allocation can simultaneously guarantee each agent receives at least her MMS [Kurokawa et al.2018]. But approximate MMS can be efficiently computed; see [Barman and Murthy2017, Ghodsi et al.2018, Kurokawa et al.2018]. Computing WMMS shares is an NP-hard problem for both goods and for chores even for the case of 2 agents and for equal shares. The statement can be derived via a reduction from the integer partition problem [Garey and Johnson1979].

Most of the work on fair allocation of items is for the case of goods although recently, fair allocation of chores [Aziz et al.2017] or combinations of goods and chores [Aziz et al.2018] has received attention as well. It is shown by [Aziz et al.2017] that MMS allocations for chores do not always exist but can be 2-approximated by a simple round-robin algorithm. [Aziz et al.2017] also presented a PTAS for relaxation of MMS called optimal MMS. [Barman and Murthy2017] presented an improved approximation algorithm for MMS allocation of chores. Fair allocation of indivisible goods and asymmetric agents has also been studied [Farhadi et al.2017, Farhadi et al.2019]. We take a similar approach and study the chore allocation problem when the agents are not symmetric. [Babaioff et al.2017] considered the allocation of indivisible goods where agents have different entitlements. One of the concepts that they propose is called -out-of-d MMS that can also apply to agents having ordinal preferences over bundles of chores. However, the paper focusses on results for goods.

3 Preliminaries

We begin by presenting our setting formally and discussing fairness concepts as well as some basic notations in the paper.

3.1 Setting

Let be a set of agents, and be a set of indivisible items. In this work, we always use and to indicate an agent and an item, separately. Each agent has a valuation function . Denote by . We assume that items are chores to every agent, i.e., for all and the valuations are additive, i.e., for any , . Without loss of generality and just for ease of presentation, throughout this paper except Section 6.2, it is assumed that all of the valuations are normalized, i.e. and .

In this work, we consider the case when agents are asymmetric. Particularly, every agent has a share for the chores, namely . The shares add up to , i.e., .

Letting and , we use to denote a chore allocation instance and when all agents have the identical valuation . Note that when all agents have identical valuation , is simplified as for any . Let be the set of all -partitions of the items. A generic allocation will be denoted by where is the bundle of agent .

3.2 WMMS Fairness

Before presenting the WMMS fairness concept that takes into account the shares of the agents, we first present the standard MMS fairness concept that assumes the shares of the agents are equal. For symmetric agents, the classical maxmin share (MMS) of an agent with valuation is defined as

Intuitively, when allocating items to agents, each agent should get an allocation with a value that is of the total value they have for all the items. Since the items are not divisible, this proportionality requirement may be not achievable for the agents. In view of this, can be viewed as a relaxed lower bound on the value that agent hopes for if she has the chance to partition the items into bundles and every other agent adversarially chooses a bundle before . Next, we generalize the classical MMS notion to the setting with asymmetric agents.

Definition 1 (Weighted MMS)

Given any chore allocation instance , for every agent , the weighted maxmin share (WMMS) value of is defined as:

Any partition achieves is called a P- partition.

When the instance is clear from the context, we may use for short. The definition above for WMMS fairness is exactly the same as that of WMMS as formalized by [Farhadi et al.2017] for the case of goods except that the entitlement of an agent is replaced by her share . As mentioned in the introduction, whereas a higher entitlement for goods is desirable for an agent, a higher share for chores is undesirable for the agent.

We call an allocation WMMS if the value of the allocation to each agent is worth at least to her. Similarly, an allocation is called -WMMS, if the total value of items allocated to each agent is at least for .

Note that when all shares are equal, WMMS coincides with MMS fairness so it is a proper generalization of MMS. Secondly, we spell out an insight that also provides justification for the WMMS concept that was defined by [Farhadi et al.2017]. We note that when the items are divisible, then . Hence, for divisible chores, WMMS fairness also implies a natural generalization of proportionality that takes into account the shares of agents. We call the latter requirement as weighted proportionality.

In the following, we define some more notation that will be used in the paper. Given a chore allocation instance , for any agent and any partition , let . That is, is the unfairness degree of allocation to . Let . Thus is the smallest degree of unfairness and . Moreover, we have the following simple properties.

Lemma 1

Given any instance , for any , , and .


Note that for any agent and any allocation , , which is the weighted arithmetic mean of the terms , with weights (whose sum is 1). As the mean equals , the smallest must be at most and . ∎

Next we show a simple algorithm, , which returns an - allocation. Algorithm produces an allocation that allocates all of the items to a single agent who has the highest share (ties are broken arbitrarily).

Lemma 2

Let be any chore allocation instance and be the output of Algorithm . Then for any .


Let be the agent who has the largest share, thus . It is easy to see that for any agent , , which is trivially at least as large as . By Lemma 1, . Accordingly, . ∎

We present the following example to provide additional intuition of WMMS and our notation.


Let be a chore allocation instance, where , and the agents’ shares and valuations are shown in Table 1.

Agent Share 1 2 3 4
Table 1: An Example of a Chore Allocation Setting.

In this instance, for agent 1, allocating one of the four chores to herself and the remaining three chores to agent 2 is an exact weighted proportional allocation with respect to valuation . Then , and .

Similarly, for agent 2, allocating chores to agent 2 and chores to agent 1 is an exact weighted proportional allocation with respect to valuation . Thus , and . Note that this allocation is bad for agent 1 since .

However, one of the weighted proportional allocations to agent 1, e.g., and , satisfies both of and , since and . Therefore, is a WMMS allocation.

4 Optimal WMMS Fairness

It is well known that for symmetric agents, no matter the items are goods or chores, an MMS allocation always exists for the 2-agent case. But for asymmetric agents, we note that an exact WMMS allocation may not exist even when there are only two agents. Indeed, by the following lemma, we see that the lower bound of the problem is at least , which means that there is no allocation that can guarantee each agent’s value to be greater than for every .

Lemma 3

In the chore allocation problem, any algorithm has an approximation ratio of at least for WMMS fairness.


In the following we construct an instance with , and the shares and valuations are shown in Table 2.

Agent Share 1 2
Table 2: Instance to establish the lower bound for 2 agents.

We first note that for agent 1, the unique P- partition is with and , since , which is the largest among all possible allocations. Accordingly, . For agent 2, to maximize , the only way is to set with and , since , which is the largest among all possible allocations. Accordingly, .

However, is bad to agent 2, since and is bad to agent 1, since . Therefore the best tradeoff to satisfy the two agents simultaneously would be allocation , since and . Indeed, we need to take all possible allocations into consideration, but it is easy to see that all other allocations can only be worse.

Thus, no algorithm could provide an allocation with each agent ’s value being strictly larger than , which finishes the proof of Lemma 3. ∎

Accordingly, it is natural to consider a relaxed version of WMMS, optimal WMMS (OWMMS) fairness, which is similar to the one introduced in [Aziz et al.2017].

Definition 2 (Optimal WMMS)

Let be a chore allocation instance. The optimal WMMS (OWMMS) ratio is defined as the minimal for which an -WMMS allocation always exists. Let for any . A partition is called an OWMMS allocation, if for all .

It is easy to see that for any instance and any agent . For any partition , if then is called -approximation to the OWMMS allocation.

5 Approximation Algorithms

For the case of goods allocation, the greedy round robin algorithm considered by [Farhadi et al.2017] gives the best guarantee (of -approximation for goods). Interestingly, the same algorithm was proved to provide a 2-approximation for MMS allocation of chores when agents are symmetric [Aziz et al.2017]. However, when agents have different shares, such an algorithm can be arbitrarily poor. We provide a bad example in the appendix, where we also show that some natural attempts to ‘fix’ the bad performance of the greedy algorithm do not help.

In the following, we give our polynomial-time -approximation algorithm. That is, for any , it returns an allocation such that for any agent , . In order to present the main algorithm, we first present a polynomial-time algorithm which guarantees each agent ’s value to be at least , when all of the agents have an identical valuation.

5.1 Identical Valuation

When all agents have an identical valuation, we show the algorithm, defined in Algorithm 1, is a 2-approximation to an exact allocation.

0:  Chore allocation instance
0:  Allocation .
1:  Initially, for all .
2:  Order all chores from the lowest value to the highest value such that .
3:  for  to  do
4:      ;
5:      .
6:  return  Allocation .
Algorithm 1 - An Algorithm for Identical Valuations

The next lemma relies on a connection to the parallel processors scheduling problem. In this problem, there is a set of jobs and a set of processors. Each job has to be processed exactly once on exactly one processor. Processors may have different speeds [Gonzalez et al.1977, Friesen1987]. The problem specifies the time required to process a given job on a given machine. Typically, the goal of scheduling problems is to find an assignment of the jobs such that the longest finishing time (i.e., makespan) is minimized. A detailed survey of this line of work can be found in [Pinedo2016]. We prove the following Lemma 4 in the appendix.

Lemma 4

For any chore allocation instance , where all agents have the identical valuation , let be the allocation outputted by . We have for any .

One may suspect that a natural generalization of to the case that agents have different valuations may work well. Unfortunately, in the appendix, we provide an example that such an algorithm cannot have any constant approximation ratio.

5.2 General Valuations

Now we are ready to study the general case when agents may have different valuations. For any chore allocation instance , let variable represent the ratio, and variable represent whether agent gets item . Let . Then the problem of computing its OWMMS ratio and an OWMMS allocation can be formalized as the following integer program.

To solve , in what follows, we first prove a key technical lemma by using the rounding technique introduced by [Lenstra et al.1990], which gives us the tool to round a fractional assignment to an integer assignment.

Lemma 5

Let be any chore allocation instance, , and . Denote by and . If the following linear program

has a feasible solution, then any extreme point of this polytope (defining the solution space) can be rounded to a feasible solution of the integer program


Let be an extreme point of the polytope defined by . Then contains at most nonzero variables due to the number of constraints in . We construct a bipartite graph via , , where is the set of agents, is the set of chores and . Using the same argument with the proof of Theorem 1 in [Lenstra et al.1990], we know that is a pseudoforest, i.e., each connected component of is a tree or a tree plus one additional edge.

Next, we round to . In any connected component of , whenever there is a chore whose degree is 1, then it must be that for some , . Then set and delete this chore from . Denote by the remained graph. Note that in , any remaining chore has a degree at least 2. Therefore must contain a matching which covers all chores, due to the fact that is a tree or a tree plus one additional edge. According to this matching, if is matched, set ; otherwise, set to be 0.

Next, it suffices to verify that is a feasible solution of . For each chore , assigns it to exactly one agent. Thus, for any . For each agent , there is at most 1 chore such that is increased to 1. Since ,

which completes the proof of Lemma 5. ∎

Note that, solving the optimal for integer program is equivalent to finding the minimum value of such that has a feasible integer solution . However, is not the relaxation of since in , there is not a variable for which . Equivalently, we can add these variables to and set them to zero. In the following, we discuss the relationship between the solutions of , and .

Recall that is the OWMMS ratio, which is also the optimal value of . Let

Note that always exists as is always feasible by Algorithm . Moreover, although is not the relaxation of , is still a lower bound of .

Lemma 6


Lemma 6 shows that to approximate , it suffices to find a feasible solution of whose value is a good approximation to . Next, we show that a feasible solution of is naturally a feasible solution of .

Lemma 7

Let . If is a feasible solution of with for all , then is a feasible solution of .

Both Lemmas 6 and 7 are proved in the appendix. Before we show our main algorithm, let us discuss the following intuitive procedure. First, compute and its corresponding fractional allocation . Then use Lemma 5 to round to an integer solution . By Lemma 7, is also a feasible solution of . Let be the final allocation, where for every . Thus,

where the first inequality is by Lemma 5 and the second inequality is by Lemma 6. That is, is a 2-approximation to the optimal allocation.

However, there are two computational issues with respect to the procedure above: (1) The computation of may need exponential time111 The computation of is NP-hard, even when and , via a reduction from the Integer Partition Problem. ; (2) Even if we know all the ’s, there is a problem of computing .

To resolve (1), we use Algorithm to compute an approximate value for each , where . Then we replace all by in above procedure.

To resolve (2), we use binary search to find a near optimal value of . Initially, we first use Algorithm to get an upper bound of and 1 is a trivial lower bound. Let be the desired precision. Denote by and the current upper and lower bounds, respectively. Set and , and check if has a feasible solution. If has a feasible solution, reset to be ; Otherwise reset . Repeat this process until .

We formally describe the algorithm described above as Algorithm 2, denoted by .

0:  Chore allocation instance and .
0:  Allocation
1:  Initially, for all .
2:  For each , run Algorithm on instance and obtain allocation .
3:  Set for all .
4:  Let and . % is the upper bound by .
5:  while  do
6:      Set .
7:      Check if has a feasible solution by setting for all .
8:      if  has a feasible solution then
9:          Reset .
10:      else
11:          Reset .
12:  Set for all and compute an extreme point of .
13:  Use Lemma 5 to round to .
14:  Set for all .
15:  return  Allocation .
Algorithm 2 - An Algorithm for General Valuations
Theorem 1

Given any chore allocation instance with being its OWMMS ratio. For any , Algorithm runs in polynomial time (for any number of agents) and returns an allocation such that for any agent , .


By Lemma 7, is a feasible solution of . At Step 12, as and , we have . Thus,

where the first inequality is by Lemma 5, the second inequality is by Lemma 4, and the last inequality is by Lemma 6.

As requires us to run and solve at most numbers of (polynomial-sized) linear program, runs in polynomial time. ∎

Note that the role of in can be replaced by other (polynomial-time) approximation algorithms (such the PTAS in [Hochbaum and Shmoys1988]) and the approximation ratio (Lemma 4) is improved accordingly.

6 Restricted Cases

In this section, we consider two important restricted cases: (1) two agents and (2) all agents have binary valuations (in which case agents have value 0 or -1 for each item).

6.1 WMMS for Two Agents

Given any instance with , we prove that it is always possible to guarantee each agent ’s value to be at least . Thus, by Lemma 3, the OWMMS ratio for the 2-agent case is within .

Divide-and-choose algorithms are widely studied in the literature, especially for the case of two agents. Roughly speaking, the algorithm starts by letting one of the agents divide the whole items (either goods or chores) into two bundles, and the other agent chooses one from the two bundles. Such an algorithm gives an exact MMS allocation for symmetric agents and a 2-WMMS allocation for asymmetric agents (the agent with smaller entitlement divides and the other agent chooses) when the items are goods. However, it is not hard to see that generic divide-and-choose algorithms could be arbitrarily bad when the items are chores.

In the following, we show that with some modification, a divide-and-choose style algorithm, (defined in Algorithm 3), works well and guarantees each agent ’s value to be at least . Without loss of generality, assume .

0:  Chore allocation instance with .
0:  Allocation .
1:  Initially, set for both .
2:  If and , set and . Go to Step 5.
3:  Let agent 2 partition into and according to a P-2 partition with respect to .
4:  Let agent 1 select his favorite bundle from and . Denote by the one chosen by agent 1 and by the one left for Agent 2.
5:  .
6:  return  Allocation .
Algorithm 3 -An Algorithm for the 2-Agent Case
Theorem 2

Let with , and be the output of Algorithm on . Then, for any agent , .


If and , Algorithm allocates all chores to agent 2. Thus and , where agent 1 is trivially satisfied as . By Lemma 1, we have . Accordingly, .

As we assume that , our last case is to consider . By the definition of , . As a result, no matter which allocation agent 2 eventually receives after the divide-and-choose procedure, the value of the allocation will always be at least as much as . For agent 1, since by assumption and he selects his favorite allocation , . By Lemma 1 and the fact that , . Therefore, . ∎

6.2 Binary Valuations

In this section, we study the case with any number of agents, but every agent’s valuation is binary: for all and . Note that, throughout this section, we do not impose normalization for ease of exposition. As will be clear later, for this case, we show that it is always possible to guarantee each agent ’s value to be at least , i.e., the optimal ratio for binary valuation case is exactly 1.

We first prove the following lemma.

Lemma 8

Let be a chore allocation instance where all agents have an identical valuation . If is uniform, (i.e. for any ), an exact allocation can be computed in polynomial time.


It suffices to show if is uniform, Algorithm returns an exact allocation. Suppose is the output of with respect to . Recall . Let be the set of indices where the minimum is obtained. In the following we show . Note that . If is not an optimal partition, then there is a partition such that .

Thus, every , has to contain a smaller number of chores compared with . Accordingly, for some , has to contain more chores than , i.e., . If , cannot be larger than . Thus, . But this is a contradiction with the fact that always allocates greedily, (i.e., Step 4 of ), since the last chore cannot be allocated to for instead of . That is .

Therefore, and for any , which competes the proof. ∎

Thus, by allocating all chores for which some agent has zero value to one such agent, we are left with only the chores for which all agents have value -1. As the modified instance if uniform, by Lemma 8, we have the following theorem.

Theorem 3

For any binary valuation case, a allocation exists and can be found efficiently.

7 Conclusions

We initiated the study on chore allocation with asymmetric agents. We show that many widely studied greedy algorithms in the literature performs badly and even for the 2-agent case an exact WMMS allocation may not exist. We then presented a constant approximation polynomial time algorithm for OWMMS allocations, and several algorithmic results for the case of identical utilities, binary utilities, and for 2 agents. Finding a stronger lower bound for WMMS allocations for any number of agents remains an open problem.


This work is partially supported by NSF CAREER Award No. 1553385. Haris Aziz is supported by a Scientia Fellowship.


  • [1]
  • [Alon1987] N. Alon. Splitting necklaces. Advances in Mathematics, 63(3):247–253, 1987.
  • [Amanatidis et al.2015] G. Amanatidis, E. Markakis, A. Nikzad, and A. Saberi. Approximation algorithms for computing maximin share allocations. In Proceedings of the 35th International Colloquium on Automata, Languages and Programming, pages 39–51, 2015.
  • [Aziz and Mackenzie2016] H. Aziz and S. Mackenzie. A discrete and bounded envy-free cake cutting protocol for any number of agents. In Proceedings of the 57th IEEE Symposium on Foundations of Computer Science, pages 416–427, 2016.
  • [Aziz et al.2017] H. Aziz, G. Rauchecker, G. Schryen, and T. Walsh. Algorithms for max-min share fair allocation of indivisible chores. In

    Proceedings of 31st AAAI Conference on Artificial Intelligence

    , pages 335–341, 2017.
  • [Aziz et al.2018] H. Aziz, I. Caragiannis, and A. Igarashi. Fair allocation of combinations of indivisible goods and chores. CoRR, abs/1807.10684, 2018.
  • [Aziz2016] H. Aziz. Computational social choice: Some current and new directions. In Proceedings of the 25th International Joint Conference on Artificial Intelligence, pages 4054–4057, 2016.
  • [Babaioff et al.2017] M. Babaioff, N. Nisan, and I. Talgam-Cohen. Competitive equilibria with indivisible goods and generic budgets. CoRR, abs/1703.08150, 2017.
  • [Barman and Murthy2017] S. Barman and S. Kumar Krishna Murthy. Approximation algorithms for maximin fair division. In Proceedings of the 18th ACM conference on Economics and Computation, pages 647–664, 2017.
  • [Brams and Taylor1995] S. Brams and A. Taylor. An envy-free cake division protocol. The American Mathematical Monthly, 102(1):9–18, 1995.
  • [Brams and Taylor1996] S. Brams and A. Taylor. Fair Division: From cake-cutting to dispute resolution. Cambridge University Press, 1996.
  • [Budish2011] E. Budish. The combinatorial assignment problem: Approximate competitive equilibrium from equal incomes. Journal of Political Economy, 119(6):1061–1103, 2011.
  • [Cseh and Fleiner2018] A. Cseh and T. Fleiner. The complexity of cake cutting with unequal shares. In

    Proceedings of the 11th International Symposium on Algorithmic Game Theory

    , pages19–30, 2018.
  • [Dubins and Spanier1961] L. Dubins and E. Spanier. How to cut a cake fairly. The American Mathematical Monthly, 68(1):1–17, 1961.
  • [Farhadi et al.2017] A. Farhadi, M. Hajiaghayi, M. Ghodsi, S. Lahaie, D. M. Pennock, M. Seddighin, S. Seddighin, and H. Yami. Fair allocation of indivisible goods to asymmetric agents. In Proceedings of the16th International Conference on Autonomous Agents and Multiagent Systems, pages 1535–1537, 2017.
  • [Farhadi et al.2019] A. Farhadi, M. Hajiaghayi, M. Ghodsi, S. Lahaie, D. M. Pennock, M. Seddighin, S. Seddighin, and H. Yami. Fair allocation of indivisible goods to asymmetric agents. Journal of Artifical Intelligence Research (JAIR), 2019.
  • [Friesen1987] D. Friesen. Tighter bounds for lpt scheduling on uniform processors. SIAM Journal on Computing, 16(3):554–560, 1987.
  • [Garey and Johnson1979] M. R. Garey and D. S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman, 1979.
  • [Ghodsi et al.2018] M. Ghodsi, M. HajiAghayi, M. Seddighin, S. Seddighin, and H. Yami. Fair allocation of indivisible goods: Improvements and generalizations. In Proceedings of the19th ACM conference on Economics and Computation. ACM Press, 2018.
  • [Gonzalez et al.1977] T. Gonzalez, O. Ibarra, and S. Sahni. Bounds for lpt schedules on uniform processors. SIAM Journal on Computing, 6(1):155–166, 1977.
  • [Hochbaum and Shmoys1988] D. Hochbaum and D. Shmoys A polynomial approximation scheme for scheduling on uniform processors: Using the dual approximation approach. SIAM journal on computing, 17(3):539– 551, 1988.
  • [Kurokawa et al.2018] D. Kurokawa, A. Procaccia, and J. Wang. Fair enough: Guaranteeing approximate maximin shares. Journal of the ACM (JACM), 65(2):8, 2018.
  • [Lenstra et al.1990] J. Lenstra, D. Shmoys, and E. Tardos. Approximation algorithms for scheduling unrelated parallel machines. Mathematical programming, 46(1-3):259–271, 1990.
  • [Pinedo2016] M. Pinedo. Scheduling: theory, algorithms, and systems. Springer, 2016.
  • [Procaccia and Wang2014] A. D. Procaccia and J. Wang. Fair enough: Guaranteeing approximate maximin shares. In Proceedings of the15th ACM conference on Economics and Computation, pages 675–692. ACM Press, 2014.
  • [Robertson and Webb1998] J. Robertson and W. Webb. Cake-cutting algorithms: Be fair if you can. 1998.
  • [Stromquist1980] W. Stromquist. How to cut a cake fairly. The American Mathematical Monthly, 87(8):640–644, 1980.

Appendix A Some Commonly Used Greedy Algorithms

In this section, we first show that the greedy round robin algorithm considered by [Farhadi et al.2017] which gives the best guarantee (of -approximation for goods) can be arbitrarily poor for the case of chores. This is surprising because the algorithm only uses ordinal preferences and higher entitlements and higher shares correlate with more items in the goods and chores setting respectively. We also show that natural attempts to ‘fix’ the bad performance of the greedy sequential algorithm does not help. Interestingly, the same round-robin greedy algorithm was proved to provide a 2-approximation for MMS allocation of chores when agents have the same shares [Aziz et al.2017].

a.1 Round Robin

We define the greedy algorithm as follows. The algorithm is oblivious to the shares of the agents. It is based on sequentially allocating items in a round robin manner. Each agent gets turns in a round robin manner to select one of her most preferred chores from all unselected chores.

: Specify an ordering of agents and let agents come in a round robin manner in the specified order and pick an item that is most preferred from the unallocated items. Stop when all the items have been allocated.

Now we construct a bad instance. Let be a chore allocation instance with agents and items, and for . All agents have identical valuation , defined as follows. Denote by , where and , and . That is every agent has value

Since and as , the instance is well-defined. Note that it is easy to see the weighted proportional allocation with respect to is to allocate all chores in to agent , where every agent’s absolute value equals to her share, thus .

However, following the protocol, the items selected by the agents is as follows: for any , during the th round, each agent will select one item from

. That is all items are ‘uniformly’ distributed among all agents such that each agent has value

for his own bundle. Let us consider agent 1 who has the smallest share with . Since

the allocation to agent 1 is arbitrarily bad. Thus, does not have any bounded approximation guarantee for the optimal allocation.

a.2 Multiplicative-Greedy Algorithm

Next we consider the following greedy algorithm to modify the Round Robin algorithm. In contrast to , the picking order of the agents changes dynamically.

: Let each agent’s proportionality value be , which is exactly if we normalize all valuations. Initialize allocation to be empty for each . Consider the agent for whom is the minimum. In case of ties, choose the agent with the largest . If there is still a tie, break tie lexicographically. Let the agent select her most preferred untaken item. Repeat until all items are allocated.

Net we present a bad example to show that cannot provide a good guarantee as well. We consider the following example shown in Table 3. Thus agent 2 selects item 2 and then agent 1 selects item 1. This allocation is arbitrarily bad to agent 1 if is sufficiently small.

Agent Share 1 2
Table 3: Instance 1 on which