Title: Fair Allocation of Indivisible Chores: Beyond Additive Costs
Venue: NeurIPS 2023
Accepted: yes
Keywords: fair allocation of chores

beyond additive cost functions

bin packing

job scheduling
Abstract: We study the maximin share (MMS) fair allocation of $m$ indivisible tasks to $n$ agents who have costs for completing the assigned tasks.
It is known that exact MMS fairness cannot be guaranteed, and so far the best-known approximation for additive cost functions is $\frac{13}{11}$ by Huang and Segal-Halevi [EC, 2023]; however, beyond additivity, very little is known. 
In this work, we first prove that no algorithm can ensure better than $\min\{n,\frac{\log m}{\log \log m}\}$-approximation if the cost functions are submodular. 
This result also shows a sharp contrast with the allocation of goods where constant approximations exist as shown by Barman and Krishnamurthy [TEAC, 2020] and Ghodsi et al. [AIJ, 2022]. 
We then prove that for subadditive costs, there always exists an allocation that is $\min\{n,\lceil\log m\rceil\}$-approximation, and thus the approximation ratio is asymptotically tight.
Besides multiplicative approximation, we also consider the ordinal relaxation, 1-out-of-$d$ MMS, which was recently proposed by Hosseini et al. [JAIR and AAMAS, 2022]. 
Our impossibility result implies that for any $d\ge 2$, a 1-out-of-$d$ MMS allocation may not exist.
Due to these hardness results for general subadditive costs, we turn to studying two specific subadditive costs, namely, bin packing and job scheduling. 
For both settings, we show that constant approximate allocations exist for both multiplicative and ordinal relaxations of MMS.

1

Abstract

We study the maximin share (MMS) fair allocation of m indivisible chores to n agents who have costs for completing the assigned chores. It is known that exact MMS fairness cannot be guaranteed, and so far the best-known approximation for additive cost functions is 13 11 by Huang and Segal-Halevi [EC, 2023]; however, beyond additivity, very little is known. In this work, we first prove that no algorithm can ensure better than min { n, log m log log m } -approximation if the cost functions are submodular. This result also shows a sharp contrast with the allocation of goods where constant approximations exist as shown by Barman and Krishnamurthy [TEAC, 2020] and Ghodsi et al. [AIJ, 2022]. We then prove that for subadditive costs, there always exists an allocation that is min { n, ⌈ log m ⌉} -approximation, and thus the approximation ratio is asymptotically tight. Besides multiplicative approximation, we also consider the ordinal relaxation, 1-out-ofd MMS, which was recently proposed by Hosseini et al. [JAIR and AAMAS, 2022]. Our impossibility result implies that for any d ≥ 2 , a 1-out-ofd MMS allocation may not exist. Due to these hardness results for general subadditive costs, we turn to studying two specific subadditive costs, namely, bin packing and job scheduling. For both settings, we show that constant approximate allocations exist for both multiplicative and ordinal relaxations of MMS.

1 Introduction

1.1 Background and related research

Although fair resource allocation has been widely studied in the past decade, the research is centered around additive functions [3]. However, in many real-world scenarios, the functions are more complicated. Particularly, the functions appear in machine learning and artificial intelligence (e.g, clustering [37], Sketches [18], Coresets [36], data distillation [41]) are often submodular, and we refer the readers to a recent survey that reviews some major problems within machine learning that have been touched by submodularity [12]. Therefore, in this work, we study the fair allocation problem when the agents have beyond additive cost functions. The mainly studied solution concept is maximin share (MMS) fairness [14], which is traditionally defined for the allocation of goods as a relaxation of proportionality (PROP). A PROP allocation requires that the utility of each agent is no smaller than the average utility when all items are allocated to her. PROP is too demanding in the sense that such an allocation does not exist even when there is a single item and two agents. Due to this strong impossibility result, the maximin share (MMS) of an agent is proposed to relax the average utility by the maximum utility the agent can guarantee herself if she is to partition the items into n bundles but is to receive the least favorite bundle.

For the allocation of goods, although MMS significantly weakens the fairness requirement, it was first shown by Kurokawa et al. [31, 32] that there are instances where no allocation is MMS fair for all agents. Accordingly, designing (efficient) algorithms to compute approximately MMS fair allocations steps into the center of the field of algorithmic fair allocation. Kurokawa et al. [32] first proved that there exists a 2 3 -approximate MMS fair allocation for additive utilities, and then Amanatidis et al. [1] designed a polynomial time algorithm with the same approximation guarantee. Later, Ghodsi et al. [23] improved the approximation ratio to 3 4 , and Garg and Taki [22] further improved it to 3 4 + o (1) . On the negative side, Feige et al. [20] proved that no algorithm can ensure better than 39 40 approximation. Beyond additive utilities, Barman and Krishnamurthy [6] initiated the study of approximately MMS fair allocation with submodular utilities, and proved that a 0 . 21 -approximate MMSfair allocation can be computed by the round-robin algorithm. Ghodsi et al. [24] improved the approximation ratio to 1 3 , and moreover, they gave constant and logarithmic approximation guarantees for XOS and subadditive utilities, respectively. The approximations for XOS and subadditive utilities are recently improved by Seddighin and Seddighin [40]. There are also several works that delve into concrete combinatorial problems and seek to improve approximation ratios compared to more general functions. Li et al. [33] and Hummel and Hetland [30] introduced interval scheduling and independent set structures, respectively, into MMS fair allocation problems. In both cases, the induced utility functions correspond to special cases of XoS functions. Both of these two works enhanced the approximation ratios for their specific utility functions. Some other combinatorial problems that have been studied for goods include the knapsack problem [21, 9, 8] and matroid constraints [19].

For the parallel problem of chores, where agents need to spend costs on completing the assigned chores, less effort has been devoted. Aziz et al. [4] first proved that the round-robin algorithm ensures 2-approximation for additive costs. Barman and Krishnamurthy [6], Huang and Lu [28] and Huang and Segal-Halevi [29] respectively improved the approximation ratio to 4 3 , 11 9 and 13 11 . Recently, Feige et al. [20] proved that with additive costs, no algorithm can be better than 44 43 -approximate. However, except a recent work that studies binary supermodular costs [10], very little is known beyond additivity.

Besides multiplicative approximations, we also consider the ordinal approximation of MMS, namely, 1 -out-ofd MMS fairness which is recently studied in [5, 26, 27], and proportionality up to any item (PROPX) which is an alternative way to relax proportionality [38, 34]. For indivisible chores, Hosseini et al. [26] and Li et al. [34] respectively proved the existence of 1 -out-of-⌈ 3 n 4 ⌉ MMSfair and exact PROPX allocations. All the above works also assume additive costs. More works related to this paper in the literature can be seen in Appendix A.

1.2 Main results

In this work, we aim at understanding the extent to which MMS fairness can be satisfied when the cost functions are beyond additive. In a sharp contrast to the allocation of goods, we first show that no algorithm can ensure better than min { n, log m log log m } -approximation when the cost functions are submodular. 1 Further, we show that for general subadditive cost functions, there always exists an allocation that is min { n, log m } -approximate MMS, and thus the approximation ratio is asymptotically tight. Next, we consider the ordinal relaxation, 1-out-ofd MMS. It is trivial that 1-out-of-1 MMSis satisfied no matter how the items are allocated, and somewhat surprisingly, our impossibility result implies that for any d ≥ 2 , there is an instance for which no allocation is 1-out-ofd MMS.

Result 1 For general subadditive cost functions, the asymptotically tight multiplicative approximation ratio of MMS is min { n, log m } . Further, for any d ≥ 2 , a 1-out-ofd MMSallocation may not exist.

Result 1 combines Theorems 1, 2 and Corollary 1. The strong impossibility in Result 1 does not rule out the possibility of constant multiplicative or ordinal approximation of MMS fair allocations for specific subadditive costs. For this reason, we turn to studying two concrete settings with subadditive costs. The first setting encodes a bin packing problem, which has applications in many areas (e.g., semiconductor chip design, loading vehicles with weight capacity limits, and filling containers [17]). In the first setting, the items have sizes which can be different to different agents. The agents have bins that can be used to pack the items allocated to them with the goal of using as few bins as possible. The second setting encodes a job scheduling problem, which appears in many research

areas, including data science, big data, high-performance computing, and cloud computing [25]. In the second setting, the items are jobs that need to be processed by the agents. Each job may be of different lengths to different agents and each agent controls a set of machines with possibly different speeds. Upon receiving a set of jobs, an agent's cost is determined by the corresponding minimum completion time when processing the jobs using her own machines (i.e., makespan). As will be clear, job scheduling setting is more general than the additive cost setting. Besides, it uncovers new research directions for group-wise fairness.

Result 2 For the bin packing and job scheduling settings, a 1-out-of-⌊ n 2 ⌋ MMS allocation and a 2-approximate MMS allocation always exist.

Result 2 combines Theorems 3, 4 and Corollaries 2, 3. Besides studying MMS fairness, in Appendix F, we also prove hardness results for two other relaxations of proportionality, i.e., PROP1 and PROPX.

