An Algorithmic Framework for Approximating Maximin Share Allocation of Chores

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 fair manner. The items could be something people like such as a house, cake or other resources which are called goods, or something people dislike such as tasks or duties which are called chores. The rigorous study of the fair allocation problem dates back to the 1940’s starting from the seminal work of . At the beginning, researchers were interested in valuable divisible resources and nicknamed this problem “Cake Cutting”. Two well known fairness notions are defined and explored: 1) Envy freeness – each agent prefers her own share of the cake over any other agent’s ; 2) Proportionality – each agent gets a share at least as valuable as the average of the whole cake .

However, when researchers began to study the indivisible setting, the story changed dramatically. The reason is that, for indivisible items, envy-free and proportional allocations may not exist, and even approximation is impossible. A simple and somewhat awkward example is that of two agents with the same valuation for one single item. No matter how you allocate the item, there is one agent getting nothing.

So how should we divide indivisible items fairly? We need a more delicate fairness concept. Budish proposed a relaxation of proportionality, which is called maximin share. It is considered as one of most successful fairness concepts for studying indivisible items. The idea of maximin share comes from the cut-and-choose protocol. In the cut-and-choose protocol, there is a cutter dividing the whole set of resources and the cutter must be the last one to choose her share. As 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. An allocation is a maximin share allocation if everyone gets a bundle at least as valuable as her maximin share.

Recently, the notion of maximin share attracted a lot of attention from the computer science community since the seminal work of . For goods, Kurokawa et al. show that a maximin share allocation may not exist. On the other hand, they demonstrate an exponential time algorithm for $\frac{2}{3}$ approximation of maximin share allocation. A line of works follow up to design efficient algorithms and improve the approximation ratio. For chores, Aziz et al. show that maximin share allocation may not exist and demonstrate a polynomial time algorithm for $2$ approximation. Later Barman and Khrishna Murthy improved this result to a polynomial time algorithm for $\frac{4}{3}$ approximation.

So far, most efforts in this area are devoted to studying how to divide goods. The parallel problems for chores are less discussed 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 intrinsically different. For example, maximum Nash welfare allocation is Pareto optimal with certain fairness for goods , however no single valued rule can be efficient with good fairness guarantee for chores . In this paper, we will show an algorithmic framework that is suitable for chores but has no direct implication for goods. 2) Practically, there are many applications in daily life in which allocating indivisible chores is 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.

We focus on two questions: What is the best ratio for which an approximation allocation exist? Can we design an efficient algorithm with a better approximation ratio? We make significant contributions to these questions in this paper.

All of our results rely on a novel algorithmic framework which combines some existent ideas. The first building block of our framework is a technique by Bouveret and Lemaître , which allows us to focus on the class of instances where agents share the same ordinal preference. This technique has been successfully applied to approximation of maximin share for goods . Interestingly, we identify a similarity between our algorithmic framework and well-known First Fit Decreasing (FFD) algorithm for the bin packing problem . The core ideas of this part are simple: 1. As long as the bundle is within the bin size, add as many items as possible to the bundle; 2. Try to allocate large items first (as they’re more problematic).

Under this algorithmic framework, we prove our main result.

For any chore division instance $\mathcal{I}$, there always exists an $\frac{11}{9}$ approximation maximin share allocation.

To combine the above two ideas, the algorithm proceeds as follows: Order the chores in decreasing order (using the reduction from a general instance to an instance such that all agents share the same ordinary preference ), and fill a bundle with as many chores as possible in a greedy fashion, as long as some agent thinks it is within $\frac{11}{9}$ of her maximin share. Then one such agent takes the bundle and leaves the game. We repeat this $n$ times, where $n$ is the number of agents. It is clear that each agent gets at most $\frac{11}{9}$ of her maximin share. To verify that it is indeed an $\frac{11}{9}$ 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 $\frac{11}{9}$ 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 $\frac{20}{17}$, but leave the tightness of the ratio as an interesting open question.

The above algorithm is quite simple, but needs to know the maximin share of each agent. Computing that value is precisely a job scheduling/load balancing problem, which is NP-hard. Since there is a PTAS for the job scheduling problem , we have a PTAS for $\frac{11}{9}+\epsilon$ approximation of maximin share allocation.

However, the PTAS may not be considered as an efficient algorithm for some practical applications if $\epsilon$ is small. To get a truly 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. This kind idea has already been applied to design efficient algorithms for fair allocation of indivisible goods . With this idea, we try to pre-allocate all chores in an appropriate and easy-to-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, and it is not clear if we can get the same ratio of $\frac{11}{9}$. In this paper, we show that a slightly worse ratio of $\frac{5}{4}$ is achievable. We leave the problem of giving a polynomial time $\frac{11}{9}$ approximation algorithm as an open problem.

One special case of our problem is that all agents have the 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 a very efficient $O(m\log m+n)$ time algorithm to get a $\frac{11}{9}$ approximation of optimal scheduling. To the best of our knowledge, except for the PTAS which is not so efficient in practice, there is no algorithm approximating optimal better than $\frac{4}{3}$.

2 Related work

The topic of fair division has a long history; it originates from the work of Steinhaus in the 40s, which triggered vast literatures on this subject – we refer the reader to the books for an overview. Most of the literature in this area focuses on the divisible setting, including very recent breakthroughs like the envy-free cake-cutting protocol of Aziz and McKenzie and a similar result for chores . In contrast, fairly allocating indivisible items among agents has not been similarly popular, until very recently. The delayed interest is likely caused by the lack of suitable fairness notions.

The recent interest for the indivisible items setting was sparked by the definition of fairness notions that approximate envy-freeness and proportionality. In particular, the notions of EF1 and EFX, defined by Budish and Caragiannis et al. can be thought of as an approximate version of envy-freeness and have received much attention recently. Some works explore their existence , others investigate the relationship with efficiency . Besides the concepts of EF1 and EFX mentioned above, approximate versions of envy-freeness include epistemic envy-freeness or notions that require the minimization of the envy-ratio and degree of envy objectives.

The notion of maximin fair share (MMS) was first proposed by Budish and inspired a line of works. In the seminal work of , the authors prove that MMS fairness may not exist, but a $\frac{2}{3}$ approximation of MMS can be guaranteed. Due to their work, the best approximation ratio of MMS and a polynomial time algorithm for finding it becomes an intriguing problem. A line of works tries to design an efficient algorithm for a $\frac{2}{3}$ approximation of MMS allocation. Ghodsi et al. further improve the existence ratio of MMS to $\frac{3}{4}$. Shortly after, Grag and Taki show a polynomial time algorithm for $\frac{3}{4}$ approximation of MMS by combining all previous techniques for this problem.

For the chores setting, Aziz et al. initiate the research on maximin share notion and provide a polynomial algorithm for 2 approximation. Utilizing the technique for goods, Barman et al. also showed a polynomial time algorithm for $\frac{4}{3}$ approximation of MMS for chores. To the best of our knowledge, the ratio $\frac{4}{3}$ 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. proposed a model for handling mixture of goods and chores. The paper showed that strategyproofness would cost a lot on maximin fairness for chores. Aziz et al. considered the case that agents have different weights in the 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 the seminal work . Graham showed that the famous Longest Processing Time rule can give a $\frac{4}{3}$ approximation to the optimal. Later Hochbaum and Shmoys discovered a PTAS for this problem. A line of follow up works try to improve the running time by developing new PTAS algorithms.

