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 counterexample. 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?
Contributions
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 polynomialtime algorithm which provides a 4approximation 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 twoagent setting and a binary valuation setting. For the twoagent case, we present a variant of divideandchoose 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 envyfreeness 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 NPhard 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 2approximated by a simple roundrobin 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 outofd 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 .
Proof.
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 .
Proof.
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.
Example
Let be a chore allocation instance, where , and the agents’ shares and valuations are shown in Table 1.
Chores  

Agent  Share  1  2  3  4 
1  
2 
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 2agent 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.
Proof.
In the following we construct an instance with , and the shares and valuations are shown in Table 2.
Items  

Agent  Share  1  2 
1  
2 
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 2approximation 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 polynomialtime 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 polynomialtime 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 2approximation to an exact allocation.
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
Proof.
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 2approximation to the optimal allocation.
However, there are two computational issues with respect to the procedure above: (1) The computation of may need exponential time^{1}^{1}1 The computation of is NPhard, 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 .
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 , .
Proof.
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 (polynomialsized) linear program, runs in polynomial time. ∎
Note that the role of in can be replaced by other (polynomialtime) 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 2agent case is within .
Divideandchoose 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 2WMMS 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 divideandchoose algorithms could be arbitrarily bad when the items are chores.
In the following, we show that with some modification, a divideandchoose style algorithm, (defined in Algorithm 3), works well and guarantees each agent ’s value to be at least . Without loss of generality, assume .
Theorem 2
Let with , and be the output of Algorithm on . Then, for any agent , .
Proof.
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 divideandchoose 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.
Proof.
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 2agent 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.
Acknowledgements
This work is partially supported by NSF CAREER Award No. 1553385. Haris Aziz is supported by a Scientia Fellowship.
References
 [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 envyfree 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 maxmin 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. TalgamCohen. 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 envyfree cake division protocol. The American Mathematical Monthly, 102(1):9–18, 1995.
 [Brams and Taylor1996] S. Brams and A. Taylor. Fair Division: From cakecutting 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 NPCompleteness. 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(13):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. Cakecutting 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 roundrobin greedy algorithm was proved to provide a 2approximation 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 welldefined. 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 . Sincethe allocation to agent 1 is arbitrarily bad. Thus, does not have any bounded approximation guarantee for the optimal allocation.
a.2 MultiplicativeGreedy 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.
Chores  

Agent  Share  1  2 
1  
2 