Social:Maximin share

Maximin share (MMS) is a criterion of fair item allocation. Given a set of items with different values, the 1-out-of-n maximin-share is the maximum value that can be gained by partitioning the items into n parts and taking the part with the minimum value.

An allocation of items among n agents with different valuations is called MMS-fair if each agent gets a bundle that is at least as good as his/her 1-out-of-n maximin-share. MMS fairness was invented by Eric Budish as a relaxation of the criterion of proportionality - each agent gets a bundle that is at least as good as the equal split (1/n of every resource). Proportionality can be guaranteed when the items are divisible, but not when they are indivisible, even if all agents have identical valuations. In contrast, MMS fairness can always be guaranteed to identical agents, so it is a natural alternative to proportionality even when the agents are different.

Motivation and examples

Identical items. Suppose first that m identical items have to be allocated fairly among n people. Ideally, each person should receive m/n items, but this may be impossible if m is not divisible by n, as the items are indivisible. A natural second-best fairness criterion is to round m/n down to the nearest integer, and give each person at least floor(m/n) items. Receiving less than floor(m/n) items is "too unfair" - it is an unfairness not justified by the indivisibility of the items.

Different items. Suppose now that the items are different, and each item has a different value. For example, suppose n=3 and m=5 and the items' values are 1, 3, 5, 6, 9, adding up to 24. If the items were divisible, we would give each person a value of 24/3 = 8 (or, if they were divisible only to integer values as in the preceding paragraph, at least floor(24/3) = 8), but this is not possible. The largest value that can be guaranteed to all three agents is 7, by the partition {1,6},{3,5},{9}. Informally, 7 is the total value divided by n "rounded down to the nearest item".

The set {1,6} attaining this maximin value is called the "1-out-of-3 maximin-share" - it is the best subset of items that can be constructed by partitioning the original set into 3 parts and taking the least valuable part. Therefore, in this example, an allocation is MMS-fair iff it gives each agent a value of at least 7.

Different valuations. Suppose now that each agent assigns a different value to each item, for example:

• Alice values them at 1,3,5,6,9;
• George values them at 1,7,2,6,8;
• Dina values them at 1,1,1,4,17.

Now, each agent has a different MMS:

• Alice's MMS is still {1,6} as above;
• George's MMS is {1,7} or {2,6} or {8}, by the partition {1,7},{2,6},{8} (all these bundles are equivalent for him);
• Dina's MMS is {1,1,1}, by the partition {1,1,1},{4},{17}.

Here, an allocation is MMS-fair if it gives Alice a value of at least 7, George a value of at least 8, and Dina a value of at least 3. For example, the in which George gets the first two items {1,7}, Alice gets the next two items {5,6}, and Dina gets the last item {17} is MMS-fair.

Interpretation. The 1-out-of-n MMS of an agent can be interpreted as the maximal utility that an agent can hope to get from an allocation if all the other agents have the same preferences, when he always receives the worst share. It is the minimal utility that an agent could feel entitled to, based on the following argument: if all the other agents have the same preferences as me, there is at least one allocation that gives me this utility, and makes every other agent (weakly) better off; hence there is no reason to give me less.

An alternative interpretation is: the most preferred bundle the agent could guarantee as divider in divide and choose against adversarial opponents: the agent proposes her best allocation and leaves all the other ones to choose one share before taking the remaining one.

MMS-fairness can also be described as the result of the following negotiation process. A certain allocation is suggested. Each agent can object to it by suggesting an alternative partition of the items. However, in doing so he must let all other agents chose their share before he does. Hence, an agent would object to an allocation only if he can suggest a partition in which all bundles are better than his current bundle. An allocation is MMS-fair iff no agent objects to it, i.e., for every agent, in every partition there exists a bundle which is weakly worse than his current share.

Existence of MMS-fair allocations

When all n agents have identical valuations, an MMS-fair allocation always exists by definition.

Even when only n-1 agents have identical valuations, an MMS-fair allocation still exists and can be found by divide and choose: the n-1 identical agents partition the items into n bundles each of which is at least as good as the MMS; the n-th agent chooses a bundle with a highest value; and the identical agents take the remaining n-1 bundles.

