An algorithmic framework for approximating maximin share allocation of chores

In this paper, we consider the problem of how to fairly dividing m indivisible chores among n agents. The fairness measure we considered here is the maximin share. The previous best known result is that there always exists a 4/3 approximation maximin share allocation. With a novel algorithm, we can always find a 11/9 approximation maximin share allocation for any instances. We also discuss how to improve the efficiency of the algorithm and its connection to the job scheduling problem.


page 1

page 2

page 3

page 4


Improved maximin fair allocation of indivisible items to three agents

We consider the problem of approximate maximin share (MMS) allocation of...

Approximate and Strategyproof Maximin Share Allocation of Chores with Ordinal Preferences

We initiate the work on maximin share (MMS) fair allocation of m indivis...

Almost Proportional Allocations for Indivisible Chores

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

Strategyproof and Approximately Maxmin Fair Share Allocation of Chores

We initiate the work on fair and strategyproof allocation of indivisible...

The Maximin Share Dominance Relation

Given a finite set X and an ordering ≽ over its subsets, the l-out-of-d ...

Graphical Cake Cutting via Maximin Share

We study the recently introduced cake-cutting setting in which the cake ...

Decentralised Random Number Generation

Decentralised random number generation algorithms suffer from the Last A...

1 Introduction

It is an important research theme in social science, economics and computer science to study how to allocate items among a number of different agents in a fairly manner. The items could be something people like such as house, cake or other resource which are called good, or something people dislike such tasks, duties which are called chores. The rigorous study of fair allocation problem could dated back to 40’s from the seminal work [34]. At the beginning, people are interested in valuable divisible resources and give this kind problem a nick name “Cake Cutting”. Two well known fairness notions are defined and explored: 1) Envy-freeness that each agent prefers her own share of the cake over any other agents’ [17],; 2) Proportionality that each agent gets a share at least the average of the whole cake [34].

For the indivisible items setting, envy-freeness and proportionality may not exist and cannot even be approximated. A simple and somewhat awkward example is that two agents with same valuation to one single item. No matter how you allocate the item, there is one agent getting nothing. From the study of a combinatorial assignment problem with competitive equilibrium, Budish [12] propose the fairness notion of maximin share, which can be considered as a relaxation of proportionality to indivisible setting. The idea of maximin share is from cut-and-choose protocol. In the cut-and-choose protocol, there is a cutter dividing the whole set of resources and cutter must be the last one to choose her share. So the cutter may get the worst share. The maximin share for an agent is the best value that the agent can guarantee if she is the cutter. And an allocation is maximin share allocation if every one gets a share at least her maximin share.

Computer science perspective of maximin share fairness is first studied in the seminal work [28]. They construct a class of instances to show that maximin share allocation may not exist. On the other hand, they demonstrate an exponential time algorithm for approximation of maximin share allocation. This discovery ignites people’s interest in designing efficient algorithm and push the approximation ratio for maximin share allocation. A line of works [9, 20, 19] follow up and improve approximation ratio to and a polynomial time algorithm.

So far most efforts in this area are devoted to studying how to dividing goods. The similar problems for chores are less concerned in the community. We have two reasons to pay attention to indivisible chores setting. 1) Technically, it may betray some people’s expectation that the problems for chores and goods are intrinsic different in many situations of indivisible setting. For example, there is a pseudo-polynomial time algorithm for Pareto optimal allocation with certain fairness for indivisible goods [10], but the existence of such kind allocation for indivisible chores is still unclear. And in this paper, we will show an algorithmic framework that is suitable for chores but no direct implication for goods. 2) Practically, there are many applications in daily life that allocating indivisible chores are involved. For example, household chores dividing, assignment of TA duties and the famous problem job scheduling etc. And this problem is also closely related to bin packing problem.

Recently, Aziz et al. [7] apply the maximin share notion to chores. For chores, maximin share should be minimax share, minimum value (duty/work load) that the agent can guarantee if she is the cutter. If one use negative value for chores, it can still be called maximin share, and we follow the literature to use the term “maximin” and use positive value for notational simplicity. They show that maximin share allocation may not exist for dividing indivisible chores and demonstrate a polynomial time algorithm for approximation. Later Barman et al. [9] improved this result to a polynomial time algorithm for approximation.