2 Preliminaries

For any integer k ≥ 1 , let [ k ] = { 1 , . . . , k } . In a fair allocation instance I = ( N,M, { v i } i ∈ N ) , there are n agents denoted by N = [ n ] and m items denoted by M = { e 1 , . . . , e m } . Each agent i ∈ N has a cost function over the items, v i : 2 M → R + ∪ { 0 } . Note that for simplicity, we abuse v i ( · ) to denote a cost function. The items are chores, and particularly, upon receiving a set of items S ⊆ M , v i ( S ) represents the effort or cost agent i needs to spend on completing the chores in S . The cost functions are normalized and monotone, i.e., v i ( ∅ ) = 0 and v i ( S 1 ) ≤ v i ( S 2 ) for any S 1 ⊆ S 2 ⊆ M . Note that no bounded approximation can be achieved for general cost functions, and we provide one such example in Appendix B.1. Thus we restrict our attention to the following three classes. A cost function v i is subadditive if for any S 1 , S 2 ⊆ M , v i ( S 1 ∪ S 2 ) ≤ v i ( S 1 ) + v i ( S 2 ) . It is submodular if for any S 1 ⊆ S 2 ⊆ M and any e ∈ M \ S 2 , v i ( S 2 ∪{ e } ) -v i ( S 2 ) ≤ v i ( S 1 ∪{ e } ) -v i ( S 1 ) . It is additive if for any S ⊆ M , v i ( S ) = ∑ e ∈ S v i ( { e } ) . It is widely known that any additive function is also submodular, and any submodular function is also subadditive.

̸

An allocation A = ( A 1 , . . . , A n ) is an n -partition of the items where A i contains the items allocated to agent i such that A i ∩ A j = ∅ for any i = j and ⋃ i ∈ N A i = M . For any set S and integer d , let Π d ( S ) be the set of all d -partitions of S . The maximin share (MMS) of agent i is

Note that we may neglect n and I in MMS n i ( I ) when there is no ambiguity. Note that the computation of MMS is NP-hard even when the costs are additive, which can be verified by a reduction from the Partition problem. Given an n -partition of M , X = ( X 1 , . . . , X n ) , if v i ( X j ) ≤ MMS i for any j ∈ [ n ] , then X is called an MMS defining partition for agent i . Note that the original definition of MMS i for chores is defined with non-positive values, where the minimum value of the bundles is maximized. In this work, to simplify the notions, we choose to use non-negative numbers (representing costs), and thus the definition is equivalently changed to be the maximum cost of the bundles being minimized. To be consistent with the literature, we still call it maximin share.

Definition 1 ( α -MMS) An allocation A = ( A 1 , . . . , A n ) is α -approximate maximin share ( α -MMS) fair if v i ( A i ) ≤ α · MMS i for all i ∈ N . The allocation is MMS fair if α = 1 .

Given the definition of MMS, for any agent i with subadditive cost v i ( · ) , we have the following bounds for MMS i ,

Following recent works [5, 27, 26], we also consider the ordinal approximation of MMS, namely, 1 -out-ofd MMS fairness. Intuitively, MMS fairness can be regarded as 1-out-ofn MMS (i.e., partitioning the items into n bundles but receiving the largest bundle). Since 1-out-ofn MMS allocations may not exist, we can instead find a maximum integer d ≤ n such that a 1-out-ofd MMS allocation is guaranteed to exist. Given a d -partition of M , X = ( X 1 , . . . , X d ) , if v i ( X j ) ≤ MMS d i for any j ∈ [ d ] , then X is called a 1-out-ofd MMS defining partition for agent i . An allocation A is 1 -out-ofd MMS fair if for every agent i ∈ N , v i ( A i ) ≤ MMS d i . More generally, given any α ≥ 1 , we have the bi-factor approximation, α -approximate 1 -out-ofd MMS, if v i ( A i ) ≤ α · MMS d i for

every i ∈ N . By the definition, we have the following simple observation, whose proof is deferred to Appendix B.2.

Observation 1 For any instance with subadditive costs, given any integer 1 ≤ d ≤ n , a 1-out-ofd MMS allocation is ⌈ n d ⌉ -MMS fair.

3 General subadditive cost setting

By Inequality 1, if the costs are subadditive, allocating all items to a single agent ensures an approximation of n , which is the most unfair algorithm. Surprisingly, such an unfair algorithm achieves the optimal approximation ratio of MMS even if the costs are submodular.

Theorem 1 For any n ≥ 2 , there is an instance with submodular costs for which no allocation is better than n -MMS or log m log log m -MMS.

Proof. For any fixed n ≥ 2 , we construct an instance that contains n agents and m = n n items. By taking logarithm of m = n n twice, it is easy to obtain

Thus, in the following, it suffices to show that no allocation can be better than n -MMS. Let each item correspond to a point in an n -dimensional coordinate system, i.e.,

For each agent i ∈ N , we define n covering planes { C il } l ∈ [ n ] and for each l ∈ [ n ] ,

̸

Note that { C il } l ∈ [ n ] forms an exact cover of the points in M , i.e., ⋃ l C il = M and C il ∩ C iz = ∅ for all l = z . For any set of items S ⊆ M , v i ( S ) equals the minimum number of planes in { C il } l ∈ [ n ] that can cover S . Therefore, v i ( S ) ∈ [ n ] for all S . We first show v i ( · ) is submodular for every i . For any S ⊆ T ⊆ M and any e ∈ M \ T , if e is not in the same covering plane as any point in T , e is not in the same covering plane as any point in S , either. Thus, v i ( T ∪ { e } ) -v i ( T ) = 1 implies v i ( S ∪ { e } ) -v i ( S ) = 1 , and accordingly,

Since { C il } l ∈ [ n ] is an exact cover of M , MMS i = 1 for every i , where the MMS defining partition is simply { C il } l ∈ [ n ] . Then to prove the theorem, it suffices to show that for any allocation of M , there is at least one agent whose cost is n . For the sake of contradiction, we assume there is an allocation A = ( A 1 , . . . , A n ) where every agent has cost at most n -1 . This means that for every i ∈ N , there exists a plane C il i such that A i ∩ C il i = ∅ . Consider the point b = ( l 1 , . . . , l n ) , it is clear that b ∈ C il i and thus b / ∈ A i for all i . This means that b is not allocated to any agent, a contradiction. Therefore, such an allocation A does not exist which completes the proof of the theorem.

To facilitate the understanding of Theorem 1, in Appendix C.1, we visualize an instance with 3 agents and 27 items where no allocation is better than 3-MMS. The hard instance in Theorem 1 also implies the following lower bound for 1 -out-ofd MMS, whose proof is in Appendix C.2.

Corollary 1 For any 2 ≤ d ≤ n , there is an instance with submodular cost functions for which no allocation is 1 -out-ofd MMS.

Theorem 2 For any instance with subadditive cost functions, there always exists a min { n, ⌈ log m ⌉} -MMS allocation.

Proof. We describe the algorithm that computes a min { n, ⌈ log m ⌉} -MMS allocation in Algorithm 1. First, if log m ≥ n , we are safe to arbitrarily allocate the items to the agents, which ensures n -approximation.

The tricky case is when log m<n , where we cannot allocate too many items to a single agent. For this case, we first look at agent 1's MMS defining partition D 1 = ( D 1 1 , . . . , D 1 n ) , where v 1 ( D 1 j ) ≤ MMS 1

Algorithm 1 Computing a min { n, ⌈ log m ⌉} -MMS allocation for subadditive costs

Input: An instance ( N,M, { v i } i ∈ N ) with general subadditive costs. Output: An allocation A = ( A 1 , . . . , A n ) such that v i ( A i ) ≤ ⌈ log m ⌉ · MMS i for all i ∈ N .

1: Initialize A i ←∅ for every i ∈ N .

2: if log m ≥ n then

3: A 1 ← M .

4: else

5: i ← 1 and M 0 ← M .

6: end if

̸

8: Let ( D i 1 , . . . , D i n ) be one of i 's MMS defining partitions over M .

7: while M i -1 = ∅ and i ≤ n do

9: Let R i j = D i j ∩ M i -1 for all j ∈ [ n ] . Re-index the bundles such that | R i 1 | ≥ · · · ≥ | R i n | .

10: A i ← ⋃ j ∈ [ ⌈ log m ⌉ ] R i j and M i ← M i -1 \ A i .

11: i ← i +1 .

12: end while

for all j ∈ [ n ] and we assume that they are ordered by the number of items, i.e., | D 1 1 | ≥ · · · ≥ | D 1 n | . In order to ensure that agent 1's cost is no more than ⌈ log m ⌉ times her MMS, we ask her to take away ⌈ log m ⌉ largest bundles (in terms of number of items) in D 1 , i.e., A 1 = ⋃ j ∈ [ ⌈ log m ⌉ ] D 1 j . Since the cost function is subadditive,

Moreover, since on average each bundle in D 1 contains m n items and A 1 contains the bundles with largest number of items, | A 1 | ≥ ⌈ log m ⌉ · m n ≥ log m n · m . That is, at least log m n fraction of the items are taken away by agent 1. Let M 1 = M \ A 1 be the set of remaining items, and we have