Our algorithmic framework is similar to First Fit Decreasing (FFD) algorithm for the bin packing problem. Johnson in his doctoral thesis first showed the performance of FFD for the bin packing problem is tight to $\frac{11}{9}$ upon an additive error. To simplify the proof and tighten the additive error, subsequent works were devoted to this problem and finally got optimal parameters. A modified and more refined version of FFD was proposed and proved to be approximately tight up to the ratio $\frac{71}{60}$ .

3 Organization

In section 2, we introduce some basic notations and concepts for the paper. In section 3, we demonstrate our algorithmic framework which is the foundation of this work. We prove the existence of an $\frac{11}{9}$-approximation allocation by the algorithmic framework in section 4. Following the existence result, in section 5 we push further to have an efficient polynomial time algorithm for $\frac{5}{4}$-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.

Preliminary

Notice here we use non-negative valuation function which is the same as goods setting. However, the meaning is the opposite. Intuitively, the value is equivalent to the workload for $S$. So each agent wants to minimize her value. An allocation $\mathbf{A}=\left(A_{1},\dots,A_{n}\right)$ is a $n$ partition of all chores $\mathcal{M}$ which allocates all chores $A_{i}$ to each agent $i$. We denote all possible allocations as the set $\Pi_{n}(\mathcal{M})$.

The maximin share of an agent $i$ is defined as

Here compare to maximin share, minimax share may be a more proper name. Since we minimum the 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.

Following is a formal definition for maximin share allocation.

An allocation $\mathbf{A}\in\Pi_{n}(\mathcal{M})$ is a maximin share (MMS) allocation if

An allocation $\mathbf{A}$ is called $\alpha$-MMS allocation if the inequality $v_{i}\left(A_{i}\right)\leq\alpha\cdot\mbox{MMS}_{i}$ holds for any agent $i$.

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

An allocation $\mathbf{A}\in\Pi_{n}(\mathcal{M})$ is a maximin share allocation for agent $i$, if

An instance $\mathcal{I}$ is called identical ordinary preference (IDO) if there is a permutation $\sigma$ on $[m]$ such that, when $j\geq k$, we have the inequality $v_{i}\left(c_{\sigma(j)}\right)\geq v_{i}\left(c_{\sigma(k)}\right)$ holds for any agent $i$.

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

Given an instance $\mathcal{I}$ and a bundle (a set of chores) $B\subseteq\mathcal{M}$, we denote by $B[i,j]$ the $j$-th largest chore in bundle $B$ from agent $i$’s perspective. For IDO instance, since every agent share the same ordinary preference, we will shortcut it as $B[j]$.

For example, for an IDO instance, the item $\mathcal{M}$ and the item $\mathcal{M}$ would be the largest and the second largest chore of all.

Algorithmic framework

In this section, we present a general algorithm framework for dividing chores. The algorithmic framework is building on a reduction and a heuristic. The reduction is from the work , which allows us to focus on IDO instances. Then, we demonstrate a heuristic for IDO instances, which is similar to First Fit Decreasing algorithm for bin packing problem .

The reduction from general instances to IDO instances is captured by the following lemma. The original statement is for goods. As the setting of chores is slightly different from goods, we give a full detail in Appendix A for the completeness.

Suppose that there is an algorithm $G$ running in $T(n,m)$ time and returning an $\alpha$-MMS allocation for all identical ordinary preference instances. Then, we have an algorithm running in time $T(n,m)+O(nm\log m)$ outputting an $\alpha$-MMS allocation for all instances.

With the above reduction, we can focus on the identical ordinary preference. We introduce a heuristic which is a key part of our approximation algorithm. The high level idea is that we setup a threshold for each agent, and then allocate large chores first and allocate them as much as possible with respect to the threshold.

For this algorithm we have the following observation.

Suppose that the inequality $\alpha_{i}\leq\alpha\cdot\mbox{MMS}_{i}$ holds for each $i$. If all chores are allocated by the algorithm, then the allocation returned by Algorithm 1 is an $\alpha$-MMS allocation.

To analyze the algorithm, we only need to focus on what threshold values $(\alpha_{1},\dots,\alpha_{n})$ will make the algorithm allocate all chores.

Main result

In this section, we show that an $\frac{11}{9}$-approximation maximin share allocation always exists by our algorithmic framework. To achieve this goal, it is sufficient to consider IDO instances solely (see Lemma 1). For simplicity, we only deal with IDO instances for all proofs in this section.

For any chore division instance $\mathcal{I}$, there always exists an $\frac{11}{9}$-MMS allocation.

By Lemma 2, it is sufficient to prove that on inputting threshold value $\alpha_{i}=\frac{11}{9}\cdot\mbox{MMS}_{i}$ to Algorithm 1, all chores will be allocated. To prove that, we focus on the agent who gets the last bundle in the execution of Algorithm 1 (the agent was chosen in line 1 of Algorithm 1, when $k=n$ in the loop of line 1). Let $\omega$ be a special index for this agent. The whole proof will take the view from agent $\omega$’s perspective. If we can prove that all remaining chores will be allocated to agent $\omega$, then the correctness of theorem is implied. For the simplicity of the presentation, we assume that $\mbox{MMS}_{\omega}=1$.

Our proof has two parts: First we prove that all “small” chores will be allocated, and then in the second part we analyze what happened to “large” chores.

Here we give a formal definition of “small” and “large”. Notice that these notions will also be used in other sections.

With a parameter $\alpha$ and an index $i\in\mathcal{N}$, we define the set of “large” chores as

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

If we input threshold value $\alpha_{i}=\frac{11}{9}\cdot\mbox{MMS}_{i}$ to Algorithm 1, then all chores in the set $\mathcal{S}\left(\omega,2/9\right)$ will be allocated after the algorithm terminates.

We will prove the statement by contradiction. Suppose that there was a chore $c\in\mathcal{S}\left(\omega,2/9\right)$ remained. For any bundle $A_{i}$, we have the inequality $v_{\omega}\left(A_{i}\cup c\right)>11/9$, otherwise Algorithm 1 would allocate the chore $c$ to the bundle $A_{i}$. As the valuation $v_{\omega}\left(c\right)\leq 2/9$, we get the inequality $v_{\omega}\left(A_{i}\right)>1$ for all $i\in\mathcal{N}$. Recall that the value $\mbox{MMS}_{\omega}$ is 1 by our assumption. So the total valuation should not exceed $n$. When we add up the valuations of all bundles, we have $\sum_{i\in\mathcal{N}}v_{\omega}\left(A_{i}\right)>n$, which is a contradiction. Therefore, there is no chore $c\in\mathcal{S}\left(\omega,2/9\right)$ remained. ∎

Next we will analyze the allocation of large chores. Notice that the algorithm always gives the priority of large chores over small chores. In other words, no matter what kind of small chores we have and how they are allocated, they do not influence the allocation of large chores. Thus, we can focus on large chores without considering any small chores.

Before presenting the details of the proof, here we give a high level idea of the proof. Suppose that $\mathbf{A}$ is the allocation returned by Algorithm 1 and $\mathcal{B}$ is a maximin share allocation for agent $\omega$. We try to imagine that the allocation $\mathbf{A}$ is generated round by round from the allocation $\mathcal{B}$. In each round $k$, we swap some chores so that bundle $B_{k}$ equals bundle $A_{k}$, and then we will not touch this bundle anymore. Our goal is to prove that during the swapping process no bundle becomes too large. Then, when we come to the last bundle, agent $\omega$ could take all remaining chores. To achieve this goal, we choose proper parameters and carefully specify the swap operation so that only two types of swaps are possible.