Our work follows this direction to analysis the approximation ratio and design efficient algorithm for maximin share allocation under indivisible chores setting.

1.1 Our results and techniques

All of our results reply on a novel algorithmic framework which combines some existent ideas. The first building block of our frame work is a technique by Bouveret and Lemaître [11], which allow us to focus on the class of instances that agents share a same ordinary preference. This technique has been successfully applied to approximating of maximin share for goods [9, 19]. Another part of our algorithmic framework is similar to the famous First Fit Deceasing (FFD) algorithm for bin packing problem [27]. The core ideas of this part are simple: 1. As long as the bundle is within the bin size, put items in the bundle as many as possible; 2. Try to allocate large item first because they are problematic.

Under this algorithmic framework, we prove our main result.

Theorem 1.

For any chore division instance , there always exists an approximation maximin share allocation.

To combine above two ideas, the algorithm is very simple: Order the chores in decreasing order (we can do that since we can assume that agents share a same ordinary preference), fill in a bundle with as many chores as possible in a greedy fashion as long as some agent think it is within of her maximin share. Then one such agent takes the bundle and leaves the game. We repeat this times, where is the number of agents. It is clear that each agent gets at most of her maximin share. To verify that it is indeed an maximin share  allocation, we only need to prove that all the chores are allocated during the process. This is however highly non-trivial. We need to maintain some invariant property during the process and argue that it will allocate all the chores. If one replaces with a smaller ratio, can we still show that it will allocate all the chores? We do not know. We show by an example that one cannot make the ratio as small as but leave the tight possible ratio as an interesting open question.

The above algorithm is very simple but need to know maximin share of each agent. Computing that value is exactly a job scheduling/load balancing problem which is NP-hard. Since there is a PTAS for job scheduling problem [24], we have a PTAS for approximation of maximin share allocation.

However, the PTAS may not be considered as an efficient algorithm for some practical application if is small. To get a really efficient algorithm, we notice that it may not be necessary to get an accurate value of maximin share. What we need is a reasonable lower bound of maximin share  for each agent to make the algorithmic framework execute correctly. This kind idea has already been applied to design efficient algorithm for fair allocation of indivisible goods [19]

. With this idea, we try to pre-allocate all chores in an appropriate and easy implement way according to one particular agent’s valuation, and then from this pre-allocation we can estimate a lower bound of maximin share  for this particular agent. This complicates the argument, it is not clear if we can get the same ratio of

. In this paper, we show that a slight worse ratio of is achievable. We leave the problem of giving a polynomial time approximation algorithm as an open problem.

One special case of our problem is that all agents have a same valuation for chores. We notice that the problem of job scheduling on identical machines is exactly this special case. Based on our algorithm, we can design an very efficient time algorithm to get a approximation of optimal scheduling. To the best of our knowledge, except those PTAS which is not that efficient, there is no algorithm approximating optimal better than .

1.2 Related work

The topic of fair division has a long history; it originates from the work of Steinhaus [34] in the 40’s and triggers vast literatures on this subject, e.g. please refer books [33, 30]. Most literatures in this area work on divisible setting, including very recent breakthroughs like the envy-free cake-cutting protocol of Aziz and McKenzie [6]

. In contrast, fairly allocating indivisible items among agents has not been as popular until very recently. The delay probably is caused by the lack of suitable fairness notions.

The recent interest for the indivisible items setting was sparked with the definition of fairness notions that approximate envy-freeness and proportionality. In particular, the notions of EF1 and EFX, defined by Budish [12] and Caragiannis et al. [14] can be thought of as an approximate version of envy-freeness and has received much attention recently, e.g. explore the existence [32, 13], investigate the relationship with efficiency [14, 10] Besides the concepts of EF1 and EFX mentioned above, approximate versions of envy-freeness include epistemic envy-freeness [2] or notions that require the minimization of the envy-ratio [29] and degree of envy [15, 31] objectives.

