# Ordinal Maximin Share Approximation for Goods

In fair division of indivisible goods, l-out-of-d maximin share (MMS) is the value that an agent can guarantee by partitioning the goods into d bundles and choosing the l least preferred bundles. Most existing works aim to guarantee to all agents a constant fraction of their one-out-of-n MMS. But this guarantee is sensitive to small perturbation in agents' cardinal valuations. We consider a more robust approximation notion, which depends only on the agents' ordinal rankings of bundles. We prove the existence of l-out-of-(l+1/2)n MMS allocations of goods for any integer l >= 1, and develop a polynomial-time algorithm that achieves this guarantee when l = 1.

## Authors

• 12 publications
• 3 publications
• 24 publications
• ### Guaranteeing Maximin Shares: Some Agents Left Behind

The maximin share (MMS) guarantee is a desirable fairness notion for all...
05/19/2021 ∙ by Hadi Hosseini, et al. ∙ 0

• ### Groupwise Maximin Fair Allocation of Indivisible Goods

We study the problem of allocating indivisible goods among n agents in a...
11/21/2017 ∙ by Siddharth Barman, et al. ∙ 0

• ### Best-of-Both-Worlds Fair-Share Allocations

We consider the problem of fair allocation of indivisible items among n ...
02/09/2021 ∙ by Moshe Babaioff, et al. ∙ 0

• ### Approximate and Strategyproof Maximin Share Allocation of Chores with Ordinal Preferences

We initiate the work on maximin share (MMS) fair allocation of m indivis...
12/27/2020 ∙ by Haris Aziz, et al. ∙ 0

• ### The Fair Division of Hereditary Set Systems

We consider the fair division of indivisible items using the maximin sha...
12/22/2018 ∙ by Zhentao Li, et al. ∙ 0

• ### Keep Your Distance: Land Division With Separation

This paper is part of an ongoing endeavor to bring the theory of fair di...
05/14/2021 ∙ by Edith Elkind, et al. ∙ 0

• ### Joint aggregation of cardinal and ordinal evaluations with an application to a student paper competition

An important problem in decision theory concerns the aggregation of indi...
01/12/2021 ∙ by Dorit S. Hochbaum, et al. ∙ 2

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Fair division is the study of how to distribute a set of items among a set of agents in a fair manner. Achieving fairness is particularly challenging when items are indivisible. Computational and conceptual challenges have motivated researchers and practitioners to develop a variety of fairness concepts that are applicable to a large number of resource allocation problems.111See [MoulinMoulin2019, Brandt, Conitzer, Endriss, Lang,  ProcacciaBrandt et al.2016] for detailed surveys and recent discussions. One of the most common fairness concepts, proposed by budish2011combinatorial, is Maximin Share (MMS), that aims to give each agent a bundle that is valued at a certain threshold. The MMS threshold, also known as -out-of- MMS, generalizes the guarantee of the cut-and-choose protocol. It is the value that an agent can secure by partitioning the items into bundles, assuming it will receive the least preferred bundle. The MMS value depends on the number of partitions, . When all items are goods (i.e., have non-negative values), the -out-of- MMS threshold is (weakly) monotonically decreasing as the number of partitions () increases.

When allocating goods among agents, a natural desirable threshold is satisfying -out-of- MMS for all agents. Unfortunately, while this value can be guaranteed for agents through cut-and-choose, -out-of- MMS allocations of goods may not exist in general for [Procaccia  WangProcaccia  Wang2014, Kurokawa, Procaccia,  WangKurokawa et al.2018]. These negative results have given rise to multiplicative approximations, wherein each agent is guaranteed at least a constant fraction of its 1-out-of- MMS. While there have been many attempts in developing algorithms that improve the bound to close to 1, the best currently known fraction is [Garg  TakiGarg  Taki2020].

Despite numerous studies devoted to their existence and computation, there is a conceptual and practical problem with the multiplicative approximations of MMS: they are very sensitive to agents’ precise cardinal valuations. To illustrate, suppose there are four goods and an agent, say Alice, who values them at . Her -out-of- MMS is , and thus a fraction guarantee can be satisfied by giving her the good valued at . But if her valuation of the third least valued good slightly perturbs to (for some small ), then of her -out-of- MMS is larger than , so the algorithm must give her at least the good of value . Note that a small perturbation in an irrelevant good induces a radical change in the final allocation and the values.

In the microeconomics literature, it is common to measure agent’s preferences as ordinal rankings of the bundles; even when utility functions are used, it is understood that they only represent ordinal rankings, and that any monotone transformation of a utility function corresponds to the same preferences. In accordance with this principle, budish2011combinatorial suggested the 1-out-of- MMS as an approximation to the 1-out-of- MMS. This approximation depends only on the ordinal ranking of the bundles, and thus it is not sensitive to small perturbations in the cardinal values, as long as rankings over bundles remain unchanged. Hence, it provides a more robust approach in evaluating the bundles. In the above example, an allocation satisfying -out-of- MMS guarantees Alice a bundle that is at least as good as the good valued at ; small inaccuracies or noise in the valuations will not change this guarantee, as long as the ranking of the bundles remains the same.