We next ask agent 2 to take away items in a similar way to agent 1. Let D 2 = ( D 2 1 , . . . , D 2 n ) be one of agent 2's MMS defining partitions, and R 2 = ( R 2 1 , . . . , R 2 n ) be the remaining items in these bundles, i.e., R 2 j = D 2 j ∩ M 1 . Again, we assume | R 2 1 | ≥ · · · ≥ | R 2 n | . Letting A 2 = ⋃ j ∈ [ ⌈ log m ⌉ ] R 2 j and M 2 = M 1 \ A 2 , we have v 2 ( A 2 ) ≤ ⌈ log m ⌉ · MMS 2 . Moreover, since on average each bundle in R 2 contains | M 1 | n items and A 2 contains the bundles with largest number of items,

We continue with the above procedure for agents i = 3 , . . . , n with the formal description shown in Algorithm 1. It is straightforward that every agent i who gets a bundle A i has cost at most ⌈ log m ⌉ · MMS i . Further, by induction, Equation 3 holds for all agents i ≤ n , i.e.,

To show the validity of the Algorithm, it remains to show that the algorithm can allocate all items, i.e., M n = ∅ . This can be seen from the following inequalities,

Since | M n | < 1 , M n must be empty, which completes the proof of the theorem.

which gives

Note that Theorem 1 does not rule out the possibility of beating the approximation ratio for specific subadditive costs. In the next two sections, we turn to studying two specific settings, where we are able to beat the lower bounds in Theorem 1 and Corollary 1 by designing algorithms that can guarantee constant ordinal and multiplicative approximations of MMS. We will mostly consider the ordinal approximation of MMS. By Observation 1, the ordinal approximation gives a result of the multiplicative one, which can be improved by slightly modifying the designed algorithms.

4 Bin packing setting

4.1 Model

The first setting encodes a bin packing problem where the items have sizes and need to be packed into bins by the agents. The items may be of different sizes to different agents. Specifically, each item e j ∈ M has size s i,j ≥ 0 to each agent i ∈ N . For a set of items S , s i ( S ) = ∑ e j ∈ S s i,j . Each agent i ∈ N has unlimited number of bins with the same capacity c i . Without loss of generality, we assume that c 1 ≥ · · · ≥ c n and c i ≥ max e j ∈ M s i,j for all i ∈ N .

Upon receiving a set of items S ⊆ M , agent i 's cost v i ( S ) 2 is determined by the minimum number of bins (with capacity c i ) that can pack all items in S . Note that the calculation of v i ( S ) involves solving a classic bin packing problem which is NP-hard. For any two sets S 1 and S 2 , v i ( S 1 ∪ S 2 ) ≤ v i ( S 1 ) + v i ( S 2 ) since the optimal packing of S 1 ∪ S 2 is no worse than packing S 1 and S 2 separately and thus v i ( · ) is subadditive. Accordingly, MMS d i is essentially the minimum number k i such that the items can be partitioned into d bundles and the items in each bundle can be packed into no more than k i bins. The definition of MMS d i gives MMS d i · c i ≥ s i ( M ) d for all i ∈ N .

We say an item e j ∈ M is large for an agent i if the size of e j to i exceeds half of the capacity of i 's bins, i.e., s i,j > c i 2 ; otherwise, we say e j is small for i . Let H i denote the set of i 's large items in M , and L i denote the set of i 's small items; that is, H i = { e j ∈ M : s i,j > c i 2 } and L i = { e j ∈ M : s i,j ≤ c i 2 } . Since two large items cannot be put together into the same bin, the number of each agent i 's large items is at most MMS d i · d ; that is, | H i | ≤ MMS d i · d .

We apply a widely-used reduction [13, 28] to restrict our attention on identical ordering (IDO) instances where s i, 1 ≥ · · · ≥ s i,m for all i . Specifically, it means that any algorithm that ensures α -approximate 1-out-ofd MMS allocations for IDO instances can be converted to compute α -approximate 1-out-ofd MMS allocations for general instances. The reduction may not work for all subadditive costs, but we prove in Appendix D.1 that it does work for the bin packing and job scheduling settings. Therefore, for these two settings, we only consider IDO instances.

4.2 Algorithm

Next, we elaborate on the algorithm that proves Theorem 3.

Theorem 3 A 1 -out-of-⌊ n 2 ⌋ MMS allocation always exists for any bin packing instance.

Let d = ⌊ n 2 ⌋ . In a nutshell, our algorithm consists of two parts: in the first part, we partition the items into d bundles in a bag-filling fashion and select one or two agents for each bundle. In the second part, for each of the d bundles and each of the agents selected for it, we present an imaginary assignment of the items in the bundle to the bins of the agent. These imaginary assignments are used to guide the allocation of the items to the agents, such that each agent receives cost no more than her 1-out-ofd MMS.

4.2.1 Part 1: partitioning the items into d bundles

The algorithm in the first part is formally presented in Algorithm 2, which runs in d rounds of bag initialization (Steps 5 to 8) and bag filling (Steps 12 to 18). For each round j ∈ [ d ] , we define candidate agents - those who think the size of the bag B j is not large enough and have unallocated small items (Step 4). Note that the set of candidate agents changes with the items in the bag and the

unallocated items. In the bag initialization procedure, we put into the bag the item e j and the items every d items after e j (i.e., e j + d , e j +2 d , . . . ), as long as they have not been allocated and are large for at least one remaining agent. We select one such agent. After the bag initialization procedure, if there is at most one candidate agent, the round ends and the candidate agent (if exists and has not been selected) is added as another selected agent. Otherwise, we enter the bag filling procedure.

In the bag filling procedure, as long as there exist at least two candidate agents, we let two of them be the selected agents and put the smallest unallocated item into the bag. If there is at most one candidate agent after the smallest item is put into the bag, the round ends and the only candidate agent (if exists and has not been selected) replaces one of the selected agents.

̸

̸

The way we establish the bag and select the agents makes the following two important properties satisfied for every round j ∈ [ d ] .

Property 1 : for each selected agent i ∈ G j , there are at most MMS d i items in B j that are large for i . Besides, letting e ∗ j be the item lastly added to B j , if e ∗ j is small for i , then s i ( B j \ { e ∗ j } ) ≤ s i ( M ) d .

Property 2 : for each remaining agent i ′ (i.e., i ′ / ∈ ⋃ l ∈ [ j ] G l ), either s i ′ ( B j ) > s i ′ ( M ) d or no unallocated item is small for i at the end of round j . Besides, no item in { e j , e j + d , . . . } that is large for i ′ remains unallocated at the end of round j .

Proof. For the first property, observe that large items are added into the bag only in the bag initialization procedure, where one out of every d items is picked. Since there are at most d · MMS d i large items for every agent i , the bag contains at most MMS d i of i 's large items. There are two cases where e ∗ j is small for an agent i ∈ G j . First, i is the only candidate agent after e ∗ j is added, for which case, we have s i ( B j ) ≤ s i ( M ) d . Second, i is one of the two selected candidate agents before e ∗ j is added, for which case, we have s i ( B j \ { e ∗ j } ) ≤ s i ( M ) d . In both cases, s i ( B j \ { e ∗ j } ) ≤ s i ( M ) d holds. The second property is quite direct by the algorithm, since there is no candidate agent outside G j at the end of round j (i.e., N ( B j ) \ G j = ∅ ), and all unallocated large items in { e j , e j + d , . . . } are put into the bag in the bag initialization procedure.

Property 1 ensures that the items in each bundle B j ∈ B can be allocated to the selected agents in G j , such that each agent i ∈ G j can use no more than MMS d i bins to pack all the items allocated to her, which will be shown in the following part. Property 2 ensures the following claim.

Claim 1 All the items can be allocated in Algorithm 2.

Proof. Observe that when the last round begins, there are at least n -( d -1) · 2 ≥ 2 remaining agents. If all the unallocated items are large for some remaining agent, all of them are added into the bag during the bag initialization procedure of the last round and thus no item remains unallocated. Now consider the case where some unallocated item is small for any remaining agent. By Property 2, for any j ∈ [ d -1] and any remaining agent i ′ , we have s i ′ ( B j ) > s i ′ ( M ) d . This gives that the total size of the unallocated items to i ′ is smaller than s i ′ ( M ) d . Besides, after the bag initialization procedure of the last round, no large item remains and every remaining item is small for any remaining agent. Combining these two facts, we know that there are always at least 2 candidate agents and thus all small items can be allocated in the bag filling procedure, which completes the proof.

4.2.2 Part 2: Allocating the items to the agents

Next, we allocate the items in each bundle B j ∈ B to the selected agents in G j . Let i be any agent in G j and B ′ j = B j \ { e ∗ j } where e ∗ j is the item lastly added to B j . We first imaginatively assign the items in B ′ j to i 's bins as illustrated by Figure 1. We first put i 's large items in B ′ j into individual empty bins. Then we greedily put into the bins the remaining small items in B ′ j in decreasing order of their sizes, as long as the total size of the assigned items does not exceed the bin's capacity. The first time when the total size exceeds the capacity, we move to the next bin and so on (if all the bins with large items are filled, we move to an empty bin). We call the item lastly added to each bin that makes the total size exceed the capacity an extra item . Denote by J i ( B ′ j ) the set of extra items and by W i ( B ′ j ) = B ′ j \ J i ( B ′ j ) the other items in B ′ j .