In particular, with two agents, an MMS-fair allocation always exists.

Bouveret and Lemaître performed extensive randomized simulations for more than 2 agents, and found that MMS-fair allocations exist in every trial. They proved that MMS allocations exist in the following cases:

• Binary valuations - each agent either likes an item (values it at 1) or dislikes it (values it at 0).
• Identical multisets - agents may value the items differently, but the multisets of the agents' values are the same.
• Few items - m ≤ n+3.

Procaccia and Wang and Kurokawa constructed an instance with n=3 agents and m=12 items, in which no allocation guarantees to each agent the 1-out-of-3 MMS. In their instance, there are 12 objects, indexed by [math]\displaystyle{ i\in[3] }[/math] and [math]\displaystyle{ j\in[4] }[/math]. Each agent [math]\displaystyle{ k }[/math] values each object [math]\displaystyle{ (i,j) }[/math] by:

[math]\displaystyle{ v_k(i,j) = 1,000,000 + 1,000\cdot T_{i,j} + E_{i,j}^{(k)} }[/math]

where [math]\displaystyle{ T, E^{(1)}, E^{(2)}, E^{(3)} }[/math] are particular 3-by-4 matrices with values smaller than 100. They prove that every agent can partition the objects into 3 subsets of 4 objects each, such that the sum of values in each subset is 4,055,000, which is therefore the MMS of all agents. They prove that every MMS allocation must give exactly 4 particular objects to every agent, but such an allocation does not exist. Thus, every allocation gives at least one agent a value of at most 4,054,999.

They generalized this instance and showed that for every n ≥ 3 there is such an instance with 3n+4 items.

Multiplicative approximation

Following the non-existence result for MMS allocations, Procaccia and Wang introduced the multiplicative approximation to MMS: an allocation is r-fraction MMS, for some fraction r in [0,1], if each agent's value is at least a fraction r of the value of his/her MMS.

They presented an algorithm that always finds an r_n-fraction MMS, where

[math]\displaystyle{ r_n := \frac{2\cdot \text{oddfloor}(n)}{3\cdot \text{oddfloor}(n) -1} = \begin{cases} \frac{2n}{3n-1} & n ~ \text{ odd} \\ \frac{2n-2}{3n-4} & n ~ \text{ even} \end{cases} }[/math]

where oddfloor(n) is the largest odd integer smaller or equal to n. In particular, r₃ = r₄ = 3/4, it decreases when n increases, and it always larger than 2/3. Their algorithm runs in time polynomial in m, when n is constant.

Amanatidis, Markakis, Nikzad and Saberi proved that, in randomly-generated instances, MMS-fair allocations exist with high probability. They presented several improved algorithms:

• A simple and fast 1/2-fraction MMS algorithm;
• A 2/3-fraction MMS algorithm that runs in polynomial time in both m and n;
• A 7/8-fraction MMS algorithm for 3 agents;
• An MMS-fair algorithm for the case of ternary valuations - each value is 0 or 1 or 2.

Aziz, Rauchecker, Schryen and Walsh presented:

• A proof that an MMS allocation may not exist for chores (items with negative utilities).
• A 2-fraction MMS algorithm for chores (with negative utilities the approximation factor is larger than 1).
• Algorithms for finding the optimal MMS approximation of a given instance, based on algorithms for multiway number partitioning.

Barman and Krishnamurthy presented:

• A simple and efficient algorithm for 2/3-fraction MMS with additive valuations . Their algorithm is based on "ordering" the instance (i.e., reducing the instance to one in which all agents agree on the ranking of goods), and then running the envy-graph procedure starting at the most valuable good. They prove that the outcome is EFX and guarantees to each agent [math]\displaystyle{ \frac{2n}{3n-1} }[/math] of his MMS, which is at least 2/3.
• A similar algorithm for chores attains 4/3-fraction MMS for chores (precisely, [math]\displaystyle{ \frac{4n-1}{3n} }[/math]).
• A simple algorithm for 1/10-fraction MMS for the more challenging case of submodular valuations - based on round-robin item allocation.