We aim to find allocations of goods that guarantee -out-of- MMS for some integer . The -out-of- MMS guarantees to each agent a bundle that is at least as good as the worst bundle in the best -partition. The aforementioned guarantee can be naturally generalized to -out-of- MMS [Babaioff, Nisan,  Talgam-CohenBabaioff et al.2021], that guarantees to each agent the value obtained by partitioning the goods into bundles and selecting the least-valuable ones. Therefore, we further investigate the -out-of- MMS generalization that allows us to improve the fairness thresholds, as we show in the next subsection. The notion of -out-of- MMS fairness is robust in the sense that, a fair allocation remains fair even when each agent’s utility function goes through an arbitrary monotonically-increasing transformation. Given these notions, we ask the following questions:

In the allocation of indivisible goods, (a) For what combinations of integers and , can -out-of- MMS allocations be guaranteed? and (b) For what integers and can -out-of- MMS allocations be computed in polynomial time?

### 1.1 Our Contributions

We investigate the existence and computation of ordinal MMS approximations and make the several contributions.

In Section 4, we prove the existence of -out-of- MMS allocation of goods when (Theorem 1). In particular, -out-of- MMS, -out-of- MMS, -out-of- MMS, and so on, are all guaranteed to exist. This finding generalizes the previously known existence result of -out-of- MMS [Hosseini  SearnsHosseini  Searns2021].

The proof uses an algorithm that, given lower bounds on the -out-of- MMS values of the agents, returns an -out-of- MMS allocation. The algorithm runs in polynomial time given the agents’ lower bounds. However, computing the exact -out-of- MMS values is NP-hard. In the following sections we propose two solutions to this issue.

In Section 5, we present a polynomial-time algorithm for finding a 1-out-of- MMS allocation, which is almost the case of Theorem 1, without requiring the exact MMS values (Theorem 2).

In Appendix B, we conduct simulations with valuations generated randomly from various distributions. For several values of , we compute a lower bound on the -out-of- MMS guarantee, using a simple greedy algorithm. We compare this lower bound to an upper bound on the -fraction MMS guarantee, which is currently the best known cardinal MMS approximation.222 In general, ordinal and cardinal approximations are incomparable from the theoretical standpoint—each of them may be larger than the other in some instances (see Appendix A). Therefore, we compare them through simulations using synthetic data. We find that, for any , when the number of goods is at least , the lower bound on the ordinal approximation is better than the upper bound on the cardinal approximation. This implies that, in practice, the algorithm of Section 4 can be used with these lower bounds to attain an allocation in which each agent receives a value that is noticeably better than the theoretical guarantees.

### 1.2 Techniques

At first glance, it would seem that the techniques used to attain MMS should also work for achieving -out-of- MMS allocations, since both guarantees approximate the same value — of the agent’s value for the set of all goods. In Appendix C we present an example showing that this is not the case, and thus, achieving ordinal MMS approximations requires new techniques. In this section, we briefly describe these techniques.

#### Lone Divider.

To achieve the existence result for any , we use a variant of the Lone Divider algorithm, which was first presented by kuhn1967games for finding a proportional allocation of a divisible resource (also known as a “cake”). Recently, it was shown that the same algorithm can be used for allocating indivisible goods too. When applied directly, the Lone Divider algorithm finds only an -out-of- MMS allocation [Aigner-Horev  Segal-HaleviAigner-Horev  Segal-Halevi2019], which for small is substantially worse than our target approximation of -out-of-. We overcome this difficulty by adding constraints on the ways in which the lone divider is allowed to partition the goods, as well as arguing on which goods are selected to be included in each partition (see Section 4).

#### Bin Covering.

For the polynomial-time algorithm when , we extend an algorithm of csirik1999two for the bin covering problem—a dual of the more famous bin packing problem [JohnsonJohnson1973]. In this problem, the goal is to fill as many bins as possible with items of given sizes, where the total size in each bin must be above a given threshold. This problem is NP-hard, but csirik1999two presents a polynomial-time approximation. This algorithm cannot be immediately applied to the fair division problem since the valuations of goods are subjective, meaning that agents may have different valuations of each good. We adapt this technique to handle subjective valuations.

## 2 Related Work

### 2.1 Maximin share