The notion of maximin fair share (MMS) was first proposed by Budish [12] and inspired a line of works. In the seminal work [28], they prove MMS fairness may not exist but approximation of MMS can be guaranteed. Due to their work, the best approximation ratio of MMS and polynomial time algorithm for finding that one becomes an intriguing problem. Barman et al. [9] design a polynomial time algorithm for approximation of MMS. Later, Ghodsi et al. [20] they further improve the existence ratio of MMS to . Shortly after, Grag and Taki [19] show a polynomial time algorithm for approximation of MMS by combing all techniques for this problem.

For the chores setting, Aziz et al. [7] started the research on maximin sharenotion and the provide a polynomial algorithm for 2 approximation. With the same technique for goods, Barman et al.  [9] also showed a polynomial time algorithm for approximation of MMS for chores. And to the best of our knowledge, the ratio was the state of art before this paper.

Except maximin fairness, recently a line of study explores the problem fair division of indivisible chores from different perspectives. Aziz et al. [3] proposed a model for handling mixture of goods and chores. The paper [5] showed that strategyproofness would cost a lot on maximin fairness for chores. Aziz et al. [4] also considered the case that agents have different weights in allocation process.

The problem of job scheduling/load balancing is a special case of allocating indivisible chores. It is a fundamental discrete optimization problem, which has been intensely studied since seminal work [22]. Graham [21] show that the famous Longest Processing Time rule can give a approximation to the optimal. Later Hochbaum and Shmoys [23] first discovered a PTAS for this problem. And a line of follow up works [1, 25, 24] try to improve the running time by developing new PTAS algorithm.

Our algorithmic framework is similar to First Fit Decreasing (FFD) algorithm for bin packing problem. Johnson in his doctoral thesis [27] first showed the performance of FFD is tight to upon an additive error. On the demanding of simplify the proof and also tighten the additive error, a serious work [8, 35, 16] devoted to this problem and finally got optimal parameters. A modified and more refined version of FFD was proposed and proved can approximate optimal to the ratio  [26].

1.3 Organization

In section 2, we introduce some basic notations and concepts for the paper. In section 3, we demonstrate our algorithmic frame work which is the foundation of this work. And then we prove the existence of allocation by the algorithmic frame work in section 4. Follow the existence result, in section 5, we push further to have an efficient polynomial time algorithm for -MMS allocation. In section 6, we connect our problem with the job scheduling problem and obtain an efficient algorithm. Finally, in section 7 we discuss some future directions and open problems for our algorithmic framework.

2 Preliminary

We introduce some basic definitions and concepts for our model here. An instance of dividing indivisible chores problem is denoted as , where is the set of agents, is the set of chores, and is the collection of all valuations. Let be the number of agents and be the number of chores. The valuation function of each agent is additive, i.e. for any set . The collection of all valuations can be equivalently written as .

Notice here we use non-negative valuation function which is the same as goods setting. However, the meaning is quite different. Intuitively, the value is equivalent to the work load for . So each agent wants to minimize her value. An allocation is a partition of all chores which allocates all chores to each agent . We denote all possible allocations as the set .

The maximin shareof an agent is defined as

Following is a formal definition for maximin share allocation.

Definition 1 (Maximin share allocation).

An allocation is a maximin share(MMS) allocation if

An allocation is called -MMS allocation if the inequality holds for any agent .

For the proof of our algorithm, the following is a useful definition.

Definition 2 (Maximin share allocation for agent ).

An allocation is a maximin share share allocation for agent , if

Definition 3 (Identical ordinary preference).

An instance is called identical ordinary preference(IDO) if there is a permutation on such that, when , we have the inequality holds for any agent .

As we will constantly use the notion of -th largest chore of a bundle in the description of the algorithm and the proof, here we give a notation for it.

Definition 4.

Given an instance and a bundle (a set of chores) , we denote as the -th largest chore in bundle from agent ’s perspective. For IDO instance, since every agent share the same ordinary preference, we will shortcut it as .