Suppose that in round $k$, we swap chores between bundle $B_{k}$ and bundle $B_{j}$ where $j>k$. The target of the swapping is to make bundle $B_{k}$ close to bundle $A_{k}$, and meanwhile bundle $B_{j}$ will not increase too much. See Figure 1.

Type 1: We will swap chore $c_{j}\in B_{j}$ with chore $c_{k}\in B_{k}$ such that $v_{\omega}\left(c_{j}\right)\geq v_{\omega}\left(c_{k}\right)$ (possibly $c_{k}=\emptyset$). After this swapping, the valuation of the bundle $B_{j}$ would not increase.

Type 2: We will swap chore $c_{j}\in B_{j}$ with two chores $c_{k_{1}},c_{k_{2}}\in B_{k}$. We have that $v_{\omega}\left(c_{k_{1}}\right)\leq v_{\omega}\left(c_{j}\right)$ and $v_{\omega}\left(c_{k_{2}}\right)\leq v_{\omega}\left(c_{j}\right)$. However, it is possible that $v_{\omega}\left(\{c_{k_{1}},c_{k_{2}}\}\right)>v_{\omega}\left(c_{j}\right)$. This swap could make the bundle $B_{j}$ larger. By a delicate choice of the parameter, this kind of increment can be well upper bounded and would not accumulate, i.e., there is at most one Type 2 swap involving bundle $B_{j}$ for any $j$.

If we input threshold value $\alpha_{i}=\frac{11}{9}\cdot\mbox{MMS}_{i}$ to Algorithm 1, then after the algorithm terminates, all chores of the set $\mathcal{L}\left(\omega,2/9\right)$ will be allocated.

Suppose that $\mathbf{A}$ is the allocation returned by the algorithm and $\mathcal{B}$ is a maximin share allocation for the last agent $\omega$. We try to swap chores in maximin share allocation $\mathcal{B}$ so that it will become the allocation $\mathbf{A}$. The proof is to analyze what happened in this swapping process.

Recall that the value $\mbox{MMS}_{\omega}$ is 1 by our assumption. We only care about large chores here. So let us define the bundle $A_{i}^{*}$ as $A_{i}\cap\mathcal{L}\left(\omega,2/9\right)$ and the bundle $B_{i}^{*}$ as $B_{i}\cap\mathcal{L}\left(\omega,2/9\right)$. For the simplicity of the proof, we assume that all bundles are ordered by the largest chore in each bundle, i.e., $A_{i}^{*}\geq A_{j}^{*}$ for all $i<j$. Notice that for the allocation $\mathbf{A}$, this order is exactly the order from the for-loop in line 1 of Algorithm 1.

We start with bundle collection $\mathcal{B}^{(0)}=\left(B_{1}^{*},\dots,B_{n}^{*}\right)$ for our swapping process. Bundle collection $\mathcal{B}^{(0)}$ is an allocation of large chores such that $v_{\omega}\left(B_{i}^{*}\right)\leq 1$ for all $i\in\mathcal{N}$. There are $n$ rounds of the swapping process in total. In each round $t$, we generate a bundle collection $\mathcal{B}^{(t)}$ by swapping some chores in bundle collection $\mathcal{B}^{(t-1)}$, so that bundle $B_{t}^{(t)}=A_{t}^{*}$. Notice that we do not need to touch bundles with index strictly less than $t$ to fix bundle $B_{t}^{(t)}$. So we have $B_{i}^{(t)}=A_{i}^{*}$ for all $i\leq t$.

If this swapping process could be successful to the round $n$, then all large chores are allocated in allocation $\mathbf{A}$, which implies the lemma. To show this, we carefully specifiy the swapping process so that bundle collection $\mathcal{B}^{(t)}$ satisfies a good property.

To introduce the good property, we need some definitions. Let

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

Good bundle: A bundle $B$ is good if 1) $v_{\omega}\left(B\right)\leq 1$ or, 2) $U(B)<5/9\text{ and }|B|=4.$

The second condition of the good bundle definition is related to the Type 2 swap which is mentioned in the high level idea. This condition can help us bound and control the damage which is caused by the second type swap.

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

Good bundle collection: A bundle collection $\mathcal{B}^{(t)}$ is good if $B_{i}^{(t)}=A_{i}^{*}$ for all $i\leq t$, and each bundle $B_{i}^{(t)}$ is good for $i>t$.

Clearly, the bundle collection $\mathcal{B}^{(0)}$ is good. This would be the basis for our induction. Now we need to describe the swapping process. To do it precisely, we introduce two operations $SWAP$ and $MOVE$, where the operation $SWAP$ would swap two chores and the operation $MOVE$ would move a set of chores from their original bundles to a target bundle.