The idea of using the highest utility an agent could obtain if all other agents had the same preferences as a benchmark for fairness, originated in the economics literature [MoulinMoulin1990, MoulinMoulin1992]. It was put to practice in the context of course-allocation by budish2011combinatorial, where he introduced the ordinal approximation to MMS, and showed a mechanism that guarantees -out-of- MMS to all agents by adding a small number of excess goods. In the more standard fair division setting, in which adding goods is impossible, the first non-trivial ordinal approximation was 1-out-of- MMS [Aigner-Horev  Segal-HaleviAigner-Horev  Segal-Halevi2019]. hosseini2021mms studied the connection between guaranteeing 1-out-of- MMS for of the agents and the ordinal approximations for all agents. The implication of their results is the existence of -out-of- MMS allocations and a polynomial-time algorithm for . Whether or not -out-of- MMS can be guaranteed without adding excess goods remains an open problem to date.

The generalization of the maximin share to arbitrary was first introduced by babaioff2019fair,babaioff2021competitive and further studied by segal2020competitive. They presented this generalization as a natural fairness criterion for agents with different entitlements. The implication relations between -out-of- MMS-fairness guarantees for different values of and were characterized by segal2019maximin. Recently, the maximin share and its ordinal approximations have also been applied to some variants of the cake-cutting problem [Bogomolnaia  MoulinBogomolnaia  Moulin2020, Elkind, Segal-Halevi,  SuksompongElkind et al.2021].

### 2.2 Multiplicative MMS approximations

The multiplicative approximation to MMS originated in the computer science literature [Procaccia  WangProcaccia  Wang2014]. The non-existence of MMS allocations [Kurokawa, Procaccia,  WangKurokawa et al.2018] and its intractability [Bouveret  LemaîtreBouveret  Lemaître2016, WoegingerWoeginger1997] have given rise to a number of approximation techniques.

These algorithms guarantee that each agent receives an approximation of their maximin share threshold. The currently known algorithms guarantee [Kurokawa, Procaccia,  WangKurokawa et al.2018, Amanatidis, Markakis, Nikzad,  SaberiAmanatidis et al.2017, Garg, McGlaughlin,  TakiGarg et al.2018] and [Ghodsi, HajiAghayi, Seddighin, Seddighin,  YamiGhodsi et al.2018, Garg  TakiGarg  Taki2020] in general, and [Amanatidis, Markakis, Nikzad,  SaberiAmanatidis et al.2017] as well as [Gourvès  MonnotGourvès  Monnot2019] when there are only three agents. There are also MMS approximation algorithms for settings with constraints, such as when the goods are allocated on a cycle and each agent must get a connected bundle [Truszczynski  LoncTruszczynski  Lonc2020]. mcglaughlin2020improving showed an algorithm for approximating the maximum Nash welfare (the product of agents’ utilities), which also attains a fraction of the MMS.

Recently, nguyen2017approximate gave a Polynomial Time Approximation Scheme (PTAS) for a notion defined as optimal-MMS, that is, the largest value, , for which each agent receives the value of . Since the number of possible partitions is finite, an optimal-MMS allocation always exists, and it is an MMS allocation if . However, an optimal-MMS allocation may provide an arbitrarily bad ordinal MMS guarantee [Searns  HosseiniSearns  Hosseini2020].

### 2.3 Fairness based on ordinal information

An advantage of the ordinal MMS approximation is that it depends only on the ranking over the bundles. Other fair allocation algorithms with this robustness property are the Decreasing Demands algorithm of herreiner2002simple, the Envy Graph algorithm of lipton2004approximately, and the UnderCut algorithm of Brams2012Undercut.

amanatidis2016truthful,halpern2021fair study an even stronger robustness notion, where the agents report only a ranking over the items. Their results imply that, in this setting, the highest attainable multiplicative approximation of MMS is .

menon2020algorithmic define a fair allocation algorithm as stable if it gives an agent the same value even if the agent slightly changes his cardinal valuations of items, as long as the ordinal ranking of items remains the same. They show that most existing algorithms are not stable, and present an approximately-stable algorithm for two agents.

Finally, robustness has been studied also in the context of fair cake-cutting. aziz2014cake define an allocation robust-fair if it remains fair even when the valuation of an agent changes, as long as the ordinal information in it remains unchanged. edmonds2011cake study cake-cutting settings in which agents can only cut the cake with a finite precision.

## 3 Preliminaries

### 3.1 Agents and goods

Let be a set of agents and denote a set of indivisible goods. We denote the value of agent for good by . Following the common convention in fair division, we assume that the valuation functions are additive, that is, for each subset , . An instance of the problem is denoted by , where is the valuation profile of agents. We assume all agents have a non-negative valuation for each good , that is, . An allocation is an -partition of that allocates the bundle of goods in to each agent .

It is convenient to assume that the number of goods is sufficiently large. Particularly, some algorithms implicitly assume that , while some algorithms implicitly assume that . These assumptions are without loss of generality, since if in the original instance is smaller, we can just add dummy goods with a value of to all agents.

### 3.2 The maximin share