For example, for an IDO instance, and would be the largest and the second largest chore of all.

3 Algorithmic framework

In this section, we present a general algorithm framework for dividing chores. The algorithmic framework has two parts. In the first part, we show how to reduce general instances to IDO instances, which is from the work [11]. In the second part, we demonstrate a strategy that is useful to find a proper approximation of maximin share allocation for chores. This strategy shares some similarity with First Fit Decreasing algorithm for bin packing problem [27].

3.1 Reduction from general to identical ordinary preference

In this section, we formally state a reduction technique which is introduced by Bouveret and Lemaître [11]. By this reduction, we only need to take care of instances such that all agents share the same ordinary preferences. And this technique has been successfully applied in the work [9] to simplify the proof of approximation of maximin share allocation for goods.

Definition 5 (Ordered instance).

Given any instance , the corresponding ordered instance of   is denoted as , where:

  • , and

  • For each agent and chore , we have

Input: , its ordered instance , and an allocation of
Output: An allocation of
1 Let and ;
2 for  to  do // values from smallest to largest
3       Let be the agent such that ;
4       Find ;
5       and ;
7 end for
Algorithm 1 Reduction
Lemma 1.

Given an instance , its ordered instance and an allocation of , Algorithm 1 will output an allocation such that for each agent .


To prove this lemma, it is sufficient to prove that in line 1 of the algorithm, the chore satisfies . Because if this is true, after adding up all these inequalities, we can get .

Look at the For loop in Algorithm 1. In the round of , there are in total chores left in i.e. . We have . ∎

Since the set of chores of ordered instance is the same as , the maximin share of each agent is the same in both instances.

Lemma 2.

Suppose algorithm runs in time and returns an -MMS allocation for all identical ordinary preference instances. Then, we have an algorithm running in time outputting an -MMS allocation for all instances.


Given such an algorithm , we can construct an algorithm for the general instance as following.

Given a chore division instance , we can construct its ordered instance in time, which is by sorting algorithm for all agents. And then we run algorithm on the instance to get an -MMS allocation for . Then we run Algorithm 1 on to get an allocation of instance . The Algorithm 1 can be done in time. And with lemma 1, we know that is an -MMS allocation of instance . ∎

3.2 Algorithm for identical ordinary preference

With the above reduction, we can focus on the identical ordinary preference. We introduce a heuristic which is a key part for building our maximin share approximation algorithm.

Input: An IDO instance , threshold values of agents
Output: An allocation
1 Let and and ;
2 for  to  do
3       ;
4       for  to  do
5             if  then
6                   ;
7             end if
9       end for
10      ;
11       Let be an agent such that ;
12       and ;
14 end for
Algorithm 2 Algorithm for -MMS

For this algorithm we have the following observation.

Lemma 3.

Suppose that the inequality holds for each . If all chores are allocated by the algorithm, then the allocation returned by Algorithm 2 is an -MMS allocation.

To analysis the algorithm, we only need to focus on what threshold values will make the algorithm allocate all chores.

4 Main result

In this section, we show that an approximation maximin share allocation always exists by our algorithmic framework by verifying that Algorithm 2 indeed allocates all the chores. This is done by a careful comparison between the algorithm’s allocation and the maximin share allocation.

Theorem 1.

For any chore division instance , there always exists an -MMS allocation

By Lemma 3, it is sufficient to prove that, for all IDO instances, on input threshold value to Algorithm 2, there is no chore remained. Suppose that agent is the last one who gets the bundle in the execution of Algorithm 2. Without loss of generality, we assume that . Now let us focus on the view of agent . If agent always gets all remaining chores for the last bundle, then the correctness of theorem is implied.

Our proof has two parts that we prove all “small” chores will be allocated first, and then analysis what happened to “large” chores. Here we give a formal definition of “small” and “large”. Notice that these notations will also be used in other sections.

Definition 6.

With parameter and index of some agent, we define the set of “large” chores as

and define the set of “small” chores as