Extra items J;(B')

Bundle:

1

2

Bundle:1

2

Schedulingthelargeitems

Scheduling the small items

Large item

Small item

If all items in B j are large for some agent i ∈ G j , we allocate all of them to i . Otherwise, we know that round j enters the bag filling procedure, thus there are two agents in G j and the last item e ∗ j is small for both of them. Letting i 1 be the agent who has more large items in B j and i 2 be the other agent, we allocate i 1 the items in W i 1 ( B ′ j ) and allocate i 2 the items in J i 1 ( B ′ j ) ∪ { e ∗ j } .

Now we are ready to prove Theorem 3.

Proof of Theorem 3. Consider any round j ∈ [ d ] . If all items in B j are large for some agent i ∈ G j , by Property 1, we know that there are at most MMS d i items in B j . Thus i can pack all items in B j using no more than MMS d i bins.

For the other case, recall that the agent i 1 ∈ G j who has more large items in B j receives the items in W i 1 ( B ′ j ) , and the other agent i 2 receives the items in J i 1 ( B ′ j ) ∪ { e ∗ j } . We first discuss agent i 1 . By Property 1, we know that for each agent i ∈ { i 1 , i 2 } , there are at most MMS d i large items in B ′ j and s i ( B ′ j ) ≤ s i ( M ) d . These two facts imply that in the imaginative assignment of B ′ j to i 1 , no more than MMS d i 1 bins are used. Since otherwise, s i 1 ( B ′ j ) > MMS d i 1 · c i 1 ≥ s i 1 ( M ) d , a contradiction. Therefore, i 1 can pack all items in W i 1 ( B ′ j ) using no more than MMS d i 1 bins.

Next we discuss agent i 2 . Observe that in the imaginary assignment of B ′ j to i 1 , for each extra item in J i 1 ( B ′ j ) , there exists another item in the same bin with a larger size. Therefore, we have

̸

s i 2 ( J i 1 ( B ′ j )) ≤ s i 2 ( B ′ j ) 2 ≤ s i 2 ( M ) 2 d . Combining with the fact that there are at most MMS d i 2 large items in B ′ j for i 2 , we know that i 2 can use no more than MMS d i 2 bins to pack all items in J i 1 ( B ′ j ) and there exists one bin with at least half the capacity not occupied. Since otherwise, s i 2 ( J i 1 ( B ′ j )) > MMS d i 2 · c i 2 2 ≥ s i 2 ( M ) 2 d , a contradiction. Recall that the last item e ∗ j is small for i 2 , it can be put into the bin that has enough unoccupied capacity. Therefore, i 2 can also pack all items in J i 1 ( B ′ j ) ∪ { e ∗ j } using at most MMS d i 2 bins, which completes the proof.

For the multiplicative relaxation of MMS, by Theorem 3 and Observation 1, a ⌈ n ⌊ n 2 ⌋ ⌉ -MMS allocation is guaranteed. Actually, we can slightly modify Algorithm 2 to compute a 2-MMS allocation.

Proof. To compute a 2-MMS allocation, we replace the value of d with n in Algorithm 2 and select only one agent in each round who receives the bag in that round. The modified algorithm is formally presented in Algorithm 3. Following the same reasonings in Parts 1 and 2 (i.e., Subsubsections 4.2.1 and 4.2.2), it is not hard to see that all items can be allocated in Algorithm 3 and for any i ∈ N , there are at most MMS i large items in A i . Besides, if the last item e ∗ i is small for i , we have s i ( A i \ { e ∗ i } ) ≤ s i ( M ) n . Again, in the imaginary assignment of A i \ { e ∗ i } to i , no more than MMS i bins are used and at least one of them does not have an extra item. Therefore, agent i can use MMS i bins to pack all items in W i ( A i \ { e ∗ i } ) and another MMS i bins to pack all items in J i ( A i \ { e ∗ i } ) ∪ { e ∗ i } , which completes the proof.

In Appendix D.2, we show that the above multiplicative ratio is actually tight in the sense that there exists an instance where no allocation is better than 2-MMS. Besides, in Appendix D.3, we show that the algorithm that proves Corollary 2 actually computes an allocation where every agent i can use at most 3 2 MMS i +1 bins to pack all the items allocated to her.

5 Job scheduling setting

The second setting encodes a job scheduling problem where the items are jobs that need to be processed by the agents. Each item e j ∈ M has a size s i,j ≥ 0 to each agent i ∈ N , and for a set of items S ⊆ M , s i ( S ) = ∑ e j ∈ S s i,j . As the bin packing setting, we only consider IDO instances where s i, 1 ≥ · · · ≥ s i,m for all i . Each agent i ∈ N exclusively controls a set of k i machines P i = [ k i ] with possibly different speed ρ i,l for each l ∈ P i . Without loss of generality, we assume ρ i, 1 ≥ · · · ≥ ρ i,k i . Upon receiving a set of items S ⊆ M , agent i 's cost v i ( S ) is the minimum completion time of processing S using her own machines P i (i.e., the makespan of P i ). Formally,

Note that the computation of v i ( S ) is NP-hard if k i ≥ 2 . For any two sets S 1 and S 2 , v i ( S 1 ∪ S 2 ) ≤ v i ( S 1 ) + v i ( S 2 ) since the makespan of scheduling S 1 ∪ S 2 is no larger than the sum of the makespans of scheduling S 1 and S 2 separately, thus v i ( · ) is subadditive.

Regarding the value of MMS d i , intuitively, it is obtained by partitioning the items into d · k i bundles, and allocating them to k i different types of machines (with possibly different speeds) where each type has d identical machines so that the makespan is minimized. 3 Note that when each agent controls a single machine, i.e., k i = 1 for all i , the problem degenerates to the additive cost case, and thus the job scheduling setting strictly generalizes the additive setting.

For the job scheduling setting, we have the following two main results.

Theorem 4 A 1-out-of-⌊ n 2 ⌋ MMS allocation always exists for any job scheduling instance.

Corollary 3 A 2-MMS allocation always exists for any job scheduling instance.

Note that simply partitioning the items into n bundles in a round-robin fashion does not guarantee 1-out-of-⌊ n 2 ⌋ MMSeven for the simpler additive cost setting. Consider an instance where there are four identical agents and five items with costs 4, 1, 1, 1, 1, respectively. For this instance, the value of 1-out-of-⌊ n 2 ⌋ MMSfor each agent is 4 as the 1-out-of2 MMSdefining partition is {{ 4 } , { 1 , 1 , 1 , 1 }} . However, the round-robin algorithm allocates two items with costs 4 and 1 to one agent, who receives a cost more than her 1-out-ofd MMS. Our algorithm overcomes this problem by first partitioning the items into ⌊ n 2 ⌋ bundles and then carefully allocating the items in each bundle to two agents.

Let d = ⌊ n 2 ⌋ . For each agent i ∈ N and each machine l ∈ P i , let c i,l = ρ i,l · MMS d i denote l 's capacity. In a nutshell, our algorithm consists of three parts: in the first part, we partition all items into d bundles in a round-robin fashion. In the second part, for each of the d bundles and each agent, we present an imaginary assignment of the items in the bundle to the agent's machines. These imaginary assignments are used in the third part to guide the allocation of the items in each of the d bundles to two agents, such that each agent can assign her allocated items to her machines in a way that the total workload on each machine does not exceed its capacity (in other words, each agent's cost is no more than her 1-out-ofd MMS). We defer the detailed algorithms and proofs to Appendix E.

6 Conclusion

In this work, we study fair allocation of indivisible chores when the costs are beyond additive and the fairness is measured by MMS. There are many open problems and further directions. First, there are only existential results for min { n, ⌈ log m ⌉} -MMS allocations in the general subadditive cost setting and 1-out-of-⌊ n 2 ⌋ MMSallocations in the job scheduling setting. Polynomial-time algorithms that achieve the same results remain as open problems. Second, for the general subadditive cost setting and the bin packing setting, we provide the tight approximation ratios, but for the job scheduling setting, we only have a lower bound of 44 43 , which is inherited from the additive cost setting [20]. One immediate direction is to design better approximation algorithms or lower bound instances for the job scheduling setting. Third, in the appendix, we show that for the bin packing setting, there exists an allocation where every agent's cost is no more than 3 2 times her MMS plus 1. We suspect that the multiplicative factor can be improved to 1. Fourth, for the job scheduling setting, we restrict us on the case of related machines in the current work, it is interesting to consider the general model of unrelated machines. As we have mentioned, the notion of collective maximin share fairness in the job scheduling setting can be viewed as a group-wise fairness notion, which could be of independent interest. Finally, we can investigate other combinatorial costs that can better characterize real-world problems.

References

Georgios Amanatidis, Evangelos Markakis, Afshin Nikzad, and Amin Saberi. Approximation algorithms for computing maximin share allocations. ACMTrans. Algorithms , 13(4):52:1-52:28, 2017.

Georgios Amanatidis, Evangelos Markakis, and Apostolos Ntokos. Multiple birds with one stone: Beating 1/2 for EFX and GMMS via envy cycle elimination. Theor. Comput. Sci. , 841: 94-109, 2020.

Georgios Amanatidis, Haris Aziz, Georgios Birmpas, Aris Filos-Ratsikas, Bo Li, Hervé Moulin, Alexandros A. Voudouris, and Xiaowei Wu. Fair division of indivisible goods: A survey. CoRR , abs/2208.08782, 2022.

Haris Aziz, Gerhard Rauchecker, Guido Schryen, and Toby Walsh. Algorithms for max-min share fair allocation of indivisible chores. In AAAI , pages 335-341. AAAI Press, 2017.

Moshe Babaioff, Noam Nisan, and Inbal Talgam-Cohen. Fair allocation through competitive equilibrium from generic incomes. In FAT , page 180. ACM, 2019.

Siddharth Barman and Sanath Kumar Krishnamurthy. Approximation algorithms for maximin fair division. ACM Trans. Economics and Comput. , 8(1):5:1-5:28, 2020.

Siddharth Barman, Arpita Biswas, Sanath Kumar Krishna Murthy, and Yadati Narahari. Groupwise maximin fair allocation of indivisible goods. In AAAI , pages 917-924. AAAI Press, 2018.

Siddharth Barman, Arindam Khan, Sudarshan Shyam, and K. V. N. Sreenivas. Finding fair allocations under budget constraints. In AAAI , pages 5481-5489. AAAI Press, 2023.

Siddharth Barman, Arindam Khan, Sudarshan Shyam, and K. V. N. Sreenivas. Guaranteeing envy-freeness under generalized assignment constraints. In EC , pages 242-269. ACM, 2023.

Siddharth Barman, Vishnu V. Narayan, and Paritosh Verma. Fair chore division under binary supermodular costs. CoRR , abs/2302.11530, 2023.

Umang Bhaskar, A. R. Sricharan, and Rohit Vaish. On approximate envy-freeness for indivisible chores and mixed resources. In APPROX-RANDOM , volume 207 of LIPIcs , pages 1:1-1:23. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2021.

Jeff A. Bilmes. Submodularity in machine learning and artificial intelligence. CoRR , abs/2202.00132, 2022.

Sylvain Bouveret and Michel Lemaître. Characterizing conflicts in fair division of indivisible goods using a scale of criteria. Auton. Agents Multi Agent Syst. , 30(2):259-290, 2016.

Eric Budish. The combinatorial assignment problem: Approximate competitive equilibrium from equal incomes. Journal of Political Economy , 119(6):1061-1103, 2011.

Ioannis Caragiannis, David Kurokawa, Hervé Moulin, Ariel D. Procaccia, Nisarg Shah, and Junxing Wang. The unreasonable fairness of maximum nash welfare. ACM Trans. Economics and Comput. , 7(3):12:1-12:32, 2019.

Hau Chan, Jing Chen, Bo Li, and Xiaowei Wu. Maximin-aware allocations of indivisible goods. In IJCAI , pages 137-143. ijcai.org, 2019.

Edward G Coffman, János Csirik, Gábor Galambos, Silvano Martello, and Daniele Vigo. Bin packing approximation algorithms: survey and classification. In Handbook of combinatorial optimization , pages 455-531. 2013.

Graham Cormode. Data sketching. Commun. ACM , 60(9):48-55, 2017.

Amitay Dror, Michal Feldman, and Erel Segal-Halevi. On fair division under heterogeneous matroid constraints. J. Artif. Intell. Res. , 76:567-611, 2023.

Uriel Feige, Ariel Sapir, and Laliv Tauber. A tight negative example for MMS fair allocations. In WINE , volume 13112 of Lecture Notes in Computer Science , pages 355-372. Springer, 2021.

Jiarui Gan, Bo Li, and Xiaowei Wu. Approximation algorithm for computing budget-feasible EF1 allocations. In AAMAS , pages 170-178. ACM, 2023.

Jugal Garg and Setareh Taki. An improved approximation algorithm for maximin shares. Artif. Intell. , 300:103547, 2021.

Mohammad Ghodsi, Mohammad Taghi Hajiaghayi, Masoud Seddighin, Saeed Seddighin, and Hadi Yami. Fair allocation of indivisible goods: Improvement. Math. Oper. Res. , 46(3): 1038-1053, 2021.

Mohammad Ghodsi, Mohammad Taghi Hajiaghayi, Masoud Seddighin, Saeed Seddighin, and Hadi Yami. Fair allocation of indivisible goods: Beyond additive valuations. Artif. Intell. , 303: 103633, 2022.

Sönke Hartmann and Dirk Briskorn. An updated survey of variants and extensions of the resource-constrained project scheduling problem. European Journal of operational research , 297(1):1-14, 2022.

Hadi Hosseini, Andrew Searns, and Erel Segal-Halevi. Ordinal maximin share approximation for chores. In AAMAS , pages 597-605. International Foundation for Autonomous Agents and Multiagent Systems (IFAAMAS), 2022.

Hadi Hosseini, Andrew Searns, and Erel Segal-Halevi. Ordinal maximin share approximation for goods. J. Artif. Intell. Res. , 74, 2022.

Xin Huang and Pinyan Lu. An algorithmic framework for approximating maximin share allocation of chores. In EC , pages 630-631. ACM, 2021.

Xin Huang and Erel Segal-Halevi. A reduction from chores allocation to job scheduling. CoRR , abs/2302.04581, 2023.

Halvard Hummel and Magnus Lie Hetland. Fair allocation of conflicting items. Auton. Agents Multi Agent Syst. , 36(1):8, 2022.

David Kurokawa, Ariel D. Procaccia, and Junxing Wang. When can the maximin share guarantee be guaranteed? In AAAI , pages 523-529. AAAI Press, 2016.

David Kurokawa, Ariel D. Procaccia, and Junxing Wang. Fair enough: Guaranteeing approximate maximin shares. J. ACM , 65(2):8:1-8:27, 2018.

Bo Li, Minming Li, and Ruilong Zhang. Fair scheduling for time-dependent resources. In NeurIPS , pages 21744-21756, 2021.

Bo Li, Yingkai Li, and Xiaowei Wu. Almost (weighted) proportional allocations for indivisible chores. In WWW , pages 122-131. ACM, 2022.

Richard J. Lipton, Evangelos Markakis, Elchanan Mossel, and Amin Saberi. On approximately fair allocations of indivisible goods. In EC , pages 125-131. ACM, 2004.

Gaëlle Loosli and Stéphane Canu. Comments on the "core vector machines: Fast SVM training on very large data sets". J. Mach. Learn. Res. , 8:291-301, 2007.

Baharan Mirzasoleiman, Amin Karbasi, Rik Sarkar, and Andreas Krause. Distributed submodular maximization: Identifying representative elements in massive data. In NIPS , pages 2049-2057, 2013.

Hervé Moulin. Fair division in the age of internet. Annu. Rev. Econ. , 2018.

Benjamin Plaut and Tim Roughgarden. Almost envy-freeness with general valuations. SIAM J. Discret. Math. , 34(2):1039-1068, 2020.

Masoud Seddighin and Saeed Seddighin. Improved maximin guarantees for subadditive and fractionally subadditive fair allocation problem. In AAAI , pages 5183-5190. AAAI Press, 2022.

Edward Lloyd Snelson and Zoubin Ghahramani. Sparse gaussian processes using pseudo-inputs. In NIPS , pages 1257-1264, 2005.

Shengwei Zhou and Xiaowei Wu. Approximately EFX allocations for indivisible chores. CoRR , abs/2109.07313, 2021.

Appendix

A More related works

Besides proportionality, in another parallel line of research, envy-freeness and its relaxations, namely envy-free up to one item (EF1) and envy-free up to any item (EFX), are also widely studied. It was shown in [35] and [11] for goods and chores, respectively, that an EF1 allocation exists for the monotone combinatorial functions. However, the existence of EFX allocations is still unknown even with additive functions. Therefore, approximation algorithms were proposed in [2, 42] for additive functions and in [39, 16] for subadditive functions. We refer the readers to [3] for a detailed survey on fair allocation of indivisible items.

B Missing materials in preliminaries

B.1 Impossibility result for general cost functions

We provide an example to show that no bounded approximation ratio can be achieved for general cost functions. Note that there exist simpler examples, but we choose the following one because it represents a particular combinatorial structure - minimum spanning tree. Let G = ( V, E ) be a graph shown in the left sub-figure of Figure 2, where the vertices V are the items that are to be allocated, i.e., M = V . There are two agents N = { 1 , 2 } who have different weights on the edges as shown in the middle and right sub-figures of Figure 2. The cost functions are measured by the minimum spanning tree in their received subgraphs. Particularly, for any S ⊆ V , v i ( S ) equals the weight of the minimum spanning tree on G [ S ] - the induced subgraph of S in G - under agent i 's weights. Thus, MMS i = 0 , for both i = 1 , 2 , where an MMS defining partition for agent 1 is { v 1 , v 2 } and { v 3 , v 4 } and that for agent 2 is { v 1 , v 4 } and { v 2 , v 3 } . However, it can be verified that no matter how the vertices are allocated to the agents, there is one agent whose cost is at least 1, which implies that no bounded approximation is possible for general costs.

v1

V2

v1

0

V2

v1

1

V2

1

L

1

1

1

1

0

0

V4

V3

V4

0

V3

V4

1

V3

G = (V,E)

Agent 1's weights

Agent 2's weights

B.2 Proof of Observation 1

To prove the observation, it suffices to show MMS d i ≤ ⌈ n d ⌉ · MMS n i for any agent i ∈ N . Let X = ( X 1 , . . . , X n ) be an MMS defining partition for agent i , which satisfies v i ( X j ) ≤ MMS n i for every j ∈ [ n ] . Consider a d -partition X ′ = ( X ′ 1 , . . . , X ′ d ) built by evenly distributing the n bundles in X to the d bundles in X ′ ; that is, the number of bundles distributed to the bundles in X ′ differs by at most one. Clearly, X ′ satisfies v i ( X ′ j ) ≤ ⌈ n d ⌉ · MMS n i for every j ∈ [ d ] . By the definition of 1-out-ofd MMS, it follows that

thus completing the proof.

x

z

y

1

2

3

2

2

3

3

Agent 1

x

z

y

1

2

3

2

2

3

3

Agent 2

x

z

y

1

2

3

2

2

3

3

Agent 3

C Missing materials in general subadditive cost setting

C.1 An example that helps understand Theorem 1

The example is illustrated in Figure 3 where each agent has three covering planes. Take agent 1 for example, her three covering planes contain the items whose x coordinates are 1, 2, 3, respectively. If there exists an allocation that is better than 3-MMS, then each agent is allocated items from at most 2 of her covering planes. Without loss of generality, we assume that agent 1 (or agents 2 and 3 respectively) is not allocated any item whose x (or y and z respectively) coordinate is 1. Then, the item (1 , 1 , 1) is not allocated to any agent, a contradiction.

C.2 Proof of Corollary 1

We consider the same instance that is designed in Theorem 1. In this instance, we have proved that no matter how the items are allocated among the agents, there is at least one agent, say i , whose cost is n . Moreover, by the design of the cost functions, for any integer d , it can be observed that MMS d i = ⌈ n d ⌉ . Note that ⌈ n d ⌉ is always smaller than n for all d ≥ 2 , thus the allocation is not 1 -out-ofd MMSto i .

D Missing materials in bin packing setting

D.1 The IDO reduction

For a bin packing or job scheduling instance I , the IDO instance I ′ is constructed by setting the size of each item e j ∈ M to each agent i ∈ N in I ′ to the j -th largest size of the items to i in I . Then the IDO reduction is formally presented in the following lemma.

Lemma 1 For the bin packing or job scheduling setting, if there exists an allocation A ′ = ( A ′ 1 , . . . , A ′ n ) in the IDO instance I ′ such that v ′ i ( A ′ i ) ≤ α · MMS d i ( I ′ ) for all i ∈ N , then there exists an allocation A = ( A 1 , . . . , A n ) in the original instance I such that v i ( A i ) ≤ α · MMS d i ( I ) for all i ∈ N .

Proof. We design Algorithm 4 that given I , I ′ and A ′ , computes the desired allocation A . In the algorithm, we look at the items from e m to e 1 . For each item, we let the agent who receives it in I ′ pick her smallest unallocated item in I .

To prove the lemma, we first show that v i ( A i ) ≤ v ′ i ( A ′ i ) for all i ∈ N . Consider the iteration where we look at the item e g . We suppose that in this iteration agent i picks item e g ′ ; that is, e g ∈ A ′ i , e g ′ ∈ A i and e g ′ is the smallest unallocated item for i . Since an item is removed from the set R after it is allocated, exactly m -g items have been allocated before e g ′ is allocated. Therefore, e g ′ is among the top m -g +1 smallest items for agent i . Recall that e g is the item with the exactly ( m -g +1) -th smallest size to i , hence s i,g ′ ≤ s ′ i,g . The same reasoning can be applied to other items in A ′ i and A i , and to other agents. It follows that for any i ∈ N , any e g ∈ A ′ i and the corresponding e g ′ ∈ A i , s i,g ′ ≤ s ′ i,g . For the bin packing or job scheduling setting, this implies v i ( A i ) ≤ v ′ i ( A ′ i ) . Since the maximin share depends on the sizes of the items but not on the order, the maximin share

of agent i in I ′ is the same as that in I , i.e., MMS d i ( I ′ ) = MMS d i ( I ) . Hence, the condition that v ′ i ( A ′ i ) ≤ α · MMS d i ( I ′ ) gives v i ( A i ) ≤ α · MMS d i ( I ) , which completes the proof.

Algorithm 4 IDO reduction for the bin packing and job scheduling settings

Input: A general instance I , the IDO instance I ′ and an allocation A ′ = ( A ′ 1 , ..., A ′ n ) for the IDO instance such that v ′ i ( A ′ i ) ≤ α · MMS d i ( I ′ ) for all i ∈ N .

Output: An allocation A = ( A 1 , ..., A n ) such that v i ( A i ) ≤ α · MMS d i ( I ) for all i ∈ N .

1: For all i ∈ N and e g ∈ A ′ i , set p g ← i .

2: Initialize A i ←∅ for all i ∈ N , and R ← M .

3: for g = m to 1 do

4: Pick e g ′ ∈ arg min e k ∈ R { s p g ,k } .

5: A p g ← A p g ∪ { e g ′ } , R ← R \ { e g ′ } .

6: end for

D.2 Lower bound instance

We present an instance for the bin packing setting where no allocation can be better than 2-MMS. We first recall the impossibility instance given by Feige et al. [20]. In this instance there are three agents and nine items as arranged in a three by three matrix. The three agents' costs are shown in the matrices V 1 , V 2 and V 3 .

Feige et al. [20] proved that for this instance the MMS value of every agent is 43 , however, in any allocation, at least one of the three agents gets cost no smaller than 44.

We can adapt this instance to the bin packing setting and obtain a lower bound of 2. In particular, we also have three agents and nine items. The numbers in matrices V 1 , V 2 and V 3 are the sizes of the items to agents 1 , 2 and 3 , respectively. Let the capacities of the bins be c i = 43 for all i ∈ { 1 , 2 , 3 } . Accordingly, we have MMS i = 1 for all i ∈ { 1 , 2 , 3 } . Since in any allocation, there is at least one agent who gets items with total size no smaller than 44, for this agent, she has to use two bins to pack the assigned items, which means that no allocation can be better than 2-MMS.

D.3 Computing 3 2 MMS +1 allocations

Recall that in the proof of Corollary 2, it has been shown that each agent i ∈ N can use MMS i bins to pack all items in W i ( A i \ { e ∗ i } ) and another MMS i bins to pack all items in J i ( A i \ { e ∗ i } ) ∪{ e ∗ i } . Actually, since all items in J i ( A i \ { e ∗ i } ) ∪ { e ∗ i } are small for i and at least two small items can be put into one bin, i only needs ⌈ MMS i 2 ⌉ bins to pack all items in J i ( A i \ { e ∗ i } ) ∪{ e ∗ i } . Therefore, each agent i can use no more than 3 2 MMS i +1 bins to pack all the items allocated to her.

E Missing materials in job scheduling setting

E.1 Another interpretation to the job scheduling setting

An alternative way to explain the job scheduling setting is to view each agent i as a group of k i small agents and MMS d i as the collective maximin share for these k i small agents. We believe this notion of collective maximin share is of independent interest as a group-wise fairness notion. We remark that this notion is different from the group-wise (and pair-wise) maximin share defined in [7] and [15], where the max-min value is defined for each single agent. In our definition, however, a set of agents share the same value for the items allocated to them.

E.2 Algorithm

E.2.1 Part 1: partitioning the items into d bundles

We first partition the items into d bundles B = ( B 1 , . . . , B d ) in a round-robin fashion. Specifically, we allocate the items in descending order of their sizes to the bundles by turns, from the first bundle to the last one. Each time, we allocate one item to one bundle, and when every bundle receives an item, we start over from the first bundle and so on. For any set of items S , let S [ l ] be the l -th largest item in S , then the algorithm is formally presented in Algorithm 5.

Algorithm 5 Partitioning the items into d bundles

By the characteristic of the round-robin fashion, we have the following important observation.

Observation 2 For each bundle B j ∈ B and each item e k ∈ B j \{ B j [1] } (if exists), the d -1 items before e k (i.e., items e k -1 , e k -2 , . . . , e k -d +1 ) have at least the same sizes as e k .

E.2.2 Part 2: imaginary assignment

Next, for each bundle B j ∈ B computed in the first part and each agent i ∈ N , we imaginatively assign the items in B j \ B j [1] to i 's machines as follows. We greedily assign the items with larger sizes to i 's machines with faster speeds (in other words, with larger capacities), as long as the total workload on one machine does not exceed the its capacity. The first time when the workload exceeds the capacity, we move to the next machine and so on. The algorithm is formally presented in Algorithm 6 and illustrated in Figure 4. For each l ∈ P i , C I i,l contains the items imaginatively assigned to machine l that do not make the total workload exceed l 's capacity, and t i,l is the last item assigned to l that makes the total workload exceed the capacity. Note that C I i,l may be empty and t i,l may be null. For simplicity, let t i, 0 = B j [1] ; that is, B j [1] is assigned to an imaginary machine 0. The items in ⋃ l ∈ [ k i ] C I i,l are called internal items (as shown by the dark boxes in Figure 4), and { t i, 0 , . . . , t i,k i } are called external items (as shown by the light boxes).

Algorithm 6 Imaginary assignment

For each bundle B j ∈ B and each agent i ∈ N , the imaginary assignment has the following important properties.

Property 1 : all items in B j \ { B j [1] } can be assigned to agent i 's machines. Besides, the last machine k i does not have an external item; that is, t i,k i is null.

Property 2 : for any 1 ≤ l ≤ k i , the total size of the internal items C I i,l does not exceed the capacity of machine l , i.e., s i ( C I i,l ) ≤ c i,l

Property 3 : for any 1 ≤ l ≤ k i , the external item t i,l -1 (if not null) has size no larger than the capacity of machine l , i.e., s i ( t i,l -1 ) ≤ c i,l .

Proof. The first property holds since otherwise, s i ( B j \ { B j [1] } ) > ∑ l ∈ [ k i ] c i,l . By Observation 2, it follows that

However, since all items can be assigned to i 's machines in i 's 1-out-ofd MMSdefining partition, we have s i ( M ) ≤ d · ∑ l ∈ [ k i ] c i,l , a contradiction.

The second property directly follows the algorithm. For the third property, s i ( t i, 0 ) ≤ c i, 1 follows two facts that t i, 0 is assigned to some machine in i 's 1-out-ofd MMS defining partition and c i, 1 is the largest capacity of the machines. We then consider l ∈ [ k i -1] and show s i ( t i,l ) ≤ c i,l +1 (if t i,l is not null). The same reasoning can be applied to any other l ′ ∈ [ k i -1] . Let S 1 = ⋃ p ∈ [ l ] ( C I i,p ∪{ t i,p } ) . From the algorithm, we know that s i ( S 1 ) > ∑ p ∈ [ l ] c i,p and t i,l is the smallest item in S 1 . By Observation 2, there exist another d -1 disjoint sets of items { S 2 , . . . , S d } such that s i ( S k ) ≥ s i ( S 1 ) for every k ∈ [2 , d ] and t i,l is also the smallest item in ⋃ k ∈ [ d ] S k . Hence, ∑ k ∈ [ d ] s i ( S k ) > d · ∑ p ∈ [ l ] c i,p . This implies that in i 's 1-out-ofd MMSdefining partition, at least one item in ⋃ k ∈ [ d ] S k is assigned to machine p ≥ l + 1 . Combining with the fact that t i,l is the smallest item in ⋃ k ∈ [ d ] S k , we have s i ( t i,l ) ≤ c i,l +1 .

By these properties, for each machine l ∈ P i , we can assign either the internal items C I i,l or the external item t i,l -1 to l , such that its completion time does not exceed MMS d i . This intuition guides the allocation of the items to the agents in the following part.

E.2.3 Part 3: allocating the items to the agents

Lastly, for any bundle B j ∈ B , we arbitrarily choose two agents i 1 , i 2 ∈ N and allocate them the items in B j as formally described in Algorithm 7. Recall that in the imaginary assignment of B j to each agent i ∈ { i 1 , i 2 } , the items in B j are divided into internal items ⋃ l ∈ [ k i ] C I i,l and external items { t i, 0 , . . . , t i,k i } . Let E = { e ∗ 1 , . . . , e ∗ | E | } contain all external items shared by i 1 and i 2 . Note that e ∗ 1 = t i 1 , 0 = t i 2 , 0 . We allocate the items in B j to agents i 1 and i 2 in | E | rounds. In each round q ∈ [ | E | ] , we first find the machines of i 1 and i 2 to which the shared external items e ∗ q and e ∗ q +1 are assigned (denoted by l 1 , l 2 , l ′ 1 and l ′ 2 , respectively. If q = | E | , simply let l ′ 1 = k i 1 and l ′ 2 = k i 2 ). We then find the agent i k ∈ { i 1 , i 2 } whose machine l k +1 has more internal items. We allocate i k her internal items from machine l k +1 to machine l ′ k , and allocate the other agent i k 's external items from machine l k to machine l ′ k -1 .

Since 2 · d = 2 · ⌊ n 2 ⌋ ≤ n , no more than n agents are needed to allocate all items. Thus to prove Theorem 4, it remains to show that each agent can assign her allocated items to her machines such that the total workload on each of the machines does not exceed its capacity.

Algorithm 7 Allocating the items to the agents

Proof of Theorem 4. Consider any bundle B j ∈ B and assume the two chosen agents are i 1 , i 2 ∈ N . We first look at the first round of the process of allocating the items in B j to i 1 and i 2 . Without loss of generality, assume that the first machine of i 1 contains more internal items than that of i 2 , i.e., C I i 1 , 1 ≥ C I i 2 , 1 . From the algorithm, the items i 1 takes are ⋃ l ′ 1 l =1 C I i 1 ,l . By the second property of the imaginary assignment, these items can be assigned to the first l ′ 1 machines of i 1 such that the total workload on each machine does not exceed its capacity. Besides, the items i 2 takes are ⋃ l ′ 1 -1 l =0 t i 1 ,l , which are e ∗ 1 and a subset of ⋃ l ′ 2 l =2 C I i 2 ,l . By the second and third properties of the imaginary assignment, these items can be assigned to the first l ′ 2 machines of i 2 such that the total workload on each machine does not exceed its capacity. The same reasoning can be applied to all following rounds. By induction, it follows that both i 1 and i 2 can assign their allocated items to their machines such that the total workload on each machine does not exceed its capacity. This means that both i 1 and i 2 receive costs no more than their 1-out-ofd MMS, which completes the proof.

For the multiplicative relaxation of MMS, by Theorem 4 and Observation 1, a ⌈ n ⌊ n 2 ⌋ ⌉ -MMS allocation is guaranteed. As the bin packing setting, after a slight modification, Algorithm 5 computes a 2-MMS allocation, which is better than ⌈ n ⌊ n 2 ⌋ ⌉ -MMS.

Proof of Corollary 3. We show that by replacing the value of d with n , Algorithm 5 computes a 2 -MMS allocation. Particularly, in the new version of Algorithm 5, we partition the items in M into n bundles in a round-robin fashion and allocate each of the n bundles to one agent in N . By the properties of the imaginary assignment, for each agent, the makespan of processing either the internal items or the external items in her bundle using her machines does not exceed MMS n i . This implies that for each agent, the cost of her bundle does not exceed 2 · MMS n i , which completes the proof.

F Proportionality up to one or any item

We now discuss two other relaxations for proportionality, i.e., proportional up to one item (PROP1) and proportional up to any item (PROPX), which are also widely studied for additive costs.

Definition 2 ( α -PROP1 and α -PROPX) An allocation A = ( A 1 , . . . , A n ) is α -approximate proportional up to one item ( α -PROP1) if v i ( A i \{ e } ) ≤ α · v i ( M ) n for all agents i ∈ N and some item e ∈ A i . It is α -approximate proportional up to any item ( α -PROPX) if v i ( A i \{ e } ) ≤ α · v i ( M ) n for all agents i ∈ N and any item e ∈ A i . The allocation is PROP1 or PROPX if α = 1 .

It is easy to see that a PROPX allocation is also PROP1. Although exact PROPX or PROP1 allocations are guaranteed to exist for additive costs, when the costs are subadditive, no algorithm can be better than n -PROP1 or n -PROPX. Consider an instance with n agents and n +1 items. The cost function is v i ( S ) = 1 for all agents i ∈ N and any non-empty subset S ⊆ M . Clearly, the cost function is subadditive since v i ( S ) + v i ( T ) ≥ v i ( S ∪ T ) for any S, T ⊆ M . By the pigeonhole principle, at least one agent i receives two or more items in any allocation of M . After removing any item e ∈ A i , A i is still not empty. That is, v i ( A i \{ e } ) = 1 = n · v i ( M ) n for any e ∈ A i . This example can be easily extended to the bin packing and job scheduling settings, and thus we have the following theorem.

Theorem 5 For the bin packing and job scheduling settings, no algorithm performs better than n -PROP1 or n -PROPX.

Proof. For the bin packing setting, consider an instance with n agents and n +1 items. The capacity of each agent's bins is 1, i.e, c i = 1 for all i ∈ N . Each item is very tiny so that every agent can pack all items in just one bin, e.g., s i,j = 1 n +1 for any i ∈ N and e j ∈ M . Therefore, we have v i ( M ) = 1 and PROP i = 1 n for each agent i ∈ N . By the pigeonhole principle, at least one agent i receives two or more items in any allocation of M . After removing any item e ∈ A i , agent i still needs one bin to pack the remaining items. Hence, we have v i ( A i \{ e } ) = 1 = n · PROP i for any e ∈ A i .

For the job scheduling setting, consider an instance with 2 n agents and 2 n +1 items where each agent possesses 2 n machines with the same speed of 1, and the size of each item is 1 for every agent. It can be easily seen that for every agent i ∈ N , the maximum completion time of her machines is minimized when assigning two items to one machine and one item to each of the remaining 2 n -1 machines. Therefore, we have v i ( M ) = 2 and PROP i = 2 2 n = 1 n for any i ∈ N . Similarly, by the pigeonhole principle, at least one agent i receives two or more items in any allocation of M . This implies that v i ( A i \{ e } ) = 1 = n · PROP i for any e ∈ A i , thus completing the proof.

Peer reviews:
comments: SUMMARY:
This paper studies the allocation of m indivisible chores among n agents with non-additive preferences. The authors show that, for the case of approximate MMS, the best approximation factor is super constant, and specifically they give a lower bound of min{n, log m/ log log m } for submodular costs, and an upper bound of min{n, log m} for subadditive costs. The lower bound also implies a negative result for 1-out-of-d MMS allocations in this setting.
The authors proceed to study special cases of subadditive costs, and specifically costs encoded by combinatorial problems, and namely bin-packing and job scheduling. So, for example, in the case of bin-packing, the cost for a subset of items is the minimum number of bins to pack them. For both cases, the authors give an algorithm for finding a 1-out-of-(n/2) MMS allocation.

STRENGTHS:
- The paper studies an interesting, natural problem: chore allocation beyond additive costs.
- The results are relatively complete, and the authors settle, up-to-constants, all their questions.

WEAKNESSES:
- The main algorithmic results (for bin-packing and scheduling) seem like twists to the standard approximation algorithms (e.g., Next Fit or Best Fit for bin-packing). Of course, this is expected, but these connections/insights are not explicit in the text, so it’s harder to see what’s new about this work.

(Some typos:
Line 134: “which is somehow the most unfair algorithm” -> drop “somehow”.
Line 342: “or the job scheduling setting, we restrict us on the case”)

QUESTIONS:
Have combinatorial values of this nature (and as a tool for bypassing negative results) been considered in the goods case?

LIMITATIONS:
N/A
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 4
DATE: 2023-06-22

comments: SUMMARY:
This paper studies the MMS fair allocation of combinatorial tasks (indivisible chores) problem where the cost function is submodular or subadditive. For submodular functions, they prove that no algorithm can ensure better than min{n, log m/log log m}-approximation. For more general subadditive cost functions, they prove that there always exists an allocation that is min{n , log m}-approximation MMS, which is (almost) asymptotically tight. What’s more, for ordinal relaxation, 1-out-of-d MMS, they prove that for any d≥2, there is an instance for which no allocation is 1-out-of-d MMS. Finally, the authors give two specific settings which are bin packing setting and job scheduling setting and prove that 1-out-of-[n/2] MMS allocations always exist for these two settings.

STRENGTHS:
This paper provides solid and clean theoretical results on MMS chores allocations. It also contains some interesting techniques. For example, the author gives a quite interesting example for Theorem 1, and I also find the proof of Theorem 2 mathematically natural and complete.

WEAKNESSES:
I do not find any obvious weaknesses. Perhaps the relevance of this paper to machine learning is not very strong.

QUESTIONS:
No question.

LIMITATIONS:
Not applicable.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2023-07-05

comments: SUMMARY:
The paper deals with problem of allocating indivisible chores to agents whose valuation functions for bundles of chores are subadditive or submodular, where an allocation that guarantees every agent their maximin share (MMS) may not exist. Here, an agent's maximin share is the agent's worst-case disutility from a partitioning of the items that minimizes the disutility of the worst (maximum disutility) partition. The paper provides new upper and lower bounds on the approximability of MMS allocations.

I have reviewed a previous version of this paper submitted to IJCAI 23 where I was positive about the technical contributions of the paper. This revision addresses the concerns with writing and a minor technical issue raised there. The revisions have certainly helped with the readability.

STRENGTHS:
The problem setting of subadditive and submodular (dis)utility functions is novel. 

The new results for these classes of valuation functions provided is this paper are likely to be of interest to the comsoc / fair division research community.

The technical results are interesting, non-trivial and use interesting techniques that are new to me. I was able to verify the technical results.

Relevant related work is well cited and discussed.

WEAKNESSES:
The relevance to NeurIPS for what seems a very AI/computational social choice focused paper is not clear although this is attempted in the introduction.

QUESTIONS:
None

LIMITATIONS:
None
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2023-07-05

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper studies the classical fair allocation of indivisible items setting with two twists: (1) Items correspond to *tasks* instead of *goods*, i.e., any agent would prefer receiving no item at all. (2) Valuations are not additive but may be subadditive. The paper also considers some special cases of subadditive valuations, namely, submodular, \"bin packing\", and \"scheduling\" costs. As an objective, the paper focusses on the classic notion of the maximin share (MMS). Since MMS allocations do not always exist, the paper considers both a multiplicative as well as an \"ordinal\" relaxation of the MMS notion. \n\nThe contribution of the paper is threefold (I am omitting the ordinal approximation results for simplicity): (1) For the subadditive case, the paper presents a lower bound of $\\min\\{n,log(m)/loglog(m)\\}$ as well as a mechanism providing an approximation of $\\min\\{n,\\log(m)\\}$. (2) For bin packing, the paper presents a multiplicative $2$-approximation and a tight lower bound of $2$ for any mechanism. (3) For job scheduling, the paper presents a mechanism providing a multiplicative $2$-approximation, however, without a matching lower bound.\n\nSTRENGTHS:\n- The paper makes significant progress within the classic setting of fair allocation of indivisible items. While this literature has been long focussed on the case of additive valuations/costs, in recent years there has been a growing body of literature studying more general valuations/costs, with the paper under review being one of these. Hence, I am optimistic that the paper will lead to follow-up work. \n- The paper develops new mechanisms that are tailored to the studied cost functions. These mechanisms and their analysis is certainly non-trivial and lead to a significant technical contribution.\n\nWEAKNESSES:\n- Since the result for the general, subadditive case is rather negative (i.e., there is no constant approximation for MMS), the main contribution of the paper is for the special cases of bin packing and scheduling. Having said this, this can hardly be seen as a critique for the paper, but rather as a sign of the challenging endeavor to study beyond additive costs. \n- I think that the writing of the paper could be improved, as I had to reread several parts of the paper. I added a list of suggestions within the minor comments. \n- Unfortunately, the newly developed mechanism is not very elegant, and one can't help but wonder whether there exists a simpler mechanism to achieve the same approximation guarantee. Also, the mechanisms do not come with a polynomial-time implementation, hence, leaving the question open whether the same guarantees can be achieved efficiently. \n\n**Minor Comments**\n- The paper uses the term \"tasks\", while a large fraction of the literature uses the term \"chores\". I would suggest to add a comment on that. \n- line 21: You mention \"functions\" without clarifying their role in the problem. (Of course this is clear for any person knowing fair allocation, but for others it may not.)\n- line 60: \"As far as we know, all the above works also assume additive costs\" - Sounds a bit weird in this context, since checking these papers should be doable. \n- line 71: \"the asymptotically tight multiplicative\" - I think it is weird to use this phrase in a theorem environment, especially since you are ignoring log-factors. I would suggest to just mention the upper and lower bounds. \n- line 99: \"Note that no bounded approximation\" - At this point, it is not clear what should be approximated. \n- Proof of theorem 1: I was very confused of the usage of the term \"covering planes\" since, as far as I understand, these objects are actually (partial) grids, i.e. finite set of points. \n- line 214: I think it would be helpful for the reader to learn about the meaning of the abbreviation \"IDO\". \n- line 228-236: I did not find the intuition for the algorithm very helpful before reading the algorithm (and even after that). I would suggest to refine this, having in mind that the reader has not read the algorithm at this point. \n- line 316: I think that $j \\in P_i$ is a bad choice for an index since here $j$ is a machine but before $j$ used to correspond to jobs/items. \n- Section 5: It would have been nice to hear some (very brief) summary of how Theorem 4 is achieved, i.e., how does the mechanism look like?\n\nQUESTIONS:\n-  Intuitively, subadditive costs make the problem \"easier\" in the sense that allocation all tasks to one agent at least has the same approximation guarantee as in the additive case. This is certainly not the case for superadditive cost functions. Do you have any results in this direction? \n- I was missing a concrete (real-world) motivation for subadditive cost functions in the context of allocation tasks. Could you elaborate on that?\n\nLIMITATIONS:\nThe limitations of the paper are well addressed, in particular, within Section 6. Here, the paper transparently communicates all resulting open questions.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-05"}