Given a bundle collection $\mathcal{B}$ and two chores $c_{1}$ and $c_{2}$, the $SWAP$ operation will generate a new bundle collection $\mathcal{B}^{\#}=SWAP(\mathcal{B},c_{1},c_{2})$ such that: If $c_{1}=c_{2}$ or, $c_{1}$ and $c_{2}$ are in the same bundle, then $\mathcal{B}^{\#}=\mathcal{B}$; otherwise, we swap these two chores.

Given a bundle collection $\mathcal{B}$, an index $j\in\mathcal{N}$ and a subset of chores $T\subseteq\mathcal{M}$, the $MOVE$ operation will generate a new bundle collection $\mathcal{B}^{\#}=MOVE(\mathcal{B},j,T)$ such that

Notice that chores set $T$ could contain chores from different bundles.

Now we describe and prove the correctness of the swapping process by induction. Suppose that bundle collection $\mathcal{B}^{(k)}$ is good. We will swap and move some chores between bundle $B_{k+1}^{(k)}$ and bundles with index greater than $k+1$, so that the bundle $B_{k+1}^{(k)}$ becomes bundle $A_{k+1}^{*}$. Without loss of generality, we can assume that the largest chore in bundle $B_{k+1}^{(k)}$ and bundle $A_{k+1}^{*}$ are the same, i.e., chore $B_{k+1}^{(k)}=A_{k+1}^{*}$. This is the largest chore among the set $\bigcup_{i\geq k+1}B_{i}^{(k)}$ by our assumption of the order of allocation $\mathbf{A}$ (The assumption made at the beginning of the whole proof). By the condition of good bundle collection and the value of large chores, we know that bundle $B_{k+1}^{(k)}$ contains at most $4$ chores.

Before the case analysis, here we give a claim which can help us combine several cases into one.

For the cases $\left\lvert B_{k+1}^{(k)}\right\rvert=\mbox{1, 2, and }4$, we have the inequalities $\left\lvert A_{k+1}^{*}\right\rvert\geq\left\lvert B_{k+1}^{(k)}\right\rvert$ and $v_{\omega}\left(B_{k+1}^{(k)}[j]\right)\leq v_{\omega}\left(A_{k+1}^{*}[j]\right)$ for $j\leq\left\lvert B_{k+1}^{(k)}\right\rvert$.

Please read Appendix B for the proof of Claim 1.

Based on the size of bundle $B_{k+1}^{(k)}$, we have the following case analysis.

$\left\lvert B_{k+1}^{(k)}\right\rvert=1,2,\mbox{ and }4$: Let $d=\left\lvert B_{k+1}^{(k)}\right\rvert$ be the cardinality of the bundle. By Claim 1, we have $\left\lvert A_{k+1}^{*}\right\rvert\geq\left\lvert B_{k+1}^{(k)}\right\rvert$ and $v_{\omega}\left(B_{k+1}^{(k)}[j]\right)\leq v_{\omega}\left(A_{k+1}^{*}[j]\right)$ for all $j\leq d$. We swap each pair of chores $B_{k+1}^{(k)}[j]$ and $A_{k+1}^{*}[j]$ for $j\leq d$. Here all swaps are Type 1 (described in high level idea) swap. If the cardinality $\left\lvert A_{k+1}^{*}\right\rvert>d$, then we just move the remaining chores to bundle $B_{k+1}^{(k)}$. Please see Figure 2 for this process.

Mathematically, let bundle collection $G^{(1)}=\mathcal{B}^{(k)}$. The swapping of the first $d$ chores could be represented as the following form $G^{(j)}=SWAP\left(G^{(j-1)},B_{k+1}^{(k)}[j],A_{k+1}^{*}[j]\right)$ for $2\leq j\leq d$. The bundle collection $G^{(d)}$ is the resulting bundle after these swaps. And the moving operation to generate bundle collection $\mathcal{B}^{(k+1)}$ is equivalent to

It is not hard to see after all these operations, no bundle with index larger than $k+1$ becomes larger nor gets more chores. A good bundle will still be a good bundle. Therefore, when we get the bundle collection $\mathcal{B}^{(k+1)}$, it is a good bundle collection.

$\left\lvert B_{k+1}^{(k)}\right\rvert=3$: As chore $B_{k+1}^{(k)}$ equals chore $A_{k+1}^{*}$ and $v_{\omega}\left(\left\{B_{k+1}^{(k)},B_{k+1}^{(k)}\right\}\right)<11/9,$ we can at least allocate chore $B_{k+1}^{(k)}$ with chore $A_{k+1}^{*}$ in the algorithm. Thus, we have $\left\lvert A_{k+1}^{*}\right\rvert\geq 2$. Let

be the bundle collection that swap chore $B_{k+1}^{(k)}$ and chore $A_{k+1}^{*}$. Now we consider the following inequality:

If the Inequality 1 holds, then we have $\left\lvert A_{k+1}^{*}\right\rvert\geq 3$ and $v_{\omega}\left(B_{k+1}^{(k)}\right)\leq v_{\omega}\left(A_{k+1}^{*}\right)$. For this case, we will swap chore $B_{k+1}^{(k)}$ and chore $A_{k+1}^{*}$ and move remaining chores in bundle $A_{k+1}^{*}$ to bundle $B_{k+1}^{(k)}$, i.e.,

The operations for this subcase are exactly the same situation as above (see Figure 2). By a similar argument, bundle collection $\mathcal{B}^{(k+1)}$ is good.

If the Inequality 1 does not hold, then we move chore $B_{k+1}^{(k)}$ to the bundle where chore $A_{k+1}^{*}$ comes from. And then move other chores in bundle $A_{k+1}^{*}$ to bundle $B_{k+1}^{(k)}$. Please see Figure 3 for this process.

Let $j$ be an index of a bundle such that $A_{k+1}^{*}\in B_{j}^{(k)}$. Then, formally this process is

This is the most complicated case since bundle $B_{j}^{(k+1)}$ contains more items than bundle $B_{j}^{(k)}$. We prove that bundle $B_{j}^{(k+1)}$ is good in Claim 2. And for other bundles with index larger than $k+1$, it either does not change or removes some chores. Therefore, bundle collection $\mathcal{B}^{(k+1)}$ is good.

Let $j$ be the index such that the chore $A_{k+1}^{*}\in B_{j}^{(k)}$. For the case $\left\lvert B_{k+1}^{(k)}\right\rvert=3$ and Inequality 1 does not hold, after all $SWAP$ and $MOVE$ operations, bundle $B_{j}^{(k+1)}$ is good.

Please read Appendix B for the proof of Claim 2.

By this case analysis, we show that the bundle collection will keep the good property until the last one $\mathcal{B}^{(n)}$. So we prove the lemma.

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

Combing Lemma 3 and Lemma 4, we have that Algorithm 1 will output a $11/9$-MMS allocation with input such that $\alpha_{i}=\frac{11}{9}\cdot\mbox{MMS}_{i}$. ∎

We can easily transfer the existence result of Theorem 1 to a polynomial approximation scheme. The only computational hardness part of our algorithmic framework is the valuation of maximin share for each agent. Notice that computing maximin share of an agent is exactly the makespan of a job scheduling problem, which is a famous NP-hard problem. This can be solved by a PTAS from job scheduling literature . Therefore, from the result of existing 11/9 approximation maximin share allocation, we have a PTAS for $11/9+\epsilon$ approximation maximin share allocation. The constant 11/9 could be improved if anyone can prove a better existence ratio of our algorithmic framework.

Given the 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. {exmp} 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 maximin share allocation.

A maximin share allocation of this instance is that

where the numbers are valuations of each chore. Obviously, the maximin share of each agent is 1.

For any $\alpha$ such that $1\leq\alpha<20/17$, if we input threshold values $(\alpha,\alpha,\alpha,\alpha)$ to Algorithm 1, then we will get the first bundle $A_{1}^{*}=\{\frac{9}{17},\frac{7}{17}\}$, the second bundle $A_{2}^{*}=\{\frac{6}{17},\frac{5}{17},\frac{5}{17}\}$ and the third bundle $A_{3}^{*}=\{\frac{4}{17},\frac{4}{17},\frac{4}{17},\frac{4}{17}\}$. When we come to the last bundle, the total valuation of remaining chores is $\frac{20}{17}$. Since the threshold $\alpha<20/17$, we cannot allocate all chores.

Algorithm 1 cannot guarantee to find an $\alpha$-MMS allocation when $\alpha<20/17$.

An efficient algorithm for practice

To run our algorithm for $\frac{11}{9}$-approximation maximin share allocation, we need to know the maximin share of each agent. The computation of the maximin share is NP-hard. Though we have a PTAS for $\left(\frac{11}{9}+\epsilon\right)$-approximation, even if we want to get a $\frac{5}{4}$-approximation with currently best PTAS for job scheduling , the running time could be more than $2^{39000}+poly(n,m)$. This is not acceptable for a real computation task. To attack this computational embarrassment, we give a trial on designing an efficient polynomial time algorithm for $\frac{5}{4}$-approximation maximin share allocation when valuations are all integers.

The design of the efficient algorithm relies on an observation: It is not necessary to know the exact value of maximin share. A reasonable lower bound of maximin share could serve the same end. This kind of observation was successfully applied to the goods setting .

From this observation, the basic idea of the design is to find a good lower bound of maximin share. And from the lower bound, we compute a proper threshold value for executing Algorithm 1. To make this idea work, we have two problems to solve: 1) How to find a proper lower bound of maximin share? 2) How to use this lower bound to get a good threshold value for the algorithm?