First we prove, from agent ’s view, there is no small chore remained after the algorithm terminates.

Lemma 4.

If we input threshold value to Algorithm 2, then there is no chore remained after the algorithm terminates.


We will prove the statement by contradiction. Suppose that there is a chore remained. For any bundle , we must have , otherwise Algorithm 2 will allocate the chore to the bundle . Thus, we get as . Since the value is 1, the total valuation should not exceed . When we add up the valuations of all bundles, we have , which is a contradiction. Therefore, there is no chore remained. ∎

Now we will analysis that there is no large chore left. Suppose is the allocation returned by the algorithm and is a maximin share allocation for agent . Without loss of generality, we can assume the bundles in are sorted as following: For any , the bundle is generated by the algorithm when of the for loop in line 2. And define the bundle as and the bundle as .

Lemma 5.

If we input threshold value to Algorithm 2, then there is no chore remained after the algorithm terminates.


Let bundle collection include all . Notice that . Our target is to generate bundle collection from by swapping chores between bundles, so that for all . If this process can successfully proceed, then which means all chores are allocated.

To prove this, we will show that, for , bundles satisfies a good property by induction. Let

denote the sum of largest and smallest chore in the bundle.

Good bundle: A bundle is good if

Here we slightly abuse the concept “good” for bundle collection.

Good bundle collection: A bundle collection is good if for all , and for each bundle is good.

Clearly, the bundle collection is good. Suppose when , the bundle collection is good. We will prove, when , by swapping some chores from , we can construct a good bundle collection .

Here we introduce two operations that is very helpful in construction from . Given a bundle collection and two chores and , the operation will generate a new bundle collection such that: If or, and are in the same bundle, then ; Otherwise

This operation swaps chore and .

Given a bundle collection , an index and a subset of chores , the operation will generate a new bundle collection such that

This operation moves chores set from their original bundles to the bundle indexed by .

Without loss of generality, we can assume that contains the largest chore among chores (we can rename the bundle which contains the largest chore to be ). It is easy to see that , as Algorithm 2 always allocates the largest chore of remaining to a new bundle. So, we only need to take care of remaining chores from both bundles. Now we describe and prove the correctness of the swapping process by case analysis. Since each has and , we know that each contains at most chores. During the swapping process, we keep the property that for each bundle contains at most chores. The following case analysis is based on the size of .

  • : We just move other chores in if any from their original bundles to . Formally, we have

    The bundle with index larger than either does not change or remove some chores. Thus a good bundle is still good. This gives that bundle collection is good.

  • : First we have the cardinality , because Algorithm 2 can at least allocate to for the second chore. So we also have . If , then we swap two chores. If there are more chores in bundle i.e. , then we just move remaining chores from their original bundles to . Mathematical equivalently, for , we have

    The bundle with index larger than either does not change or remove some chores. Thus a good bundle is still good. This gives that bundle collection is good.

  • : By a similar argument as the above case, we have . Let

    be the bundle collection that swap chore and chore . Now we consider the following inequality:


    If the Inequality 1 holds, then we have and . For this case, we will swap chore and chore and move remaining chores in bundle to bundle , i.e.

    In this subcase, the bundle with index larger than either does not change or remove some chores. Thus a good bundle is still good. This gives that bundle collection is good.

    If the Inequality 1 does not hold, then we move to the bundle where comes from and then move other chores in to . Let be an index of a bundle such that . Then, formally this process is

    This is the most complicated case since contains more item than . We prove that bundle is good in Claim 2. And for other bundles with index larger than , it either does not change or remove some chores. Therefore, bundle collection is good.

  • : Using the property of good bundle, we prove that and for in Claim 1. For such chores, we swap them one by one. If the cardinality , then we just move remaining chores from their original bundles to .

    Formally the process is described as following. Let bundle collection and bundle collection for . We have

    The bundle with index larger than either does not change or remove some chores. Thus a good bundle is still good. This gives that bundle collection is good.

Claim 1.

For the case , we have and for .


