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.^{1}^{1}1See [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 outof MMS, generalizes the guarantee of the cutandchoose 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 nonnegative values), the outof MMS threshold is (weakly) monotonically decreasing as the number of partitions () increases.
When allocating goods among agents, a natural desirable threshold is satisfying outof MMS for all agents. Unfortunately, while this value can be guaranteed for agents through cutandchoose, outof 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 1outof 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 outof 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 outof 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 1outof MMS as an approximation to the 1outof 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 outof 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 outof MMS for some integer . The outof 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 outof MMS [Babaioff, Nisan, TalgamCohenBabaioff et al.2021], that guarantees to each agent the value obtained by partitioning the goods into bundles and selecting the leastvaluable ones. Therefore, we further investigate the outof MMS generalization that allows us to improve the fairness thresholds, as we show in the next subsection. The notion of outof MMS fairness is robust in the sense that, a fair allocation remains fair even when each agent’s utility function goes through an arbitrary monotonicallyincreasing transformation. Given these notions, we ask the following questions:
In the allocation of indivisible goods, (a) For what combinations of integers and , can outof MMS allocations be guaranteed? and (b) For what integers and can outof 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 outof MMS allocation of goods when (Theorem 1). In particular, outof MMS, outof MMS, outof MMS, and so on, are all guaranteed to exist. This finding generalizes the previously known existence result of outof MMS [Hosseini SearnsHosseini Searns2021].
The proof uses an algorithm that, given lower bounds on the outof MMS values of the agents, returns an outof MMS allocation. The algorithm runs in polynomial time given the agents’ lower bounds. However, computing the exact outof MMS values is NPhard. In the following sections we propose two solutions to this issue.
In Section 5, we present a polynomialtime algorithm for finding a 1outof 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 outof 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.^{2}^{2}2 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 outof 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 outof MMS allocation [AignerHorev SegalHaleviAignerHorev SegalHalevi2019], which for small is substantially worse than our target approximation of outof. 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 polynomialtime 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 NPhard, but csirik1999two presents a polynomialtime 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 courseallocation by budish2011combinatorial, where he introduced the ordinal approximation to MMS, and showed a mechanism that guarantees outof 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 nontrivial ordinal approximation was 1outof MMS [AignerHorev SegalHaleviAignerHorev SegalHalevi2019]. hosseini2021mms studied the connection between guaranteeing 1outof MMS for of the agents and the ordinal approximations for all agents. The implication of their results is the existence of outof MMS allocations and a polynomialtime algorithm for . Whether or not outof 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 outof MMSfairness 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 cakecutting problem [Bogomolnaia MoulinBogomolnaia Moulin2020, Elkind, SegalHalevi, SuksompongElkind et al.2021].
2.2 Multiplicative MMS approximations
The multiplicative approximation to MMS originated in the computer science literature [Procaccia WangProcaccia Wang2014]. The nonexistence 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 optimalMMS, that is, the largest value, , for which each agent receives the value of . Since the number of possible partitions is finite, an optimalMMS allocation always exists, and it is an MMS allocation if . However, an optimalMMS 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 approximatelystable algorithm for two agents.
Finally, robustness has been studied also in the context of fair cakecutting. aziz2014cake define an allocation robustfair if it remains fair even when the valuation of an agent changes, as long as the ordinal information in it remains unchanged. edmonds2011cake study cakecutting 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 nonnegative 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 outof 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 outofMMS 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 weaklyincreasing function of and a weaklydecreasing 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 [AignerHorev SegalHaleviAignerHorev SegalHalevi2019], 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
then there exists a partition of into , such that
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 envyfree matching in the resulting bipartite graph.^{3}^{3}3 An envyfree 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 envyfree matching, and a maximumcardinality envyfree matching can be found in polynomial time [AignerHorev SegalHaleviAignerHorev SegalHalevi2019]. 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 cakecutting [KuhnKuhn1967].
When is a set of indivisible goods, is a reasonable threshold for every [AignerHorev SegalHaleviAignerHorev SegalHalevi2019], 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 outof MMS, it cannot guarantee outof 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 1outof 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 outof 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 NPhard 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 outof MMS allocation when in polynomialtime.
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 leastvaluable 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
Since ,
(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 .

There are goods with the value of .

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 mostvaluable good; the new should be the value of ’s leastvaluable 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, 4thbest item and 5thbest 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, 4thbest and 5thbest 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 pickingsequence 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 outof. 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 mostvaluable goods; contains the next mostvaluable 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 leastvaluable 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 .^{4}^{4}4 Recall that the Lone Divider algorithm allocates bundles using an envyfree 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
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
Assume for contradiction that . Then the above inequality implies:
However, by (1),
which is a contradiction. ∎
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 previouslyallocated bundles;

Some newlyconstructed bundles with at most goods;

Some newlyconstructed 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 highestvalued 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 previouslyallocated bundles, and are newlyconstructed 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 highvalue goods.
4.7 Highvalue goods
We define highvalue goods as goods with . Denote by the number of highvalued goods in . Since the instance is ordered, goods are highvalued. All MMS bundles are worth at most , and therefore may contain at most one highvalue 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 highvalue good, so the are all distinct.

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

.
We consider three cases, based on the number of highvalue goods.
Case #1: .
This means that all highvalue goods are contained in , so after removing , at most highvalue goods remain — at most in each of . Alice constructs the required bundles by bagfilling — 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 bagfilling. The lemma implies that .
Case #2: .
Alice uses bagfilling 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: and .
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 highvalue goods remain. They can be partitioned into two subsets:

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

the other highvalue 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 highvalue goods.
Alice constructs at most bundles as follows.

Repeat while is not empty:

Initialize a bag with the lowestvalued 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 lessthan to atleast). 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 highvalue 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 bagfilling. 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 lowvalue 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 highvalue goods in and the highvalue goods in . We denote them by and their values by for .
By definition, the total value of all these remainders is:
For each remainderset , denote by , the subset of that remains after removing the at most unacceptable bundles with more than goods.^{5}^{5}5 Bundles with at most goods do not consume anything from the remaindersets , since they contain only highvalue 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 highvalue goods for , some lowvalue goods with a total value of less than (since the total value of the unacceptable bundle is less than ). Therefore, the total value of lowvalue goods included in these unacceptable bundles is at most (equality holding iff ). Therefore, the total remaining value satisfies
(2)  
The bagfilling proceeds as follows.