Ghodsi, Hajiaghayi, Seddighin, Seddighin and Yami presented:

• For additive valuations: a polynomial-time algorithm for 3/4-fraction MMS.
• For n=4 additive agents: an algorithm for 4/5-fraction MMS.
• For submodular valuations: a polynomial-time algorithm for 1/3-fraction MMS, and an upper bound of 3/4-fraction.
• For XOS valuations: a polynomial-time algorithm for 1/8-fraction MMS, an existence proof for 1/5-fraction, and an upper bound of 1/2-fraction.
• For subadditive valuations: an existence proof for log(m)/10-fraction MMS, and an upper bound of 1/2-fraction.

Garg, McGlaughlin and Taki presented a simple algorithm for 2/3-fraction MMS whose analysis is also simple.

Garg and Taki presented a simple algorithm for 3/4-fraction MMS, which does not need to know the MMS value, and thus runs in strongly polynomial time. They also prove the existence of [math]\displaystyle{ (\frac{3}{4} + \frac{1}{12 n}) }[/math]-fraction MMS.

To date, it is not known what is the largest r such that an r-fraction MMS allocation always exists. It can be any number between 3/4 and slightly less than 1.

Huang and Lu prove that a 11/9-fraction MMS allocation for chores always exists.

Kulkarni, Mehta and Taki study MMS allocation with mixed valuations, i.e., when there are both goods and chores. They prove that:

• No multiplicative approximation is possible. They extend the example of Procaccia and Wang by adding three chores with a value of -4,054,999.75. The 1-out-of-3 MMS of each agent is 0.25 (each MMS bundle contains four goods with a sum of 4,055,000, and one chore). However, every allocation of the goods gives at least one agent, a value of at most 4,054,999 from the goods. We must give one chore to each agent; therefore, at least one agent has a negative value.
• They also present conditions under which computing an α-MMS and Pareto-optimal allocation, for the best possible α in a specific instance, can be done in polynomial time.

Amanatidis, Birmpas and Markakis presented truthful mechanisms for approximate MMS-fair allocations (see also Strategic fair division):

• For n agents: an 1/O(m)-fraction MMS.
• For 2 agents: a 1/2-fraction MMS, and a proof that no truthful mechanism can attain more than 1/2.

Ordinal approximation

Budish introduced a different approximation to the 1-of-n MMS—the 1-of-([math]\displaystyle{ n+1 }[/math]) MMS (each agent receives at least as much as he could get by partitioning into n+1 bundles and getting the worst one). He showed that the Approximate Competitive Equilibrium from Equal Incomes always guarantees the 1-of-([math]\displaystyle{ n+1 }[/math]) MMS, However, this allocation may have excess supply, and - more importantly - excess demand: the sum of the bundles allocated to all agents might be slightly larger than the set of all items. Such an error is reasonable when allocating course seats among students, since a small excess supply can be corrected by adding a small number of seats. But the classic fair division problem assumes that items may not be added.

Without excess supply and demand, the following approximations are known:

• A 1-out-of-(2n-2) MMS allocation using envy-free matching.
• A 1-out-of-(3n/2) MMS allocation using a different algorithm. It can be computed in polytime when n<6.

To date, it is not known what is the smallest N such that a 1-out-of-N MMS allocation always exists. It can be any number between n+1 and 3n/2. The smallest open case is n=4.

The ordinal MMS condition can also be applied to asymmetric agents (agents with different entitlements).

Techniques and algorithms

Various normalizations can be applied to the original problem without changing the solution. Below, O is the set of all objects.

Scaling

If, for each agent i, all valuations are scaled by a factor k_i (which can be different for different agents), then the MMS for each agent is scaled by the same factor; therefore, every MMS allocation in the original instance is an MMS allocation in the scaled instance. It is common to scale the valuations such that the MMS of evey agent is exactly 1. After this scaling, the MMS approximation problems can be stated as:

• r-fraction MMS: the total value of O is at least n; we need to give each of n agents a bundle worth at least r.
• 1-of-N MMS: the total value of O is at least N; we need to give each of n agents a bundle worth at least 1.