First we prove that the inequality is true. Since bundle is good, we have the condition or . If the valuation , then as any chores in the bundle is greater than 2/9, we have

Now we prove the inequality

Suppose . Let be the value of . Then we have

(by )

This implies . This contradicts our assumption that .

Notice that is the value of largest chore among the remaining. So the inequality suggests that even if we allocate 3 largest chores, there is still a space for the chore . So the first 3 chores being allocated to bundle must be the largest 3 chores. So for .

As we have , the chore would not be one of first 3 chores allocated to bundle . Since there is a space for the chore , the forth chore being allocated to bundle should at least as large as the chore . Combining all these, we have and for . ∎

Claim 2.

For the case and Inequality 1 does not hold, after all and operations, bundle is good, where is the index such that .


We first prove two useful observations.

Observation 1.

The chore must be the largest chore in the bundle .


Because and it is good, so , which means . This implies all remaining chores are less than . Therefore, add the second largest chore, it is still less than . We have must be the largest chore in the bundle . ∎

Observation 2.

For the valuation of chore , we have .


As Inequality 1 does not hold, we have

By the assumption that , we get

Now we prove the statement by case analysis on the number of chores in the bundle

For the case that bundle only contains the chore i.e. , it is easy to see bundle is good after replacing the chore with chores and .

If bundle contains two chores i.e. , we prove the valuation . First we have following inequality

For the valuation of bundle , we have

The first inequality is due to the chore is no less than the other chore in bundle . The second inequality is just follow the above inequality. Thus, bundle is still good.

Now let us look at the case . Since bundle is good, we have . By Observation 2, we have . Therefore, except the chore , the valuation of the remaining two chores in bundle is

As the valuation and bundle is good, we have

For the bundle , the largest chore is either in the set or in the set Therefore, the valuation

It is easy to see, in this case, the cardinality . Thus, bundle is good.

It is impossible that . Since bundle is good, if , then we have As bundle , it implies that the valuation of the largest chore

This contradicts to Observation 2 i.e. . So it is impossible.

It is easy to see that, for a good bundle, if we replace one chore with a smaller chore, it is still good. The only case, which may increase the number of chores or increase the value of chores, is concluded in claim 2. Thus we can keep this process to . ∎

With above two lemmas, now we can show the correctness of theorem 1.

Proof of Theorem 1.

Combing Lemma 4 and Lemma 5, we have Algorithm 2 will output a -MMS allocation when input . ∎

We can transfer the existence result of Theorem 1 to a PTAS. The only computational difficulty part is the value of maximin share of each agent. Notice that computing maximin share of an agent is exactly the makespan of a job scheduling problem. This can be solved by a PTAS from job scheduling literature [24]. Therefore, from the result of existence 11/9 approximation maximin share allocation, we have a PTAS for approximation maximin share allocation. The constant 11/9 could be improved if anyone can prove a better existence ratio of our algorithmic framework.

Given above result, it is natural to ask what is the best approximation ratio of our algorithmic framework. Though we cannot prove the best ratio now, we present the following example to show a lower bound of our technique.

Example 4.1.

In this example, we consider an instance of 14 chores and 4 agents with an identical valuation (not just ordinal, but cardinal is also same). The valuation of each chore is demonstrated by the optimal allocation.

An optimal allocation of this instance is that

where the numbers are valuations of each chore. Obviously, the maximin share of each agent is 1. However, if we input to Algorithm 2, then not all chores could be allocated.

Example 4.1 implies the following result.

Theorem 2.

The best approximation ratio for Algorithm 2 with inputting threshold value cannot less than .

5 Road to a really efficient algorithm

To run our algorithm for 11/9 approximation maximin share, we need to know the maximin share of each agent. The computation of these quantities are NP-hard. Though we have a PTAS for approximation, even if we want to get a approximation with currently best PTAS for job scheduling [24], the running time could be more than . This is not acceptable for a real computation. To attack this computational embarrassing, we give a trial on designing an efficient polynomial time algorithm for 5/4 approximation maximin share  allocation.