We find that a threshold testing algorithm could be an answer to these problems. The threshold testing algorithm tries to allocate relative large chores in a certain way to see whether the threshold is large enough for an agent or not. For the first problem, we can use the threshold testing algorithm as an oracle to do binary search for finding a reasonable lower bound of maximin share of each agent. For the second problem, the allocation generated by the threshold testing algorithm could serve as a benchmark to help us find a good threshold value.

To explain some key points of the threshold testing, we introduce a simple trial – naive test which is building on Algorithm 1 straightforwardly. The naive test gives a polynomial-time $\frac{11}{9}$-approximation algorithm for the job scheduling problem (see Section 6). However, we construct a counter example which is an IDO instance for the naive test in this section.

Basically, the naive test tries to run Algorithm 1 directly on a single agent. Suppose that we have an instance $\mathcal{I}=\langle\mathcal{N},\mathcal{M},\mathcal{V}\rangle$. Let $\mathsf{NT}\left(i,s_{i}\right)$ denote a naive test, where $i$ is an agent and $s_{i}$ is a threshold. The naive test $\mathsf{NT}\left(i,s_{i}\right)$ will first construct an instance $ID=\langle\mathcal{N},\mathcal{M},\mathcal{V}^{\prime}\rangle$ such that $\mathcal{V}^{\prime}=(v_{i},\dots,v_{i})$, i.e., valuations are all same as $v_{i}$. Then it will run Algorithm 1 with the $ID$ instance and threshold values $\left(s_{i},\dots,s_{i}\right)$. If all chores are allocated in Algorithm 1, then the naive test $\mathsf{NT}\left(i,s_{i}\right)$ returns “Yes”, otherwise returns “No”.

Given an agent $i$, let $s^{*}_{i}=\min_{s_{i}}\left\{s_{i}\mid\mathsf{NT}\left(i,s_{i}\right)\text{returns ``Yes"}\right\}$ be the minimal value passing the naive test. By the proof of Theorem 1, it is not hard to see that the value $s^{*}_{i}$ satisfies $s^{*}_{i}\leq\frac{11}{9}\cdot\mbox{MMS}_{i}$. Based on this observation, it is natural to try the following.

Trial approach: First, compute the minimal threshold $s^{*}_{i}$ for each agent. How to compute the value of $s^{*}_{i}$ is not important for our discussion on the properties of threshold testing. Then run Algorithm 1 with thresholds $\{s^{*}_{i}\}_{i\in\mathcal{N}}$ to get an allocation.

If the following conjecture is true, then this approach would work.

Montonicity: If Algorithm 1 can allocate all chores with threshold values $\{\alpha_{i}\}_{i\in\mathcal{N}}$, then Algorithm 1 should allocate all chores with any threshold values $\{\beta_{i}\}_{i\in\mathcal{N}}$ such that $\beta_{i}\geq\alpha_{i}$ for all $i$. For the naive test, this conjecture implies that if the test $\mathsf{NT}\left(i,s_{i}\right)$ returns “Yes”, then the test $\mathsf{NT}\left(i,s^{\prime}_{i}\right)$ returns “Yes” for any $s^{\prime}_{i}\geq s_{i}$. Unfortunately, Conjecture 5.1 is not true even for the naive test (all agents have the same valuation). Here we give a counter example. {exmp}

In this example, we consider an instance of 17 chores and 4 agents. All agents have the same valuation. The valuation of each chore is demonstrated by the maximin share allocation.

The maximin share allocation of this instance is that

The numbers are valuations of each chore. The maximin share and value $s^{*}_{i}$ of each agent is 7.5. It is easy to verity that all chores will be allocated if we input the threshold values $(7.5,7.5,7.5,7.5)$ to Algorithm 1. And the allocation is exactly the allocation we give here.

However, if we input threshold values $(7.6,7.6,7.6,7.6)$ to Algorithm 1, we will have

So for this example, naive test $\mathsf{NT}\left(i,7.5\right)$ will return “Yes”, but $\mathsf{NT}\left(i,7.6\right)$ will return “No”. This example reveals a surprising fact about Algorithm 1. When we have more spaces to allocate chores, it could be harmful. The connection between Conjecture 5.1 and the trial approach is that: In terms of the last agent’s perspective, when we do the trial approach, the effect of heterogeneous valuations would act as enlarging threshold. Next we construct an example based on Example 5.1 to show how the trial approach failed.

We construct an IDO instance consists of 4 agents and 17 chores. For those 4 agents, three of them (agents $t_{1}$, $t_{2}$ and $t_{3}$) have exact the same valuation as Example 5.1. Agent $t_{4}$ is a special agent. The valuation of agent $t_{4}$ is demonstrated by the maximin share allocation:

By our construction, it is easy to verify that the value $s^{*}_{i}$ equals 7.5 for any agent $i$. The trial approach will input the threshold (7.5,7.5,7.5,7.5) to Algorithm 1.

Notice, this is an IDO instance. For agents $t_{1}$, $t_{2}$ and $t_{3}$, the largest 4 chores are valued at $\{5.1,2.75,2.75,2.5\}$. For agent $t_{4}$, the largest 4 chores are valued at $\{5.1,2.75,2.75,2.4\}$. When we do the trial approach, agent $t_{4}$ will get the first bundle, which is $A=\{5.1,2.4\}$ for agent $t_{4}$. And this bundle contains chores $\{5.1,2.5\}$ in terms of the valuation of other agents. Just like Example 5.1, there will be 2 chores unallocated at the end. So the trial approach fails.

2 Threshold testing

Before we present the threshold testing algorithm, let us summarize the issue of the naive test by Figure 4. The naive test will return a threshold value $\alpha$ (a red value in Fig 4 between $\mbox{MMS}_{i}$ and $\frac{11}{9}\mbox{MMS}_{i}$). When we run Algorithm 1, the effect of other agents can be viewed as increasing the threshold $\alpha$. Let us call the threshold after increasing effective threshold. If the effective threshold is a blue value, then Algorithm 1 could be failed. To resolve this situation, we need to find a threshold $\alpha^{\prime}$ such that every value larger than $\alpha^{\prime}$ will pass the test.

From this idea, we try to find a value $s_{i}$, which is a lower bound on $\mbox{MMS}_{i}$. Then scale it large enough ($\frac{5}{4}\cdot s_{i}$) so that no larger value will fail the test. This can be done by allocating chores with valuation larger than $s_{i}/4$ in a special way.

Here is a detailed description of our threshold testing algorithm.

To get a lower bound of maximin share by a binary search, we need monotonicity of the algorithm, i.e., threshold testing should return “Yes” on all values larger than $\mbox{MMS}_{i}$ for any agent $i$. Though Example 5.1 shows monotonicity does not hold in general, we prove that by the choice of parameters, the following monotonicity holds.

For any $\alpha_{i}\geq\frac{11}{9}\cdot\mbox{MMS}_{i}$, if we input the threshold $\alpha_{i}$ to Algorithm 1, then all chores will be allocated.

Notice that, if we replace the condition of $\alpha_{i}$ from $\alpha_{i}=\frac{11}{9}\cdot\mbox{MMS}_{i}$ to $\alpha_{i}\geq\frac{11}{9}\cdot\mbox{MMS}_{i}$ in Lemma 3 and Lemma 4, the proof of those two lemmas work in the same way. This observation would directly implies this lemma. ∎

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

If we input an index $i$ and a threshold $s_{i}\geq\mbox{MMS}_{i}$ to Algorithm 2, then the algorithm will return “Yes”. Therefore, when we use Algorithm 2 to do binary search, we will correctly get a lower bound of maximin share.

As Algorithm 2 deal with the chores in set $\mathcal{L}\left(i,s_{i}/4\right)$ only, let us assume that the chores set $\mathcal{M}=\mathcal{L}\left(i,s_{i}/4\right)$ in this proof.

When the inequality $s_{i}\geq\mbox{MMS}_{i}$ holds, there is an allocation $\mathbf{A}^{*}$ such that $v_{i}\left(A_{j}^{*}\right)\leq s_{i}$ for all $j$. We will compare the allocation $\mathbf{A}^{*}$ with the allocation generated in Algorithm 2 to show that the remaining chores after line 2 do not greater than the chores in the allocation $\mathbf{A}^{*}$.Then we can allocate them in a way like Algorithm 1. So the threshold $s_{i}$ will pass the test.

We introduce some notations for the proof. Let $H$ denote the set of chores which are allocated before line 2. Let $Q$ be the set of chores of bundles containing a really large chore from allocation $\mathbf{A}^{*}$, i.e.,

Let $\mathbf{A}$ be the allocation generated in Algorithm 2 when we input agent $i$ and value $s_{i}$. Suppose that for allocation $\mathbf{A}$, the indices of the bundles are the same as in Algorithm 2. Let $k=\left\lvert\mathcal{L}\left(i,s_{i}/2\right)\right\rvert$ be the number of really large chores. Notice that no two chores in the set $\mathcal{L}\left(i,s_{i}/2\right)$ will be allocated to one bundle i.e., all these chores are allocated separately. So we have $H=\bigcup_{j\leq k}A_{j}$. Without loss of generality, we can assume that the $j$-th largest chore $\mathcal{M}[j]\subseteq A_{j}^{*}$ for all $j\leq k$. Then we have $Q=\bigcup_{j\leq k}A_{j}^{*}$.

Since the set of chores $\mathcal{L}\left(i,s_{i}/2\right)$ is contained in both set $H$ and set $Q$, we can simply let function $f(c)=c$ for any chore $c\in\mathcal{L}\left(i,s_{i}/2\right)$. Let us consider the set of chores $Q^{\prime}=Q\setminus\mathcal{L}\left(i,s_{i}/2\right)$.

Index: If chore $c\in A_{j}^{*}$, we call $j$ the index of chore $c\in Q^{\prime}$.

Recall that we have assumed that the set of all chores $\mathcal{M}=\mathcal{L}\left(i,s_{i}/4\right)$. So there are no two chores in $Q^{\prime}$ sharing one index.

Without breaking the condition $v_{i}\left(A_{j}^{*}\right)\leq s_{i}$ for all $j\leq k$, we can assume that:

For any two chores $c_{1},c_{2}\in Q^{\prime}$, if $v_{i}\left(c_{1}\right)>v_{i}\left(c_{2}\right)$, then the index of chore $c_{1}$ greater than the index of chore $c_{2}$.

Indexes of chores in set $Q^{\prime}$ are consecutive and end at the index $k$, i.e., the set of indexes equals the set $[j,k]$ (here $[j,k]$ is the set of all integers between $j$ and $k$).

Recall that the chore $\mathcal{M}[j]\in A_{j}^{*}$ for each $j\leq k$. It means that when index becomes larger, there is more space to allocate a chore in $Q^{\prime}$ without exceeding the threshold $s_{i}$. So we have the following observation. If condition 1) breaks, we can swap two chores without violating maximin share condition. If condition 2) breaks, then there is an index $j$ for a chore $c\in Q^{\prime}$ and an index $d$ such that $d>j$ and there is no chore corresponding to index $d$. In this case, we can reallocate chore $c$ to bundle $A_{d}^{*}$ and it is still a maximin share allocation. These two observations imply we can make above two assumptions. ∎