For every agent and integers , the -out-of- maximin share of from , denoted , is defined as

where the maximum is over all partitions of into subsets, and the minimum is over all unions of subsets from the partition. We say that an allocation is an -out-of--MMS allocation if for all agents , .

Obviously , and this equality holds if and only if can be partitioned into subsets with the same value. Note that for goods is a weakly-increasing function of and a weakly-decreasing function of .

The value is at least as large, and sometimes larger than, . For example, suppose , there are goods with value and one good with value . Then but .

### 3.3 The Lone Divider algorithm

A general formulation of the Lone Divider algorithm, based on [Aigner-Horev  Segal-HaleviAigner-Horev  Segal-Halevi2019], is shown in Algorithm 1. It accepts as input a general set (divisible or indivisible), and a threshold value for each agent . These values should satisfy the following condition for each agent .

###### Definition 1 (Reasonable threshold).

Given a set , a value function on , and an integer , a reasonable threshold for is a real number satisfying the following condition. For every integer and disjoint subsets , if

 ∀c∈[k]:vi(Bc)

then there exists a partition of into , such that

 ∀j∈[n−k]:vi(Mj)≥ti.

Informally, if any unacceptable subsets are given away, then can partition the remainder into acceptable subsets.

Given an instance with

, a vector

of real numbers is called a reasonable threshold vector for if is a reasonable threshold for for all .

###### Example 1 (Reasonable threshold).

Suppose is a perfectly divisible resource (such as a cake), and let . This threshold is reasonable, since if some bundles with value less than are given away, the value of the remaining resource is more than . Since the resource is divisible, it can be partitioned into acceptable subsets. This does not necessarily hold when is a set of indivisible goods; hence, finding reasonable thresholds for indivisible items setting is more challenging.

#### Algorithm Description

Algorithm 1 proceeds in the following way: in each step, a single remaining agent is asked to partition the remaining goods into acceptable bundles—bundles whose values are above the divider’s threshold. Then, all agents point at those bundles that are acceptable for them, and the algorithm finds an envy-free matching in the resulting bipartite graph.333 An envy-free matching in a bipartite graph is a matching in which each unmatched agent in is not adjacent to any matched element in . The bipartite graph generated by the Lone Divider algorithm always admits a nonempty envy-free matching, and a maximum-cardinality envy-free matching can be found in polynomial time [Aigner-Horev  Segal-HaleviAigner-Horev  Segal-Halevi2019]. The matched bundles are allocated to the matched agents, and the algorithm repeats with the remaining agents and goods. It is easy to see that, if all threshold values are reasonable, then Lone Divider guarantees agent a bundle with a value of at least . For example, when is a divisible resource, is a reasonable threshold for every , so the Lone Divider algorithm can be used to attain a proportional cake-cutting [KuhnKuhn1967].

When is a set of indivisible goods, is a reasonable threshold for every [Aigner-Horev  Segal-HaleviAigner-Horev  Segal-Halevi2019], so these ordinal approximations can all be computed directly through the Lone Divider algorithm. However, directly applying the Lone Divider algorithm cannot guarantee a better ordinal approximation, as we show next.

###### Example 2 (Execution of Algorithm 1).

For simplicity, we present an example for . We show that, while Algorithm 1 can guarantee -out-of- MMS, it cannot guarantee -out-of- MMS. Suppose that there are goods, and that all agents except the first divider value some goods at and the other goods at (see Figure 1). Then the 1-out-of- MMS of all these agents is .

However, it is possible that the first divider takes an unacceptable bundle containing all goods of value . Then, no remaining agent can partition the remaining goods into bundles of value at least . In this instance, it is clear that while is a reasonable threshold, is not.

## 4 Ordinal Approximation of MMS for Goods

In this section we prove the following theorem.

###### Theorem 1.

Given an additive goods instance, an -out-of- MMS allocation always exists when .

We present an algorithm (Algorithm 2) for achieving the above MMS bound. Since the algorithm requires to know the exact MMS thresholds for each agent (which is NP-hard to compute), it does not run in polynomial time. Thus, we provide a constructive proof for the existence of such allocations. In Section 5 we present a different algorithm to compute -out-of- MMS allocation when in polynomial-time.

Our algorithm starts with several normalization and ordering steps, some of which appeared in previous works and some are specific to our algorithm. For completeness, we describe each of the normalization steps below.

### 4.1 Normalization

We start by scaling the valuations such that for each agent . Then, for each we perform an additional normalization as follows.

• Consider a particular -partition attaining the maximum in the definition. Call the bundles in this partition the MMS bundles of agent .

• Denote the total value of the least-valuable MMS bundles by (or just , when is clear from the context). By definition, the value of the -th MMS bundle must be exactly , while the values of the other MMS bundles are at least .