We will present a threshold testing algorithm first. Upon giving a threshold value and an agent, the threshold testing algorithm can test whether the threshold is large enough or not to finish a special allocation for that particular agent. The main algorithm first use the threshold testing algorithm as an oracle to do binary search for finding a reasonable lower bound of maximin share of each agent. And then plug in certain threshold value of each agent to the algorithmic framework which is introduced in section 3.

The following is the threshold testing algorithm.

Input: Index of an agent, a threshold value
Output: Yes/No
1 Let ;
2 // Please refer the Definition 6 ;
3 Initialize an allocation such that for and for Let denote the set of remaining ‘‘large” chores;
4 for  to  do
5       if  such that  then
6             ;
8       end if
10 end for
12 // The following for-loop is similar to Algorithm 2 ;
13 for  to  do
14       for  to  do
15             if  then
16                   ;
18             end if
20       end for
21      ;
23 end for
24if  then
25      return Yes;
27      return No;
28 end if
Algorithm 3 Threshold testing

At the first look of this threshold testing algorithm, people may wonder why we design it like this. Here is a remark for it:

  • People may wonder why we don’t just use Algorithm 2 with input of valuations and thresholds as threshold testing? The threshold obtained by Algorithm 2 can guarantee that for each agent , when input the same valuation and the same threshold to Algorithm 2, all chores will be allocated. To get a full allocation, we need put all agents’ valuations and thresholds together to Algorithm 2. However, this step may not work. Please see the discussion of Example 5.1. Actually, Example 5.1 shows a more surprising fact about Algorithm 2. Intuitively, people may think the following monotonicity should hold: for any when input valuations and thresholds to Algorithm 2, all chores should be allocate. However, the following Example 5.1 disproves this monotonicity.

  • The ratio 11/9 in line 3 can be any number between 11/9 and 5/4. Actually, Algorithm 3 only considers the large chores in , smaller constant would not be a help. The choice of this constant only need to satisfy two properties: 1) When the threshold , the process should allocate all chores; 2) The final allocation can serve as a benchmark for the proof of 5/4 approximation to maximin share allocation.

Intuitively, people may think if Algorithm 2 can allocate all chores on input of threshold values , then Algorithm 2 should allocate all chores with larger threshold values. Here we give a counter example for this monotonicity.

Example 5.1.

In this example, we consider an instance of 17 chores and 4 agents with an identical valuation. The valuation of each chore is demonstrated by the optimal allocation.

An optimal allocation of this instance is that

where the numbers are valuations of each chore. The maximin share of each agent is 7.5. You can verity that if we input threshold value to Algorithm 2, all chores will be allocated. And the allocation is exactly the optimal allocation we give here.

However, if we input threshold value 7.6 to Algorithm 2, we have

There are 2 chores remained.

If we use Algorithm 2 as threshold testing, then it is possible that we get a 7.5 as threshold for the agent in above example. We can construct another agent that can take the largest and the fourth largest chores as an accepting bundle. Now let us put 3 agents with valuation as above example and this constructed agent together. This instance would directly imply Algorithm 2 cannot be used as threshold testing.

For the correctness of binary search, we need monotonicity of the algorithm i.e. threshold testing for agent should return YES on all values larger than . Otherwise, the binary search may not terminate correctly to return a lower bound of . Though Example 5.1 shows in general monotonicity does not hold. We prove that by the choice of parameters, the following monotonicity holds.

Lemma 6.

For any , if we input to Algorithm 2, all chores will be allocated.


The proof of Lemma 4 and Lemma 5 work for all values larger than . The only requirement on value to make proof work is that: there is an allocation such that for all . And this is certainly true for any . ∎

Now we prove that our threshold testing algorithm has the following monotone property.

Lemma 7.

If we input and to Algorithm 3, then the algorithm will return Yes.


Let denote the set of chores which are allocated in the for-loop of line 3. Let be the number of really large chores. Let be the allocation output by Algorithm 3 on input agent and threshold . After line 3 of threshold testing, the set of remaining chores is i.e. the chores that are valued between