Suppose that the assumptions in Claim 3 hold, we prove the following claim.

There is an injection $f:Q\rightarrow H$ such that $v_{i}\left(c\right)\leq v_{i}\left(f(c)\right)$ for any chore $c\in Q$ .

Since the set of chores $\mathcal{L}\left(i,s_{i}/2\right)$ is contained in both set $H$ and set $Q$, we can simply let function $f(c)=c$ for any chore $c\in\mathcal{L}\left(i,s_{i}/2\right)$. Now we consider the chores $Q^{\prime}=Q\setminus\mathcal{L}\left(i,s_{i}/2\right)$.

Similarly, let $H^{\prime}=H\setminus\mathcal{L}\left(i,s_{i}/2\right)$ and call $j$ to be the index of chore $c\in H^{\prime}$. Notice that, by Algorithm 2, the allocation $\mathbf{A}$ and set $H^{\prime}$ satisfy these two conditions as well. For any chore $c\in Q^{\prime}$, let $f(c)=c^{\prime}$ where chore $c$ and chore $c^{\prime}\in H^{\prime}$ have a same index.

Now we prove that $v_{i}\left(c\right)\leq v_{i}\left(f(c)\right)$. Let $j$ be the index for chore $c$. When Algorithm 2 allocates chore $f(c)$ to bundle $A_{j}$, it will choose the largest possible chore $c^{\prime}$ such that $v_{i}\left(\mathcal{M}[j]\cup c^{\prime}\right)\leq s_{i}$. Deduce from our assumption for the index of chore $c$, we know that chore $c$ has not been allocated when Algorithm 2 deal with bundle $A_{j}$. Thus, we have $v_{i}\left(c\right)\leq v_{i}\left(f(c)\right)$. ∎

Next we analysis the remaining chores from sets $\mathcal{M}\setminus H$ and $\mathcal{M}\setminus Q$.

There is an injective function $g:\mathcal{M}\setminus H\rightarrow\mathcal{M}\setminus Q$ such that $v_{i}\left(c\right)\leq v_{i}\left(g(c)\right)$ for any chore $c\in\mathcal{M}\setminus H$.

By Claim 4, suppose that $f:Q\rightarrow H$ is an injective function such that $v_{i}\left(c\right)\leq v_{i}\left(f(c)\right)$ for any chore $c\in Q$. Let $f^{0}:\mathcal{M}\rightarrow\mathcal{M}$ be an identity function. For any integer $k>0$, let $f^{k}(c)=f(f^{k-1}(c))$ if $f^{k-1}(c)\in Q$. We construct $g$ such that

First, we prove that for any $c\in\mathcal{M}\setminus H$, the mapping $g(c)$ is well-defined. For any chore $c\in\mathcal{M}\setminus(Q\cup H)$, we have $f^{0}(c)=c\in\mathcal{M}\setminus Q$. So for those chores, we have $g(c)=c$. For any chore $c\in Q\setminus H$, we prove that there must exist a $k$ such that $f^{k}(c)\in\mathcal{M}\setminus Q$. Suppose that there is no such $k$. There must exist two integers $k_{1}<k_{2}$ such that $f^{k_{1}}(c)=f^{k_{2}}(c)$. Since function $f$ is injective, we have that

Because we have assumed that $c\in\mathcal{M}\setminus H$, it is a contradiction. Therefore, function $g$ is well-defined.