• For each MMS bundle with value larger than , arbitrarily pick one or more goods and decrease their value until the value of the MMS bundle becomes exactly . Note that this does not change the MMS value.

After the normalization, the sum of values of all goods is

 vi(M)= (d−ℓ+1)⋅(ℓ−xi)+xi = ℓ+(d−ℓ)(ℓ−xi)=d+(d−ℓ)(ℓ−1−xi).

Since ,

 vi(M)≥ (ℓn+n/2−1/2)+(ℓn+n/2−1/2−ℓ)(ℓ−1−xi) = n⋅ℓ  +  (n−1)⋅ℓ(ℓ−1−xi)  +  (n−1)⋅(ℓ−xi)/2. (1)

The goal of the algorithm is to give each agent a bundle with . We say that such a bundle is acceptable for .

###### Example 3 (Normalization).

To illustrate the parameter , consider the following two instances with and .

1. There are goods with the value of .

2. There are goods valued and one good with the value of .

Here, each MMS bundle contains a single good. In both cases, the value of every goods is at least . In the first case and the total value is . In the second case, and the total value is .

### 4.2 Ordering the instance

As in previous works [Bouveret  LemaîtreBouveret  Lemaître2016, Barman  Krishna MurthyBarman  Krishna Murthy2017, Garg, McGlaughlin,  TakiGarg et al.2018, Huang  LuHuang  Lu2021], we apply a preliminary step in which the instance is ordered, i.e., for each agent . Ordering is done as follows:

• Index the goods in arbitrarily .

• Tell each agent to adopt, for the duration of the algorithm, a modified value function that assigns, to each good , the value of the -th most valuable good according to . For example, the new should be the value of ’s most-valuable good; the new should be the value of ’s least-valuable good; etc. Ties are broken arbitrarily.

During the execution of the algorithm, each agent answers all queries according to this new value function. For example, an agent asked whether the bundle is acceptable, should answer whether the bundle containing his best item, 4th-best item and 5th-best item is acceptable. Once the algorithm outputs an allocation, it can be treated as a picking sequence in which, for example, an agent who receives the bundle has the first, fourth and fifth turns. It is easy to see that such an agent receives a bundle that is at least as good as the bundle containing her best, 4th-best and 5th-best items. Hence, if the former is acceptable then the latter is acceptable too.

Clearly, given an unordered instance, its corresponding ordered instance can be generated in polynomial time (for each agent , we need steps for ordering the valuations). Given an allocation for the ordered instance, one can compute the allocation for the corresponding unordered instance in linear time, using the picking-sequence described above. Moreover, the unordering process—as described above—has relatively low communication requirements, as it does not require the agents to report their valuations to the social planner; they only need to pick the best item in their turn among available goods.

### 4.3 Restricted Lone Divider

As shown in subsection 3.3, the plain Lone Divider algorithm (Algorithm 1) cannot guarantee a better ordinal approximation than -out-of-. However, we can improve its performance by restricting the partitions that the lone divider is allowed to make in Step 1 of Algorithm 1.

For every , denote . In other words, contains the most-valuable goods; contains the next most-valuable goods; and so on. Recall that the instance is ordered, so these sets are the same for all agents.

###### Definition 2 (ℓ-balanced bundle).

Given an ordered instance and an integer , a nonempty bundle is called -balanced if

• contains exactly one good from .

• If , then contains exactly one good from .

• If , then contains exactly one good from .

• If , then contains exactly one good from .

Algorithm 2 requires the lone divider to construct a partition in which all bundles are -balanced.

###### Example 4 (ℓ-balanced bundles).

Suppose there are five agents () and goods, where the value of each good is precisely for all agents. Then, a -balanced bundle must contain a good ; a -balanced bundle must contain a good from and a good from ; a -balanced bundle must contain, in addition to these, a good from ; and so on.

### 4.4 Construction for a single divider

In order to prove the correctness of Algorithm 2, it is sufficient to prove that the threshold value is a reasonable threshold (see Definition 1) for each agent , with the additional restriction that all bundles should be -balanced.

To do this, it is sufficient to consider a single divider, Alice. We denote her normalized ordered value measure by , and the sum of her least-valuable MMS bundles by . We consider a particular MMS partition for Alice, and refer to the bundles in this partition as the MMS bundles.

Assume that unacceptable bundles have already been given to other agents and that all these bundles are -balanced. Therefore, for each , it must be that .444 Recall that the Lone Divider algorithm allocates bundles using an envy-free matching. This means that all bundles allocated before Alice’s turn are unacceptable to Alice. We have to prove that Alice can use the remaining goods to construct acceptable bundles that are also -balanced. Particularly, in what follows we prove that Alice can construct acceptable bundles, each of which contains exactly remaining good from each of .

### 4.5 Main idea: bounding the waste

