SlowGuess/NeurIPS_2023_OCR huggingface dataset:
We say an item  $e_j \in 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} > \frac{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 \in M : s_{i,j} > \frac{c_i}{2}\}$  and  $L_i = \{e_j \in M : s_{i,j} \leq \frac{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  $\mathsf{MMS}_i^d \cdot d$ ; that is,  $|H_i| \leq \mathsf{MMS}_i^d \cdot d$ .
We apply a widely-used reduction [13, 28] to restrict our attention on identical ordering (IDO) instances where  $s_{i,1} \geq \dots \geq s_{i,m}$  for all  $i$ . Specifically, it means that any algorithm that ensures  $\alpha$ -approximate 1-out-of-  $d$  MMS allocations for IDO instances can be converted to compute  $\alpha$ -approximate 1-out-of-  $d$  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.
Next, we elaborate on the algorithm that proves Theorem 3.
Theorem 3 A 1-out-of-  $\lfloor \frac{n}{2} \rfloor$  MMS allocation always exists for any bin packing instance.
Let  $d = \lfloor \frac{n}{2} \rfloor$ . 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-of-  $d$  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 \in [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
Note that although the value of  $v_{i}(S)$  also depends on  $c_{i}$ , to simplify the notations, we let the subscript  $i$  absorb  $c_{i}$  and neglect an extra parameter in  $v_{i}(\cdot)$ .
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+2d}, \ldots$ ), 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.
Algorithm 2 Partitioning the items into  $d$  bundles.
Input: An IDO bin packing instance  $(N,M,\{v_{i}\}_{i\in N},\{s_{i}\}_{i\in N})$    
Output: A  $d$  -partition of the items  $\mathbf{B} = (B_1,\dots ,B_d)$  and disjoint sets of selected agents  $\mathbf{G} =$ $(G_{1},\ldots ,G_{d})$  1: Initialize  $L_{i}\gets \{e_{j}\in M:s_{i,j}\leq \frac{c_{i}}{2}\}$  for each  $i\in N$  , and  $R\gets M$  2: for  $j = 1$  to  $d$  do 3: Initialize  $B_{j}\gets \emptyset ,G_{j}\gets \emptyset ,t\gets j.$  4:  $N(B_j)\gets \{i\in N:s_i(B_j)\leq \frac{s_i(M)}{d}$  and  $L_{i}\cap R\neq \emptyset \}$  // Candidate agents 5: while  $e_t\in R$  and there exists an agent  $i\in N$  who thinks  $e_t$  is large do 6:  $B_{j}\gets B_{j}\cup \{e_{t}\} ,R\gets R\setminus \{e_{t}\} ,t\gets t + d.$  7:  $G_{j}\gets \{i\}$  8: end while 9: if  $|N(B_j)| = 1$  and  $N(B_j)\neq G_j$  then 10: Pick  $i\in N(B_j),G_j\gets G_j\cup \{i\}$  11: end if 12: while  $|N(B_j)|\geq 2$  do 13: Pick  $i_1,i_2\in N(B_j),G_j\gets \{i_1,i_2\}$  . 14: Pick the smallest item  $e\in R,B_j\gets B_j\cup \{e\} ,R\gets R\setminus \{e\} .$  15: if  $|N(B_j)| = 1$  and  $N(B_j)\nsubseteq G_j$  then 16: Pick  $i\in N(B_j)$  and replace one arbitrary agent in  $G_{j}$  with agent i. 17: end if 18: end while 19:  $N\gets N\backslash G_j$  20: end for
The way we establish the bag and select the agents makes the following two important properties satisfied for every round  $j \in [d]$ .
- Property 1: for each selected agent  $i \in G_j$ , there are at most  $\mathsf{MMS}_i^d$  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 \setminus \{e_j^*\}) \leq \frac{s_i(M)}{d}$ .
- Property 2: for each remaining agent  $i'$  (i.e.,  $i' \notin \bigcup_{l \in [j]} G_l$ ), either  $s_{i'}(B_j) > \frac{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}, \ldots\}$  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 \cdot \mathsf{MMS}_i^d$  large items for every agent  $i$ , the bag contains at most  $\mathsf{MMS}_i^d$  of  $i$ 's large items. There are two cases where  $e_j^*$  is small for an agent  $i \in G_j$ . First,  $i$  is the only candidate agent after  $e_j^*$  is added, for which case, we have  $s_i(B_j) \leq \frac{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 \setminus \{e_j^*\}) \leq \frac{s_i(M)}{d}$ . In both cases,  $s_i(B_j \setminus \{e_j^*\}) \leq \frac{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) \setminus G_j = \emptyset$ ), and all unallocated large items in  $\{e_j, e_{j+d}, \ldots\}$  are put into the bag in the bag initialization procedure.
Property 1 ensures that the items in each bundle  $B_{j} \in \mathbf{B}$  can be allocated to the selected agents in  $G_{j}$ , such that each agent  $i \in G_{j}$  can use no more than  $\mathrm{MMS}_i^d$  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) \cdot 2 \geq 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 \in [d - 1]$  and any remaining agent  $i'$ , we have  $s_{i'}(B_j) > \frac{s_{i'}(M)}{d}$ . This gives that the total size of the unallocated items to  $i'$  is smaller than  $\frac{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} \in \mathbf{B}$  to the selected agents in  $G_{j}$ . Let  $i$  be any agent in  $G_{j}$  and  $B_{j}' = B_{j} \setminus \{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}' \setminus J_{i}(B_{j}')$  the other items in  $B_{j}'$ .
Figure 1: Imaginary assignment of  $B_{j}^{\prime}$  to agent  $i$ 's bins
If all items in  $B_{j}$  are large for some agent  $i \in 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}^{\prime})$  and allocate  $i_{2}$  the items in  $J_{i_{1}}(B_{j}^{\prime}) \cup \{e_{j}^{*}\}$ .
Now we are ready to prove Theorem 3.
Proof of Theorem 3. Consider any round  $j \in [d]$ . If all items in  $B_{j}$  are large for some agent  $i \in G_{j}$ , by Property 1, we know that there are at most  $\mathsf{MMS}_i^d$  items in  $B_{j}$ . Thus  $i$  can pack all items in  $B_{j}$  using no more than  $\mathsf{MMS}_i^d$  bins.
For the other case, recall that the agent  $i_1 \in 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') \cup \{e_j^*\}$ . We first discuss agent  $i_1$ . By Property 1, we know that for each agent  $i \in \{i_1, i_2\}$ , there are at most  $\mathsf{MMS}_i^d$  large items in  $B_j'$  and  $s_i(B_j') \leq \frac{s_i(M)}{d}$ . These two facts imply that in the imaginative assignment of  $B_j'$  to  $i_1$ , no more than  $\mathsf{MMS}_{i_1}^d$  bins are used. Since otherwise,  $s_{i_1}(B_j') > \mathsf{MMS}_{i_1}^d \cdot c_{i_1} \geq \frac{s_{i_1}(M)}{d}$ , a contradiction. Therefore,  $i_1$  can pack all items in  $W_{i_1}(B_j')$  using no more than  $\mathsf{MMS}_{i_1}^d$  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
Algorithm 3 Computing 2-MMS allocations for the bin packing setting
Input: An IDO bin packing instance  $(N,M,\{v_{i}\}_{i\in N},\{s_{i}\}_{i\in N})$    
Output: An allocation  $\mathbf{A} = (A_1,\dots ,A_n)$  such that  $v_{i}(A_{i})\leq 2\cdot \mathrm{MMS}_{i}$  for all  $i\in N$  1: Initialize  $R\gets M$    
2: for  $j = 1$  to  $n$  do   
3: Initialize  $B_{j}\gets \emptyset ,t\gets j,k\gets$  an arbitrary agent in  $N$    
4: while  $e_t\in R$  and there exists an agent  $i\in N$  who thinks  $e_t$  is large do   
5:  $B_{j}\gets B_{j}\cup \{e_{t}\} ,R\gets R\setminus \{e_{t}\} ,t\gets t + n.$    
6:  $k\gets i$    
7: end while   
8: while there exists an agent  $i\in N$  that satisfies  $s_i(B_j)\leq \frac{s_i(M)}{n}$  and  $L_{i}\cap R\neq \emptyset$  do   
9:  $k\gets i$    
10: Pick the smallest item  $e\in R,B_j\gets B_j\cup \{e\} ,R\gets R\setminus \{e\}$    
11: end while   
12:  $A_{k}\gets B_{j},N\gets N\setminus \{k\}$    
13: end for
$s_{i_2}(J_{i_1}(B_j')) \leq \frac{s_{i_2}(B_j')}{2} \leq \frac{s_{i_2}(M)}{2d}$ . Combining with the fact that there are at most  $\mathsf{MMS}_{i_2}^d$  large items in  $B_j'$  for  $i_2$ , we know that  $i_2$  can use no more than  $\mathsf{MMS}_{i_2}^d$  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')) > \mathsf{MMS}_{i_2}^d \cdot \frac{c_{i_2}(M)}{2} \geq \frac{s_{i_2}(M)}{2d}$ , 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') \cup \{e_j^*\}$  using at most  $\mathsf{MMS}_{i_2}^d$  bins, which completes the proof.
For the multiplicative relaxation of MMS, by Theorem 3 and Observation 1, a  $\lceil \frac{n}{\lfloor \frac{n}{2} \rfloor} \rceil$ -MMS allocation is guaranteed. Actually, we can slightly modify Algorithm 2 to compute a 2-MMS allocation.
Corollary 2 A 2-MMS allocation always exists for any bin packing instance.
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., Subsections 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 \in N$ , there are at most  $\mathrm{MMS}_i$  large items in  $A_i$ . Besides, if the last item  $e_i^*$  is small for  $i$ , we have  $s_i(A_i \setminus \{e_i^*\}) \leq \frac{s_i(M)}{n}$ . Again, in the imaginary assignment of  $A_i \setminus \{e_i^*\}$  to  $i$ , no more than  $\mathrm{MMS}_i$  bins are used and at least one of them does not have an extra item. Therefore, agent  $i$  can use  $\mathrm{MMS}_i$  bins to pack all items in  $W_i(A_i \setminus \{e_i^*\})$  and another  $\mathrm{MMS}_i$  bins to pack all items in  $J_i(A_i \setminus \{e_i^*\}) \cup \{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  $\frac{3}{2} \mathrm{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 \in M$  has a size  $s_{i,j} \geq 0$  to each agent  $i \in N$ , and for a set of items  $S \subseteq M$ ,  $s_i(S) = \sum_{e_j \in S} s_{i,j}$ . As the bin packing setting, we only consider IDO instances where  $s_{i,1} \geq \dots \geq s_{i,m}$  for all  $i$ . Each agent  $i \in N$  exclusively controls a set of  $k_i$  machines  $P_i = [k_i]$  with possibly different speed  $\rho_{i,l}$  for each  $l \in P_i$ . Without loss of generality, we assume  $\rho_{i,1} \geq \dots \geq \rho_{i,k_i}$ . Upon receiving a set of items  $S \subseteq 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,
$$
v_{i}(S) = \min_{(T_{1},\dots ,T_{k_{i}})\in \Pi_{k_{i}}(S)}\max_{l\in [k_{i}]} \frac{\sum_{e_{t}\in T_{l}}s_{i,t}}{\rho_{i,l}}.
$$
Note that the computation of  $v_{i}(S)$  is NP-hard if  $k_{i} \geq 2$ . For any two sets  $S_{1}$  and  $S_{2}$ ,  $v_{i}(S_{1} \cup S_{2}) \leq v_{i}(S_{1}) + v_{i}(S_{2})$  since the makespan of scheduling  $S_{1} \cup S_{2}$  is no larger than the sum of the makespans of scheduling  $S_{1}$  and  $S_{2}$  separately, thus  $v_{i}(\cdot)$  is subadditive.
Regarding the value of  $\mathsf{MMS}_i^d$ , intuitively, it is obtained by partitioning the items into  $d \cdot 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. 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-  $\lfloor \frac{n}{2} \rfloor$  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- $\lfloor \frac{n}{2} \rfloor$  MMS even 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- $\lfloor \frac{n}{2} \rfloor$  MMS for each agent is 4 as the 1-out-of-2 MMS defining 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-of- $d$  MMS. Our algorithm overcomes this problem by first partitioning the items into  $\lfloor \frac{n}{2} \rfloor$  bundles and then carefully allocating the items in each bundle to two agents.
Let  $d = \left\lfloor \frac{n}{2} \right\rfloor$ . For each agent  $i \in N$  and each machine  $l \in P_i$ , let  $c_{i,l} = \rho_{i,l} \cdot \mathsf{MMS}_i^d$  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-of-  $d$  MMS). We defer the detailed algorithms and proofs to Appendix E.
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, \lceil \log m \rceil\}$ -MMS allocations in the general subadditive cost setting and 1-out-of- $\lfloor \frac{n}{2} \rfloor$  MMS allocations 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  $\frac{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  $\frac{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.
The authors are ordered alphabetically. This work is funded by NSFC under Grant No. 62102333, HKSAR RGC under Grant No. PolyU 25211321, and CCF-Huawei Populus Grove Fund.
<sup>3</sup>We provide another interpretation in Appendix E.1, which shows that the job scheduling setting uncovers new research directions for group-wise fairness.
[20] 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.
[21] Jiarui Gan, Bo Li, and Xiaowei Wu. Approximation algorithm for computing budget-feasible EF1 allocations. In AAMAS, pages 170-178. ACM, 2023.
[22] Jugal Garg and Setareh Taki. An improved approximation algorithm for maximin shares. Artif. Intell., 300:103547, 2021.
[23] 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.
[24] 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.
[25] Sonke 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.
[26] Hadi Hosseini, Andrew Sears, 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.
[27] Hadi Hosseini, Andrew Sears, and Erel Segal-Halevi. Ordinal maximin share approximation for goods. J. Artif. Intell. Res., 74, 2022.
[28] Xin Huang and Pinyan Lu. An algorithmic framework for approximating maximin share allocation of chores. In EC, pages 630-631. ACM, 2021.
[29] Xin Huang and Erel Segal-Halevi. A reduction from chores allocation to job scheduling. CoRR, abs/2302.04581, 2023.
[30] Halvard Hummel and Magnus Lie Hetland. Fair allocation of conflicting items. Auton. Agents Multi Agent Syst., 36(1):8, 2022.
[31] David Kurokawa, Ariel D. Procaccia, and Junxing Wang. When can the maximin share guarantee be guaranteed? In AAAI, pages 523-529. AAAI Press, 2016.
[32] David Kurokawa, Ariel D. Procaccia, and Junxing Wang. Fair enough: Guaranteeing approximate maximin shares. J. ACM, 65(2):8:1-8:27, 2018.
[33] Bo Li, Minming Li, and Ruilong Zhang. Fair scheduling for time-dependent resources. In NeurIPS, pages 21744-21756, 2021.
[34] Bo Li, Yingkai Li, and Xiaowei Wu. Almost (weighted) proportional allocations for indivisible chores. In WWW, pages 122-131. ACM, 2022.
[35] Richard J. Lipton, Evangelos Markakis, Elchanan Mossel, and Amin Saberi. On approximately fair allocations of indivisible goods. In EC, pages 125-131. ACM, 2004.
[36] Gé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.
[37] Baharan Mirzasoleiman, Amin Karbasi, Rik Sarkar, and Andreas Krause. Distributed submodular maximization: Identifying representative elements in massive data. In NIPS, pages 2049-2057, 2013.
[38] Hervé Moulin. Fair division in the age of internet. Annu. Rev. Econ., 2018.
[39] Benjamin Plaut and Tim Roughgarden. Almost envy-freeness with general valuations. SIAM J. Discret. Math., 34(2):1039-1068, 2020.
[40] Masoud Seddighin and Saeed Seddighin. Improved maximin guarantees for subadditive and fractionally subadditive fair allocation problem. In AAAI, pages 5183-5190. AAAI Press, 2022.
[41] Edward Lloyd Snelson and Zoubin Ghahramani. Sparse gaussian processes using pseudo-inputs. In NIPS, pages 1257-1264, 2005.
[42] Shengwei Zhou and Xiaowei Wu. Approximately EFX allocations for indivisible chores. CoRR, abs/2109.07313, 2021.
A More related works