Second, we prove that the function $g$ is injective. Suppose that there are two chores $c_{1},c_{2}\in\mathcal{M}\setminus H$ such that $g(c_{1})=g(c_{2})$. Then there exist two integers $k_{1},k_{2}$ such that $g(c_{1})=f^{k_{1}}(c_{1})=f^{k_{2}}(c_{2})=g(c_{2})$. Recall that $f$ is injective. If $k_{1}=k_{2}$, then $c_{1}=c_{2}$. It is impossible. Let us assume that $k_{1}<k_{2}$. Then, we have $c_{1}=f^{0}(c_{1})=f^{k_{2}-k_{1}}(c_{2})\in H$. It is a contradiction to the range of chore $c_{1}$. Thus, function $g$ is injective.

As $v_{i}\left(c\right)\leq v_{i}\left(f(c)\right)$ for any chore $c$, we have $v_{i}\left(c\right)\leq v_{i}\left(f^{w_{i}}(c)\right)=v_{i}\left(g(c)\right)$. ∎

The set $\mathcal{M}\setminus Q$ is exactly the set $\bigcup_{j>k}A_{j}^{*}$. By Claim 5, we are able to allocate set $\mathcal{M}\setminus H$ into $n-k$ bundles such that no bundle with valuation more than $s_{i}$. Then by Lemma 5, Algorithm 2 will allocate all remaining chores by the threshold $s_{i}$. So Algorithm 2 will return “Yes” on the threshold $s_{i}$.

3 Efficient approximation algorithm

Now we present the following approximation algorithm for $5/4$-MMS allocation.

Remark: The value $r_{i}=2l_{i}$ from line 3 is an upper bound of $\mbox{MMS}_{i}$. This can be deduced from the 2 approximation algorithm of the job scheduling problem .

To analyze the correctness of Algorithm 3, we focus on the agent who gets the last bundle, which is denoted by $\omega$. First we argue that no small chores left unallocated.

If the threshold $s_{\omega}\geq v_{\omega}\left(\mathcal{M}\right)/n$, then after Algorithm 3 terminates, all chores $c\in\mathcal{S}\left(\omega,s_{\omega}/4\right)$ will be allocated.

By the same argument as Lemma 3, if there is a chore $c\in\mathcal{S}\left(\omega,s_{\omega}/4\right)$ left, then every bundle is greater than $s_{\omega}$. In the algorithm, we have set a lower bound $s_{\omega}\geq v_{\omega}\left(\mathcal{M}\right)/n$ for the binary search. If the value of every bundle is greater than $s_{\omega}$, the sum of valuations of all bundles will grater than $v_{\omega}\left(\mathcal{M}\right)$. This is impossible. Thus we prove the lemma. ∎

Next we analyze what happened to the large chores in the allocation. The idea of the proof is similar to what we have done for Lemma 4. The key difference is that the benchmark allocation is the one generated by the threshold testing, but not a maximin share allocation like Lemma 4. We compare the output of Algorithm 3 with the benchmark allocation to argue that all chores will be allocated.

After Algorithm 3 terminates, all chores $c\in\mathcal{L}\left(\omega,s_{\omega}/4\right)$ will be allocated.

Please see Appendix C for the full proof. Here we give a high level idea of the proof. After binary search, we have a threshold value $s_{\omega}$ for the last agent $\omega$, which is a lower bound of $\mbox{MMS}_{\omega}$. Let $\mathcal{B}$ be the allocation that the threshold testing algorithm generated inside itself upon inputting agent $\omega$ and value $s_{\omega}$. Let $\mathbf{A}$ be the allocation returned by Algorithm 3. We will try to compare allocation $\mathbf{A}$ and allocation $\mathcal{B}$ from agent $\omega$’s perspective.

When comparing these two allocations, we observe that, for any $k$, the set of the first $k$ bundles of allocation $\mathbf{A}$ ($\bigcup_{i\leq k}A_{i}$) always contains larger and more chores than allocation $\mathcal{B}$ ($\bigcup_{i\leq k}B_{i}$). Particularly, we prove by induction that we can maintain an injective mapping from chore set $\bigcup_{k<i\leq n}B_{i}$ to set $\bigcup_{k<i\leq n}A_{i}$ such that each chore $c$ is mapped to a chore with valuation no less than $c$. ∎

With all these lemmas, now we can prove the following theorem.

For integer valuations, Algorithm 3 will output a 5/4 approximation maximin share allocation in $O(nm\log m+n^{2})$ time.

The correctness of Algorithm 3 is directly implied by Lemma 7 and Lemma 8. We only need to analyze the time complexity of our algorithm. The running time of the threshold testing is about $O(m\log m+n)$. As valuations are all integers, the number of iterations of binary search depends on the length of the representation of each integer (usually it can be considered a constant). And we repeat the binary search $n$ times for each agent respectively. Finally, Algorithm 1 terminates in time $O(nm\log m)$. Combining all these, the total running time of our algorithm is $O(nm\log m+n^{2})$. ∎

Application to the job scheduling problem

The job scheduling problem is one of the fundamental discrete optimization problems. Here we particularly consider the model that minimizes the execution time for scheduling $m$ jobs on $n$ identical machines. It could be viewed as a special case of chore allocation, where all agents have the same valuation. From this perspective, we show how to apply our algorithmic framework to this problem.

The problem of job scheduling is proved to be NP-hard in . And later, the polynomial time approximation scheme (PTAS) for this problem was discovered and developed . To the best of our knowledge, except those PTASs, there is no algorithm approximating optimal better than 4/3. From our algorithmic framework, we demonstrate an algorithm, which is simpler and more efficient than the best PTAS, and achieves a better approximation ratio than other heuristics.

When all valuations are integers, an 11/9 approximation of optimal scheduling can be found in $O(m\log m+n)$ time.

We first describe the algorithm for this problem. The algorithm is similar to Algorithm 3, except for two modifications:

Change the threshold testing algorithm in binary search from Algorithm 2 to the naive test which is introduced in section 5.1.

Delete the for-loop, and compute one proper threshold from the valuation function.

As all agents share the same valuation function, the threshold obtained by the naive test obviously can apply to all agents. Then we can get an allocation such that no bundle exceeds the threshold. And by Lemma 5 , the threshold from binary search is not greater than $\frac{11}{9}\cdot\mbox{MMS}$.

The time complexity of one testing is $O(m\log m+n)$. The number of iterations of binary search depends on the length of the representation of each integer (usually it can be considered a constant). Finally, Algorithm 1 will be executed one more time. Thus, the complexity of our algorithm is $O(m\log m+n)$ ∎

Discussion

At the first glance, our algorithm is quite similar to FFD algorithm for the bin packing problem. However, technically they are two different problems. 1) The bin packing problem is fixing the size of each bin and then try to minimize the number of bins. Our problem can be viewed as fixing the number of bins but try to minimize the size of each bin. 2) The optimal approximation of FFD algorithm for the bin packing problem is $\frac{11}{9}\cdot OPT+\frac{6}{9}$. To the best of our knowledge, there is no reduction between the approximation ratio of these two problems. 3) The lower bound Example 4 does not make sense to the bin packing problem, and the lower bound example of bin packing problem does not make sense to our problem.

For the analysis of our algorithmic framework, there is a gap between the lower and the upper bound of the approximation ratio. It will be interesting to close this gap. Another interesting direction is that how to convert the existence result from our algorithmic framework into an efficient algorithm. Suppose that $\alpha$ is the best approximation ratio of existence of our algorithmic framework. By combining a PTAS for job scheduling , we can have a PTAS for $\alpha+\epsilon$ approximation of maximin share allocation. Nevertheless, such PTAS can hardly to be considered as efficient in practical use. In section 5, we show one way to get a polynomial time algorithm for 5/4 approximation from our existence result. It is still possible to design an efficient algorithm for $\alpha$-approximation.