Given a bundle , denote its waste by . This is the value the bundle contains beyond the acceptability threshold of . Note that the waste of acceptable bundles is positive and that of unacceptable bundles is negative. The total initial value for Alice is given by (1). The total waste she can afford in her partition is therefore

 v(M)−n⋅ℓ=(n−1)⋅(ℓ−x)/2+(n−1)⋅ℓ(ℓ−1−x).

The first term implies that she can afford an average waste of for bundles; the second term implies that she can afford an average waste of for bundles.

###### Example 5 (Bounding the waste).

Consider Example 3. In case (1), the total value is and we need bundles with a value of , so the affordable waste is . The average over bundles is . In case (2), the total value is , so the affordable waste is . The average over bundles is . In both cases, if there are acceptable bundles with that amount of waste, then the remaining value is exactly , which is sufficient for an additional acceptable bundle.

The following lemma formalizes this observation.

###### Lemma 1.

Suppose there exists a partition of into

• Some bundles with an average waste of at most ;

• A subset of remaining goods, with .

Then .

###### Proof.

For brevity, we denote and . The total value of the bundles equals their number times their average value. So the total value of the bundles is at most . After adding for the remaining goods, the sum equals , so

 (t+1)⋅ℓ+t⋅w1+t⋅w2>v(M).

Assume for contradiction that . Then the above inequality implies:

 n⋅ℓ+(n−1)⋅w1+(n−1)⋅w2>v(M)

However, by (1),

 v(M)≥n⋅ℓ+(n−1)⋅w1+(n−1)⋅w2,

###### Remark 1.

The value of each MMS bundle is at most . Therefore, any bundle that contains exactly such MMS bundles has a waste of at most and thus it satisfies the upper bound of Lemma 1. In particular, this is satisfied for every bundle with at most goods.

Below we show how Alice can find a partition in which the average waste is upper bounded as in Lemma 1. This partition will consist of the following bundles:

• The previously-allocated bundles;

• Some newly-constructed bundles with at most goods;

• Some newly-constructed bundles with waste at most ;

• Some pairs of bundles, where the waste in one is larger than but the waste in the other is smaller than , such that the average is at most .

### 4.6 Step 0: Handling bundles with at most ℓ goods

Recall that before Alice’s turn, some bundles have been allocated, with a value of less than . Hence, their waste is less than . Some of them contain or more goods: such bundles must, by the restriction on the previous dividers, contain exactly one good from each of .

But some of these bundles may contain less than goods. To simplify and unify the arguments to follow, we would like to ensure that all these bundles contain at least goods. To each such bundle with goods, Alice adds a good from each of , such that it contains exactly goods. By Remark 1, the waste of each such bundle is at most , which satisfies the upper bound of Lemma 1.

Now, for each , the bundle contains exactly good from each of . Therefore, exactly goods are available in each of .

Next, Alice checks all the -tuples containing one good from each of (starting from the highest-valued goods in each set). If the value of such an -tuple is at least , then it is acceptable and its waste is at most .

After Step 0, there are some bundles with a waste of at most , each of which contains exactly one good from each of . Of these, are previously-allocated bundles, and are newly-constructed acceptable bundles. In each of , there remain exactly goods. The total value of each -tuple of remaining goods from is less than . Alice will now construct from them some bundles with an average waste of at most .

Lemma 1 implies the following lemma on the remaining goods (the goods not in these bundles):

###### Lemma 2.

Suppose there exists a partition of the remaining goods into

• Some bundles with an average waste of at most ;

• A subset of remaining goods, with .

Then .

Alice’s strategy branches based on the number of high-value goods.

### 4.7 High-value goods

We define high-value goods as goods with . Denote by the number of high-valued goods in . Since the instance is ordered, goods are high-valued. All MMS bundles are worth at most , and therefore may contain at most one high-value good each. Since the number of MMS bundles is , we have .

For each , we denote

• := the MMS bundle containing . Since the value of all MMS bundles is at most , each MMS bundle contains at most one high-value good, so the are all distinct.

• := the remainder set of , i.e., the set .

• .

We consider three cases, based on the number of high-value goods.

#### Case #1: h≤ℓn.

This means that all high-value goods are contained in , so after removing , at most high-value goods remain — at most in each of . Alice constructs the required bundles by bag-filling — a common technique in MMS approximations (e.g. [Garg, McGlaughlin,  TakiGarg et al.2018]).

• Repeat at most times:

• Initialize a bag with a good from each of (Step 0 guarantees that the total value of these goods is less than ).

• Fill the bag with goods from outside . Stop when either no such goods remain, or the bag value raises above .

Since all goods used for filling the bag have a value of at most , the waste of each constructed bundle is at most . By construction, all these bundles are acceptable except the last one. Apply Lemma 2 with being the set of goods remaining in the last bag, and being the number of acceptable bundles constructed by bag-filling. The lemma implies that .