The above scaling requires to compute the MMS of each agent, which is an NP-hard problem (multiway number partitioning). An alternative scaling, that can be done faster, is:

• r-fraction MMS: the total value of O is exactly n; the MMS is at most 1; we need to give each of n agents a bundle worth at least r.
• 1-of-N MMS: the total value of O is exactly N; the MMS is at most 1; we need to give each of n agents a bundle worth at least 1.

Allocating one object

If we remove one object o from O. Then for each agent, the 1-out-of-(n-1) MMS w.r.t. the remaining set O \ o is at least his 1-out-of-n MMS w.r.t. the original set O. This is because, in the original MMS partition, n-1 parts remain intact. Now, suppose we aim to give each agent a value of r. If some object o₁ is worth at least r to at least one agent, then we can give o₁ to one such agent arbitrarily, and proceed to allocate the remaining objects to the remaining agents. Therefore, we can assume w.l.o.g. that:

• r-fraction MMS : the value of each object for all agents is less than r .
• 1-of-N MMS : the value of each object for all agents is less than 1.

This normalization works even with the fast scaling, and with arbitrary monotone valuations (even non-additive).

Bag filling

Denote an object, that is valued by at most s by all agents, as an "s-small object". Suppose that all objects are s-small. Take an empty bag and fill it with object after object, until the bag is worth at least r to at least one agent. Then, give the bag to one such agent arbitrarily. Since all objects are s-small, the remaining agents value the bag at most r+s; if this value is sufficiently small, then the remaining value is sufficiently large so that we can proceed recursively. In particular, bag-filling gives as the following solutions:

• 1/2-fraction MMS : take s = r = 1/2; note that by the previous normalization we can assume that all objects are 1/2-small. Initially, there are n agents and the total value is at least n for them. After a bag is allocated, the remaining n -1 agents value the remaining objects at least n - (r +s ) = n -1, so we can proceed recursively.
• 1-of-(2n) MMS : take s = r = 1; note that by the previous normalization we can assume that all objects are 1-small. Initially, there are n agents and the total value is at least 2n for them. After a bag is allocated, the remaining n -1 agents value the remaining objects at least 2n - (r +s ) = 2n -2 = 2(n -1), so we can proceed recursively.

These bag-filling algorithms work even with the fast scaling, so they run in polynomial time - they do not need to know the exact MMS value. In fact, both algorithms can be stated without mentioning the MMS at all:

• Every agent for whom each object is worth at most 1/(2n) of the total value, receives at least 1/(2n) of the total value.

Modified bag filling: The condition that all objects are s-small can be relaxed as follows. Take some s<r. Denote an object that is not s-small (i.e., valued at least s by at least one agent) as an "s-large object". Suppose at most n objects are s-large. Take one s-large object o₁, put it in a bag, and fill it with s-small objects until one agent indicates that it is worth for him at least r. There must be at least one such agent, since some agent i values o₁ at some x>s. For this agent, there are at most n-1 remaining s-large objects. By the previous normalization, these objects are still r-small, so their total value for i is at most r(n-1), so the value of remaining s-small objects is at least n-r(n-1)-x = r(n-1)+r-x ≥ r-x.

Ordering

an instance is ordered if all agents have the same ordinal ranking on the objects, i.e, the objects can be numbered o₁, ..., o_m such that, for each agent i, v_i(o₁) ≥ ... ≥ v_i(o_m). Intuitively, ordered instances are hardest, since the conflict between agents is largest. Indeed, the negative instance of is ordered - the order of the objects is determined by the matrix [math]\displaystyle{ T }[/math], which is the same for all agents. This can also be proved formally. Suppose we have an algorithm that finds, for every ordered instance, an r-fraction MMS allocation. Now, we are given a general item-allocation instance P. We solve it in the following way.