In section 6, we try to explore the power of our algorithmic framework on the job scheduling problem. It may worth to exploring more on the relationship of the algorithmic framework with other scheduling problems.

Acknowledgement

Xin Huang is supported in part at the Technion by an Aly Kaufman Fellowship. Pinyan Lu is supported by Science and Technology Innovation 2030 – “New Generation of Artificial Intelligence” Major Project No.(2018AAA0100903), NSFC grant 61922052 and 61932002, Innovation Program of Shanghai Municipal Education Commission, Program for Innovative Research Team of Shanghai University of Finance and Economics, and the Fundamental Research Funds for the Central Universities.

We thank Prof. Xiaohui Bei for helpful discussion on the subject. Thank Prof. Inbal Talgam-Cohen and Yotam Gafni for providing useful advice on writing. Part of this work was done while the author Xin Huang was visiting the Institute for Theoretical Computer Science at Shanghai University of Finance and Economics.

References

Appendix A Reduction from general to identical ordinary preference

Here we formally state a reduction technique which is introduced by Bouveret and Lemaître . 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 to simplify the proof of approximation of maximin share allocation for goods.

We first introduce a concept of ordered instance.

Given any instance $\mathcal{I}=\langle\mathcal{N},\mathcal{M},\mathcal{V}\rangle$, the corresponding ordered instance of $\mathcal{I}$ is denoted as $\mathcal{I}^{*}=\langle\mathcal{N}^{*},\mathcal{M}^{*},\mathcal{V}^{*}\rangle$, where:

$\mathcal{N}^{*}=\mathcal{N}$, and $|\mathcal{M}^{*}|=|\mathcal{M}|$

For each agent $i$ and chore $c^{*}_{j}\in\mathcal{M}^{*}$, we have $v_{i}^{*}(c^{*}_{j})=v_{i}\left(\mathcal{M}[i,j]\right)$

The whole reduction relies on the following algorithm.

We have the following observation for this algorithm.

Given an instance $\mathcal{I}$, its ordered instance $\mathcal{I}^{*}$ and an allocation $\mathbf{A}^{*}$ of $\mathcal{I}^{*}$, Algorithm 4 will output an allocation $\mathbf{A}$ such that $v_{i}\left(A_{i}\right)\leq v_{i}\left(A_{i}^{*}\right)$ for each agent $i$.

To prove this lemma, it is sufficient to prove that in line 4 of the algorithm, the chore $c$ satisfies $v_{i}\left(c\right)\leq v_{i}\left(\mathcal{M}^{*}[j]\right)$. Because if this is true, after adding up all these inequalities, we can get $v_{i}\left(A_{i}\right)\leq v_{i}\left(A_{i}^{*}\right)$.

Look at the for-loop in Algorithm 4. In the round of $j$, there are $j$ chores left in $T$, i.e., $|T|=j$. We have $v_{i}\left(c\right)=v_{i}\left(T[i,j]\right)\leq v_{i}\left(\mathcal{M}[i,j]\right)=v_{i}\left(\mathcal{M}^{*}[j]\right)$. ∎

Since the set of chores of ordered instance $\mathcal{I}^{*}$ is the same as $\mathcal{I}$, the maximin share of each agent $i$ is the same in both instances.

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

Given a chore division instance $\mathcal{I}$, we can construct its ordered instance $\mathcal{I}^{*}$ in $O(nm\log m)$ time, which is by sorting algorithm for all agents. And then we run algorithm $G$ on the instance $\mathcal{I}^{*}$ to get an $\alpha$-MMS allocation $\mathbf{A}^{*}$ for $\mathcal{I}^{*}$. Then we run Algorithm 4 on $\mathbf{A}^{*}$ to get an allocation $\mathbf{A}$ of instance $\mathcal{I}$. The Algorithm 4 can be done in $O(nm)$ time. And with lemma 9, we know that $\mathbf{A}$ is an $\alpha$-MMS allocation of instance $\mathcal{I}$. ∎

Appendix B Complementary Proofs of Lemma 4

For the case $\left\lvert B_{k+1}^{(k)}\right\rvert=1$, it is trivial. For the case $\left\lvert B_{k+1}^{(k)}\right\rvert=2$, we notice that Algorithm 1 can at least allocate chore $B_{k+1}^{(k)}$ to bundle $A_{k+1}^{*}$ as the second chore. This would imply the cardinality $\left\lvert A_{k+1}^{*}\right\rvert\geq 2$ and the valuation $v_{\omega}\left(B_{k+1}^{(k)}\right)\leq v_{\omega}\left(A_{k+1}^{*}\right)$.

For the case $\left\lvert B_{k+1}^{(k)}\right\rvert=4$, first we prove that the inequality $U\left(B_{k+1}^{(k)}\right)<5/9$ is true. Since bundle $B_{k+1}^{(k)}$ is good, we have the condition $U\left(B_{k+1}^{(k)}\right)<5/9$ or $v_{\omega}\left(B_{k+1}^{(k)}\right)\leq 1$. If the valuation $v_{\omega}\left(B_{k+1}^{(k)}\right)\leq 1$, then as any chores in the bundle is greater than 2/9, we have

Suppose that $3\cdot v_{\omega}\left(B_{k+1}^{(k)}\right)+v_{\omega}\left(B_{k+1}^{(k)}\right)>11/9$. Let $x$ be the value of $v_{\omega}\left(B_{k+1}^{(k)}\right)$. Then we have

This implies $x<2/9$. This contradicts our assumption that $c\in\mathcal{L}\left(\omega,2/9\right)$.

Notice that $v_{\omega}\left(B_{k+1}^{(k)}\right)$ 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 $B_{k+1}^{(k)}$. So the first 3 chores being allocated to bundle $A_{k+1}^{*}$ must be the largest 3 chores. So $v_{\omega}\left(B_{k+1}^{(k)}[j]\right)\leq v_{\omega}\left(A_{k+1}^{*}[j]\right)$ for $j\leq 3$.

As we have $\left\lvert B_{k+1}^{(k)}\right\rvert=4$, the chore $B_{k+1}^{(k)}$ would not be one of first 3 chores allocated to bundle $A_{k+1}^{*}$. Since there is a space for the chore $B_{k+1}^{(k)}$, the forth chore being allocated to bundle $A_{k+1}^{*}$ should at least as large as the chore $B_{k+1}^{(k)}$. Combining all these, we have $\left\lvert A_{k+1}^{*}\right\rvert\geq 4$ and $v_{\omega}\left(B_{k+1}^{(k)}[j]\right)\leq v_{\omega}\left(A_{k+1}^{*}[j]\right)$ for $j\leq 4$. ∎

The chore $A_{k+1}^{*}$ must be the largest chore in the bundle $B_{j}^{(k)}$.

Because $|B_{k+1}^{(k)}|=3$ and it is good, so $v_{\omega}\left(B_{k+1}^{(k)}\right)\leq 1$, which means $B_{k+1}^{(k)}<1-2/9-2/9=5/9$. This implies all remaining chores are less than $5/9$. Therefore, add the second largest chore, it is still less than $11/9$. We have $A_{k+1}^{*}$ must be the largest chore in the bundle $B_{j}^{(k)}$. ∎