#### Case #2: k′≥n/2.

Alice uses bag-filling as in Case #1.

Here, the waste per constructed bundle might be more than . However, since the value of a single good is at most , the waste of each constructed bundle is at most .

In each of the bundles of step 0, the waste is at most . Since , the average waste per bundle is at most . Hence Lemma 2 applies, and at least acceptable bundles are constructed.

#### Case #3: h>ℓn and k′<n/2.

In this case, Alice will have to construct some bundles with waste larger than . However, she will compensate for it by constructing a similar number of bundles with waste smaller than , such that the average waste per bundle remains at most .

After removing , exactly high-value goods remain. They can be partitioned into two subsets:

• the top remaining goods — those contained in ; exactly in each of . By assumption, .

• the other high-value goods — those not contained in . Since , the set contains at most goods.

This is the hardest case; to handle this case, we proceed to Step 1 below.

### 4.8 Step 1: Bundling high-value goods.

Alice constructs at most bundles as follows.

• Repeat while is not empty:

• Initialize a bag with the lowest-valued remaining good from each of (Step 0 guarantees that their total value is less than ).

• Fill the bag with goods from , until the bag value raises above .

Note that , so as long as is nonempty, each of is nonempty too, and Alice can indeed repeat. By construction, all filled bags except the last one are valued at least ; it remains to prove that the number of these bags is sufficiently large.

Let be the number of acceptable bundles constructed once becomes empty. Note that, in addition to these bundles, there may be an incomplete bundle — the last bundle, whose construction was terminated while its value was still below .

Let be the set of goods from in the acceptable bundles. Denote by the set of goods from that were added last to these bundles (bringing their value from less-than- to at-least-). Note that the waste in each of these bundles might be larger than , but it is at most the value of a single good from , so the total waste is at most .

After this step, Besides the acceptable bundles, there are some high-value goods remaining in (some of these goods are possibly in the incomplete bundle, if such a bundle exists). Alice now has to construct from them some acceptable bundles.

### 4.9 Step 2: Using the remainders.

Alice now constructs acceptable bundles by bag-filling. She initializes each bag with the incomplete bundle from step 1 (if any), or with an -tuple of unused goods from . Then, she fills the bag with low-value goods from the following remainder sets:

• The remainder sets corresponding to the goods allocated within the unacceptable bundles . We denote them by and their values by for .

• The remainder sets corresponding to the high-value goods in and the high-value goods in . We denote them by and their values by for .

By definition, the total value of all these remainders is:

 v⎛⎝⋃j∈P+∪P−RPj  ∪  k⋃c=1ℓ⋃l=1RUc,l⎞⎠ =∑j∈P+∪P−rPj  +  k∑c=1ℓ∑l=1rUc,l.

For each remainder-set , denote by , the subset of that remains after removing the at most unacceptable bundles with more than goods.555 Bundles with at most goods do not consume anything from the remainder-sets , since they contain only high-value goods from . From the same reason, the acceptable bundles constructed in Step 0 do not consume anything from the remainder sets. Each unacceptable bundle contains, in addition to the high-value goods for , some low-value goods with a total value of less than (since the total value of the unacceptable bundle is less than ). Therefore, the total value of low-value goods included in these unacceptable bundles is at most (equality holding iff ). Therefore, the total remaining value satisfies

 v⎛⎝⋃j∈P+∪P−R′Pj  ∪  k⋃c=1ℓ⋃l=1R′Uc,l⎞⎠ (2) ≥⎛⎝∑j∈P+∪P−rPj  +  k∑c=1ℓ∑l=1rUc,l⎞⎠−k∑c=1ℓ∑l=1rUc,l =∑j∈P+∪P−rPj.

The bag-filling proceeds as follows.

1. Initialize .

2. Initialize a bag with either the incomplete bundle from step 1 (if any), or some unused top goods. We denote the top goods used for initializing bag by .

3. Add to the bag the remainder-sets and in an arbitrary order. Stop when either no such remainder-sets remain, or the bag value raises above .

4. If there are still some unused remainder-sets and high-value goods, let and go back to step 2.

The bag-filling stops when either there are no more high-value goods, or no more remainder-sets. In the former case, Alice has all required bundles ( from step 1 and from step 2), and the construction is done. We now analyze the latter case.

By construction, we go to the next bag only after the current bag becomes at least . Therefore, all bags except the last one are valued at least . Our goal now is to prove that the number of these “all bags except the last one” is sufficiently large.

Let be the number of bundles constructed with a value of at least . For each , The -th bag contains the high-value goods and some remainder-sets. How much remainder-sets should it contain? Suppose it contains remainder-sets with a total value of . Then, the total bundle value is . By assumption, the total value of every MMS bundles is at least , so the bundle value is at least . Therefore, to make bundle acceptable, it is sufficient to add to it a value of .