Initialize .

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 .

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

If there are still some unused remaindersets and highvalue goods, let and go back to step 2.
The bagfilling stops when either there are no more highvalue goods, or no more remaindersets. 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 highvalue goods and some remaindersets. How much remaindersets should it contain? Suppose it contains remaindersets 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 remainderset added to bag (bringing its value from lessthan to atleast). The total value of remaindersets in the bag is thus less than .
The total value of remaindersets in the unfilled th bag is less than , where are indices of some remaining highvalue goods. Therefore, the total value of remaindersets in all bags together satisfies
(3)  
(4) 
In the lefthand side there are terms, while in the righthand side there are terms — for each bundle constructed in Step 1. We now show that each term in the lefthand side is equal or smaller than a unique term in the righthand side. Since the lefthand side is overall larger than the righthand side, this indicates that the lefthand side must have more terms, that is, . This implies that , i.e., Alice has successfully constructed from the remaindersets 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 lowestvalued 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 remainderset, so it is either equal to some unique index , or to some unique index (the index some remainderset 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
by the normalization (Section 4.1)  
Therefore, the average waste per bundle is at most .
4.10 Step 3: plain bagfilling.
At this stage, there are no more highvalue goods outside . Therefore, Alice can construct the remaining bundles by plain bagfilling, initializing each bag with some tuple of unused goods remaining in , and filling it with some lowvalue goods outside . Since the waste in each bundle is at most , Lemma 2 implies that the total number of constructed bundles is .
4.11 Limits of Algorithm 2
To illustrate the limitation of Algorithm 2, we show that it cannot guarantee outof 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 outof 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 polynomialtime algorithm for computing outof MMS allocations, focusing on the case . Algorithm 2 guarantees that each agent receives an outof 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 NPhard, Algorithm 2 does not run in polynomialtime 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 NPhard, but several approximation algorithms are known. Approximation algorithms to this problem accept a bincovering 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.
Comments
There are no comments yet.