1. Construct an ordered instance ord(P) in the following way: for every agent i, define v_i(o_j) in ord(P) as the j-th highest value in the set of values of agent i in P. This requires O(n m log(m)) time.
2. Find an r-fraction MMS allocation ord(A) in ord(P).
3. Construct a picking sequence in which the agent who received o₁ in ord(A) picks first, the agent who received o₂ in ord(A) picks second, etc.
4. Let agents pick their best items according to the picking-sequence. Let A be the resulting allocation. In A, each agent receives exactly the same number of items as in ord(A). Moreover, each agent who received o_j in ord(A), receives one of his top j items in A. Therefore, his value for each item he got in A is at least as large as his value for the corresponding item in ord(A). Therefore, the value of every agent in A is at least as high as in ord(A). Since the ordering does not change the MMS values, the new allocation A is still r-fraction MMS.

So when looking for r-fraction MMS allocations, we can assume w.l.o.g. that:

• The ordinal ranking of the objects is the same for all agents.

Allocating two objects

Suppose we find two objects o₁ and o₂, that one agent i values at least r, while the other agents value at most 1. Then these two objects can be allocated to i. For the other agents, the 1-out-of-(n-1) MMS w.r.t. the remaining set is at least his 1-out-of-n MMS w.r.t. the original set O. This is because, in the original MMS partition, at least n-2 parts remain intact, while the two parts that are not intact can be combined to form a single part with a value of at least 1. This normalization works only with additive valuations.

Moreover, suppose that the instance is ordered, and suppose we remove from O the two objects o_n, o_n+1 (i.e., the n-th and (n+1)-th highest-valued items). Then for each agent, the 1-out-of-(n-1) MMS w.r.t. the remaining set is at least his 1-out-of-n MMS w.r.t. the original set O. This is because, by the pigeonhole principle, at least one MMS part of each agent must contain two or more objects from the set {o₁, ..., o_n+1}. These items can be used to replace the objects given away, which results in n-1 parts with a value of at least 1. This means that, if the objects o_n, o_n+1 have a value of at least the MMS for some agent i, we can give them to i and proceed to allocate the remaining objects to the remaining agents. Therefore, we can assume w.l.o.g. that:

• r-fraction MMS: the total value of o_n, o_n+1 for all agents is less than r . In particular, the value of o_n+1 and all objects after it in the ordering is less than r/2.
• 1-of-N MMS : the total value of o_N, o_N+1 for all agents is less than 1. In particular, the value of o_N+1 and all objects after it in the ordering is less than 1/2.

This normalization works even with the fast scaling. Combining it with modified bag-filling leads to the following simple algorithm for 2/3-fraction MMS.

• As long as a single object is worth at least 2/3 to some agent, allocate it.
• Order the instance.
• As long as o_n, o_n+1 are worth at least 2/3 to some agent, allocate them.
• Finally, there are at most n objects with value at least 1/3; allocate them using modified bag-filling.

The guarantee of this algorithm can be stated even without mentioning MMS:

• Every agent, for whom o₁ is worth at most 2/(3n) of the total value and o_n + o_n+1 are worth together at most 2/(3n) of the total value, receives at least 2/(3n) of the total value.

Algorithmic problems

Several basic algorithms related to the MMS are:

• Computing whether the 1-of-n MMS of a given agent is at least some integer K. It is in NP since it can be vefiried in polynomial time given any allocation with min-value at least K; it is NP-hard by reduction from the partition problem. Hence, it is NP-complete for any n ≥ 2. Therefore, calculating the MMS of a given agent is NP-hard. Woeginger developed a PTAS for it.
• Deciding whether a given allocation is MMS-fair is co-NP complete for agents with additive valuations (it is in co-NP, since it is possible to prove in polynomial time that a given allocation is not MMS-fair, given the MMS partition of one of the agents, which shows that the agent's MMS value is larger than his value in the allocation).
• Deciding whether a given instance admits any MMS allocation, given the MMS values of all agents. It is in NP since it can be verified in polynomial time given the allocation; its exact runtime complexity is unknown. Therefore, deciding whether a given instance admits any MMS allocation is in [math]\displaystyle{ NP^{NP} }[/math], i.e., it can be solved in nondeterministic-polynomial time using an oracle to an NP problem (the oracle is needed to calculate the MMS of an agent). However, the exact computational complexity of this problem is still unknown: it may be level 2 or 1 or even 0 of the polynomial hierarchy.
• The decision problem of checking if there exists a minimax share allocation is NP-hard. Both problems can be approximated by a PTAS, assuming that the number of agents is fixed. When agents' valuations are binary, or additive and based on Borda score, maximin share allocations can always be found efficiently. When their valuations are nonadditive, there are instances in which an r-fraction MMS allocation does not exist for any positive r. However, for a class of symmetric submodular utilities, there exists a tight 1/2-fraction MMS allocation, and it can be approximated to within a factor of 1/4.

MMS fairness for groups

An allocation is called pairwise-maximin-share-fair (PMMS-fair) if, for every two agents i and j, agent i receives at least his 1-out-of-2 maximin-share restricted to the items received by i and j. It is not known whether a PMMS allocation always exists, but a 0.618-approximation always exists.

An allocation is called groupwise-maximin-share-fair (GMMS-fair) if, for every subgroup of agents of size k, each member of the subgroup receives his/her 1-out-of-k maximin-share restricted to the items received by this subgroup.

With additive valuations, the various fairness notions are related as follows:

• Envy-freeness implies GMMS-fairness;
• GMMS-fairness implies MMS-fairness (by taking the subgroup of size n) and PMMS-fairness (by taking subgroups of size 2);
• PMMS-fairness implies 2/3-MMS-fairness for three agents, and 4/7-MMS-fairness in general;
• PMMS-fairness implies EFX, which implies EF1.
• EF1 implies 1/2-PMMS and EFX implies 2/3-PMMS. Hence, a 1/2-PMMS allocation can be found in polynomial time.
• MMS-fairness and PMMS-fairness do not imply each other.

GMMS allocations are guaranteed to exist when the valuations of the agents are either binary or identical. With general additive valuations, 1/2-GMMS allocations exist and can be found in polynomial time.

Relation to other fairness criteria

An allocation is called envy-free-except-c-items (EFc) for an agent i if, for every other agent j, there exists a set of at most c items that, if removed from j's bundle, then i does not envy the remainder. An EF0 allocation is simply called envy-free. EF1 allocations can be found, for example, by round-robin item allocation or by the envy-graph procedure.

An allocation is called proportional-except-c-items (PROP*c) for an agent i if there exists a set of at most c items outside i's bundle that, if removed from the set of all items, then i values his bundle at least 1/n of the remainder. A PROP*0 allocation is simply called proportional.

EF0 implies PROP*0, and EF1 implies PROP*(n-1). Moreover, for any integer c 0, EFc implies PROP*((n-1)c). The opposite implication is true when n=2, but not when n>2.

The following maximin-share approximations are implied by PROP*(n-1), hence also by EF1:

• Multiplicative approximation: 1/n-fraction MMS (the 1/n is tight);
• Ordinal approximation: 1-of-(2n-1) MMS (the 2n-1 is tight). Similarly, for every integer c, PROP*c implies 1-of-(c+n) MMS.
• MMS when the value function is binary. The opposite implication holds too.

The above implications are illustrated below:

Envy-free	→	Proportional	→	Maximin-share
↓		↓		↓
			→	1/n-fraction MMS
EF1	→	PROP*(n-1)	↔	MMS for binary valuation
↓		↓	→	1-out-of-(2n-1) MMS
				↓
EFc	→	PROP*((n-1)c)	→	1-out-of-((n-1)c+n) MMS

An allocation is called envy-free-except-any-item (EFx) for an agent i if, for every other agent j, for any single item removed from j's bundle, i does not envy the remainder. EFx is strictly stronger than EF1. It implies the following MMS approximations:

• 2/3-fraction MMS for 2 or 3 agents (it is tight);
• 4/7-fraction MMS for any number of agents (it is not known whether it is tight; the upper bound is 8/13).

See also

• Bin covering problem and Bin packing problem - two well-studied optimization problems that can be seen as special cases of indivisible goods allocation and indivisible chores allocation, respectively. Many techniques used for these problems are useful in the case of maximin share item allocation, too.
• Envy-free item allocation