Denote by the index of the last remainder-set added to bag (bringing its value from less-than- to at-least-). The total value of remainder-sets in the bag is thus less than .

The total value of remainder-sets in the unfilled -th bag is less than , where are indices of some remaining high-value goods. Therefore, the total value of remainder-sets in all bags together satisfies

 v⎛⎝⋃j∈P+∪P−R′Pj  ∪  k⋃c=1ℓ⋃l=1R′Uc,l⎞⎠ <  t∑a=1(rj[a,∗]+ℓ∑l=1rj[a,l])  +  (ℓ∑l=1rj[t+1,l]) (3) =(t+1∑a=1ℓ∑l=1rj[a,l])  +  (t∑a=1rj[a,∗]).

Combining (2) and (3) gives

 (t+1∑a=1ℓ∑l=1rj[a,l])+(t∑a=1rj[a,∗])>∑j∈P+∪P−rPj. (4)

In the left-hand side there are terms, while in the right-hand side there are terms — for each bundle constructed in Step 1. We now show that each term in the left-hand side is equal or smaller than a unique term in the right-hand side. Since the left-hand side is overall larger than the right-hand side, this indicates that the left-hand side must have more terms, that is, . This implies that , i.e., Alice has successfully constructed from the remainder-sets some acceptable bundles.

• Consider first the terms , and compare them to for . Since the bundles in Step 1 were constructed in ascending order of value, starting at the lowest-valued available goods in each of , every index is smaller than any index . Therefore, every term is smaller than some unique term for , for every .

• Consider now the terms , and compare them to for . Each of the indices is an index of some unique remainder-set, so it is either equal to some unique index , or to some unique index (the index some remainder-set of some unacceptable bundle ). All indices are in , so they are smaller than the indices . Therefore, every is either equal or smaller than some unique term for .

So Alice has new acceptable bundles. The waste of each of these is , which — as mentioned above — is equal to or smaller than some unique term for . Therefore, the total waste of all these bundles is at most the following sum of terms: .

Recall that the waste of each of the acceptable bundles from step 1 was at most for some . Therefore, the total waste of the acceptable bundles constructed so far is at most

 ∑j∈P−rPj+∑j∈P−v(gj) = ∑j∈P−(rPj+v(gj)) = ∑j∈P−v(Mj) ≤ ∑j∈P−(ℓ−x) by the normalization (Section 4.1) = |P−|⋅(ℓ−x) = s⋅(ℓ−x).

Therefore, the average waste per bundle is at most .

### 4.10 Step 3: plain bag-filling.

At this stage, there are no more high-value goods outside . Therefore, Alice can construct the remaining bundles by plain bag-filling, initializing each bag with some -tuple of unused goods remaining in , and filling it with some low-value goods outside . Since the waste in each bundle is at most , Lemma 2 implies that the total number of constructed bundles is .

This completes the proof that is a reasonable threshold for Algorithm 2. Therefore, the algorithm finds the allocation promised in Theorem 1.

### 4.11 Limits of Algorithm 2

To illustrate the limitation of Algorithm 2, we show that it cannot guarantee -out-of- MMS. For simplicity we assume that is even so that is an integer.

###### Example 6 (Tight bound for our technique).

Suppose that in the first iteration all agents except the divider have the following MMS bundles:

• bundles are made of two goods with values and .

• One bundle is made of two goods with values and .

• bundles are made of two goods with values .

So their -out-of- MMS equals . However, it is possible that the first divider takes an unacceptable bundle containing goods of value , the good of value , and the goods of value . Note that this bundle is -balanced. All remaining goods have a value of less than , so an acceptable bundle requires at least goods. However, the number of remaining goods is only : goods of value , one good of value and goods of value . Hence, at most acceptable bundles can be constructed.

## 5 Ordinal Approximation for Goods in Polynomial Time

The objective of this section is to develop a polynomial-time algorithm for computing -out-of- MMS allocations, focusing on the case . Algorithm 2 guarantees that each agent receives an -out-of- MMS allocation for . However, the algorithm requires exact MMS values to determine whether a given bundle is acceptable to each agent. Since computing an exact MMS value for each agent is NP-hard, Algorithm 2 does not run in polynomial-time even for the case of .

We utilize an optimization technique used in the bin covering problem. This problem was presented by assmann1984dual as a dual of the more famous bin packing problem. In the bin covering problem, the goal is to fill bins with goods of different sizes, such that the sum of sizes in each bin is at least , and subject to this, the number of bins is maximized. This problem is NP-hard, but several approximation algorithms are known. Approximation algorithms to this problem accept a bin-covering instance and fill at least bins, where and are constants, and is the maximum possible number of bins in .

Such an algorithm can be used directly to find an ordinal approximation of an MMS allocation when all agents have identical valuations. Our challenge is to adapt them to agents with different valuations.