Fair Division with Bounded Sharing

12/01/2019 ∙ by Erel Segal-Halevi, et al. ∙ 0

A set of objects is to be divided fairly among agents with different tastes, modeled by additive value functions. If the objects cannot be shared, so that each of them must be entirely allocated to a single agent, then fair division may not exist. How many objects must be shared between two or more agents in order to attain a fair division? The paper studies various notions of fairness, such as proportionality, envy-freeness and equitability. It also studies consensus division, in which each agent assigns the same value to all bundles — a notion that is useful in truthful fair division mechanisms. It proves upper bounds on the number of required sharings. However, it shows that finding the minimum number of sharings is, in general, NP-hard even for generic instances. Many problems remain open.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

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

What is a fair way to allocate objects without monetary transfers?

When the objects are indivisible, it may be impossible to allocate them fairly — consider a single object and two people. A common approach to this problem is to look for an approximately-fair allocation. There are several definitions of approximate fairness, the most common of which are envy-freeness except one object (EF1) and maximin share (MMS). An alternative solution is to “make objects divisible” by allowing randomization and ensure that the division is fair ex-ante.

While approximate or ex-ante fairness are reasonable when allocating low-value objects, such as seats in a course or in a school, they are not suitable for high-value objects, e.g., houses or precious jewels. Think of a divorcing couple deciding how to split children, or two siblings who have to divide three houses among them; it is unlikely that one of them will agree to receive a bundle that is envy-free except one child/house, or a lottery that gives either one or two with equal probability.

In practical cases, when monetary transfers are undesired, the common solution is to find a way to share some of the objects. For example, a shop can be jointly owned by several partners, sharing the costs and revenues of operation. A house can be jointly owned by several people, who live in the house alternately in different times. While such sharing may be inevitable if exact fairness is desired, it may be quite inconvenient due to the overhead in managing the shared property. Therefore, it is desirable to minimize the number of objects that have to be shared.

Our contribution.

The paper advocates a new approach to the problem of fair division:

minimize the number of sharings under the constraints of fairness.

This approach is a compelling alternative to approximate fairness when the objects to be divided are highly valuable and sharing is technically possible (as in all examples above and many other real-life situations) but unwanted.

We consider problems in which objects have to be divided among agents. The objects to be divided may contain both goods and bads, as in the practice of partnership dissolution when valuable assets are often divided together with liabilities. We assume that agents have additive utilities, so the problem can be represented by a valuation matrix, recording the value of each object to each agent. We focus on classic fairness notions such as proportionality (each agent gets a bundle worth at least of the total value) or envy-freeness (each agent weakly prefers his/her bundle to the bundle of any other agent).

In a companion paper (Sandomirskiy and Segal-Halevi, 2019), we assumed that there is an additional requirement of fractional Pareto-optimality (fPO) — no other allocation, with or without sharing, is at least as good for all agents and strictly better for some of them. This is a strong requirement that has two implications:

  1. An upper bound on the number of sharings: for every fPO utility-profile, there is an allocation attaining this profile with at most sharings.

  2. An upper bound on the number of fPO allocations: when is fixed, and the valuations are non-degenerate (for every pair of agents, there are no two objects with the same value-ratio), the number of fPO allocations is polynomial in . Moreover, it is possible to enumerate all such allocations in polynomial time.

These two implications allowed us to design an algorithm for finding an allocation that minimizes the number of sharings, subject to being fPO and fair; the algorithm is polynomial in for non-degenerate valuations.

The present paper focuses on situations in which there is no requirement for fractional-PO. There may be two reasons for dropping the fPO requirement:

  • Allowing allocations with fewer sharings. The agents may prefer a fair allocation with few sharings to a fair+fPO allocation with many sharings.

  • Allowing truthful mechanisms. It is known that no truthful mechanism can guarantee both fairness and Pareto-efficiency (see Section 5); it may be desired to give up efficiency to get truthfulness.

In order to take advantage of these new possibilities, new techniques are needed.

  1. For an upper bound on the number of sharings

    , we can use a different technique based on linear programming. This technique gives us an upper bound of between

    and sharings, depending on the desired fairness criterion.

  2. In contrast, there is no polynomial upper bound on the number of fair allocations, even with non-degenerate valuations. In fact, we show that minimizing the number of sharings subject to fairness is NP-hard even with two agents, with either degenerate or non-degenerate valuations.

The results from both papers are summarized and compared in Table 1.

Sharing minimization without fPO is significantly harder than with fPO; that is why the present paper contains more open problems than solutions.

Valuations
Allocation Sharings Identical Non-degenerate
Proportional at most [Sec.3]
minimal NP-hard [T4.2]
Envy-free at most [Sec.3*]
minimal NP-hard [T4.2]
Equitable at most Weakly-polynomial [Sec.3]
minimal ???
Consensus at most Weakly-polynomial [Sec.5]
minimal NP-hard [T5.2]
Fair and dPO at most ???
minimal NP-hard [T4.2]
Fair and fPO at most when fixed [*]
minimal NP-hard [*] when fixed [*]
Table 1: Run-time complexity of allocating objects among agents (where is fixed), with a bound on the number of sharings. Results denoted by [*] are from Sandomirskiy and Segal-Halevi (2019).

2 Preliminaries

2.1 Agents, objects, and allocations

There is a set of agents and a set of divisible objects. A bundle

of objects is a vector

, where the component represents the portion of in the bundle (the total amount of each object is normalized to ).

Each agent has an additive utility function over bundles: . Here is agent ’s value of receiving the whole object ; the matrix is called the valuation matrix; it encodes the information about agents’ preferences and is used below as the input of fair division algorithms. The total value of agent to all objects is denoted by .

We make no assumptions on valuation matrix and allow values of mixed signs: for example, the same object can bring positive value to some agents and negative to others.

An allocation is a collection of bundles , one for each agent, with the condition that all the objects are fully allocated. An allocation can be identified with the matrix such that all and for each .

Fairness and efficiency concepts

The two fundamental notions of fairness, taking preferences of agents into account, are envy-freeness and a weaker concept of proportionality (also known as equal split lower bound or fair share guarantee).

An allocation is called proportional if each agent prefers her bundle to the equal division: .

An allocation is called envy-free (EF) if every agent prefers her bundle to the bundles of others. Formally, for all : . Every envy-free allocation is also proportional; with agents, envy-freeness and proportionality are equivalent.

An allocation is called equitable if it gives each agent exactly the same relative value, defined as the value of the bundle divided by the total value: : .

The idea that the objects must be allocated in the efficient, non-improvable way is captured by Pareto-optimality. An allocation is Pareto-dominated by an allocation if gives at least the same utility to all agents and strictly more to at least one of them.

An allocation is fractionally Pareto-optimal (fPO) if it is not dominated by any feasible . It is discrete Pareto-optimal (dPO) if it is not dominated by any feasible with . fPO implies dPO but not vice-versa.

2.2 Measures of sharing

If for some , , then the object is not shared — it is fully allocated to agent . Otherwise, object is shared between two or more agents. Throughout the paper, we consider two measures quantifying the amount of sharing in a given allocation

The simplest one is the number of shared objects:

Alternatively, one can take into account the number of times each object is shared. This is captured by the number of sharings

For “indivisible” allocations both measures are zero, but they differ, for example, if only one object is shared but each agent consumes a bit of : the number of shared objects in this case is while the number of sharings is . Clearly, the number of shared objects is always at most the number of sharings.

3 Worst-case Bounds on Sharing

Several previous works have used combinatorial arguments to prove an upper bound of on the number of sharings, given the additional requirement of fractional-PO (Bogomolnaia et al., 2016, Barman and Krishnamurthy, 2018). Some of these results are generalized in the companion paper (Sandomirskiy and Segal-Halevi, 2019).

Since the present paper does not require fPO, we present below an alternative proof that uses a more general technique. The technique relies on the following known fact: a bounded feasible linear program with constraints has a basic feasible solution — a solution in which at most variables are non-zero (Matousek and Gärtner, 2007). The technique was first applied to fair division by Wilson (1998). The theorem below generalizes his results.

Theorem 3.1.

For any feasible allocation :

(a) There exists a feasible allocation with at most sharings in which each agent receives exactly the same utility: . The is tight even for shared objects.

(b) There exists a feasible allocation with at most sharings in which each agent receives at least as much utility: . The is tight even for shared objects.

Proof.

For each , define the constant .

(a) The allocation can be found using an LP in which the variables are the for all , and the constraints (besides the non-negativity constraints ) are:

  • feasibility constraints: for all .

  • value constraints: for all .

It is feasible ( satisfies it) and has constraints, so it has a solution in which at most variables are non-zero: . By definition of sharing, .

For tightness, consider an instance with agents and goods, where agent values good at and the other goods at . Let be the allocation giving each agent of each good. This allocation has sharings and gives each agent a utility of exactly . But no allocation with less than shared objects can attain exactly the same utilities: if object is given entirely to agent , then agent ’s utility is more than ; if it is given entirely to another agent, then agent ’s utility is at most .

(b) The above LP can be modified by removing the constraint for agent , and maximizing agent ’s utility instead:

maximize (3.1)
subject to

It has a feasible solution () in which the objective value is , so in every optimal solution the utility of agent is at least and the utility of each agent is exactly . The LP has constraints, so it has a solution with at most non-zeros. This solution satisfies .

For tightness, consider an instance with agents and goods whose value for all agents is . Let be the allocation that gives each agent of each good. This allocation has sharings and gives each agent a utility of . But in any allocation with less than shared objects, at least one object is given entirely to some agent, and thus the remaining agents must share a total value of at most ; thus at least one remaining agent gets less than . ∎

Note that Theorem 3.1 holds whether the valuations are positive, negative or mixed.

Theorem 3.1 raises the computational question of how to find an allocation satisfying the worst-case upper bound on sharing. The simplex method finds such solutions for any LP, and it may be sufficient for all practical purposes, but its worst-case run-time is exponential. Khachiyan (1980) showed that the ellipsoid method can be used to find an optimal basic feasible solution in weakly-polynomial time, but its practical performance is not very good. Interior-point methods perform better both theoretically and practically, but they may find an interior solution (with many nonzeros) rather than a basic feasible solution. Megiddo (1991) gives a strongly-polynomial time that, given a pair of optimal solutions for the primal and dual problems, finds an optimal basic feasible solution.222 The above references are based on an answer by Kevin Dalmeijer from Operations Research Stack Exchange (https://or.stackexchange.com/a/3129/2576). Bixby and Saltzman (1994) give a different algorithm for the same task, that performs well in practice but does not have good worst-case run-time guarantees.

All the above algorithms still require a solution to the original LP, for which we currently have only weakly-polynomial algorithms. In some special cases, more efficient algorithms are possible.

Proportionality.

With the allocation giving each agent of each object, part (b) implies the existence of a proportional allocation with at most sharings. Such an allocation can be found efficiently by reduction to cake-cutting. Arrange the objects arbitrarily on an interval, where each object corresponds to a homogeneous sub-interval. A connected partition makes cuts and hence at most objects are shared. When all valuations are positive or all valuations are negative, a connected proportional allocation can be found using operations by the Even-Paz protocol (Even and Paz, 1984). When the valuations are mixed, a connected proportional allocation can be found using using operations by the Last Diminisher protocol (Steinhaus, 1948).

Envy-freeness.

The existence of envy-free allocations with at most sharing does not follow directly from Theorem 3.1. For all-positive or all-negative valuations, it can be deduced by a reduction to the problem of envy-free cake-cutting with connected pieces (similarly to the reduction for proportionality). The existence of such allocations was proved by Stromquist (1980) and Su (1999). For general cakes, connected envy-free allocations cannot be found using a finite number of queries (Stromquist, 2008). However, for piecewise-homogeneous cakes, such as the ones generated from the above reduction, Alijani et al. (2017) show an algorithm that finds such allocations in time ; we do not know whether polynomial-time algorithms exist.

Another way to deduce the existence of envy-free allocations with sharings, as explained in the companion paper, is from results on existence of a competitive equilibrium (CE) with equal incomes (EI). A CEEI is always envy-free. Moreover, competitive equilibria satisfy the property of Pareto-indifference: if is a CE and gives the same utilities to all agents, then is a CE too. Existence of CE for problems with arbitrary mixed valuations was proved in Bogomolnaia et al. (2017). But, polynomial-time algorithms for computing CE are known only for restricted cases:

  • For strictly-positive valuations, Orlin (2010) shows an algorithm that finds a CE in operations.

  • For negative valuations, Branzei and Sandomirskiy (2019) show an algorithm that finds a CE in operations.

Equitability.

It is easy to write an LP that finds an equitable allocation in which the equitable value is maximized (Wilson, 1998). The existence of such an allocation with sharings does not follow directly from Theorem 3.1(b). However, the same LP that finds the maximum equitable value already has constraints:

  • feasibility constraints;

  • equitability constraints: for all .

Hence a max-equitable allocation with sharings exists. Currently, we do not know a strongly-polynomial algorithm for finding such an allocation.

Different entitlements.

All fairness properties can be generalized to situations in which agents have different entitlements. For each , let denote the entitlement of agent , where . Then an allocation is proportional if for all , envy-free if for all : , and equitable if for all : .

With the allocation giving each agent a fraction of each resource, Theorem 3.1(b) implies the existence of a proportional allocation with at most sharings. However, in contrast to the case of equal entitlements, it is not possible to compute such an allocation by reduction to cake-cutting, since for some vectors of entitlements, there may be no connected cake-allocation that satisfies the generalized proportionality property (Segal-Halevi, 2019, Crew et al., 2019).

Existence for both proportionality and envy-freeness can be derived from the existence of a CE with different incomes: when the income of each agent is , any CE is both envy-free and proportional.

Open problem 1.

All computational results stated above are derived by adding strong constraints, such as connectivity or competitive-equilibrium. It is very reasonable that without these constraints faster algorithms are possible. What is the run-time complexity of finding an allocation with at most sharings that is:

(a) Proportional?

(b) Envy-free?

(c) Equitable?

(d) Proportional/envy-free/equitable with different entitlements?

4 Minimizing the Sharing

In the worst case a fair division might require sharings, but in some cases it may be possible to find a fair allocation with fewer sharings. For general linear programs, finding a solution with a minimal number of nonzero variables is known to be NP-hard and hard to approximate (see Appendix A). But this does not rule out the possibility of minimizing the number of nonzero variables in specific linear programs related to fairness. This invokes the following decision problem.

Definition 4.1.

Given integers and , FairBoundedSharing is the problem of deciding if a given instance with agents admits a fair division with at most sharings.

FairBoundedSharing is obviously in NP. Moreover, FairBoundedSharing is obviously NP-hard, since we can reduce Partition to an instance of FairBoundedSharing in which all agents have identical valuations.

In the companion paper (Sandomirskiy and Segal-Halevi, 2019), we considered the related problem FpoBoundedSharing — deciding if a given instance with agents admits a fair and fractionally-PO division with at most sharings. Here, too, FpoBoundedSharing is NP-hard by the same reduction from Partition, since when all agents have identical valuations, all allocations are fPO. However, contrary to intuition, we revealed that the case of identical valuations is computationally the hardest case: if the valuations are “sufficiently different” then FpoBoundedSharing can be decided in time when is fixed. “Sufficiently different” means that for every two agents and two objects , the value-ratios are different: (a condition called non-degeneracy). Note that, in the space of all value-matrices, the subset of degenerate matrices has a measure of zero; the hard case of identical valuations is a knife-edge case. Informally one can say that “almost all instances of FpoBoundedSharing are easy” (= decidable in polynomial time when is fixed).

Is it also true that “almost all instances of FairBoundedSharing are easy”? Below we show that the answer is no: when the fPO requirement is removed, or even just weakened to dPO, computational hardness strikes already for two agents, even for non-degenerate valuations.

4.1 Finding a fair allocation with zero sharings

Theorem 4.2.

For any integer , the problem FairBoundedSharing() is NP-complete even for non-degenerate and strictly-positive valuations.

Proof.

By reduction from Partition. Given a Partition instance with positive integers, , with , construct a fair division problem with goods: “number goods” and “personal goods”. There are agents with the following valuations (see Table 2):

Number-goods Personal-goods Total
Alice
Bob
“personal agents”
Table 2: Values for proof of Theorem 4.2.
  • Alice values each number-good at , and each personal-good at . Hence Alice’s total value is .

  • Bob values each number good at and each personal good at , where the and are small strictly-positive perturbations selected such that the valuations are non-degenerate, and . Bob’s total value is thus too.

  • There are “personal agents”, each of whom values a unique personal good at and all other goods at some small positive number (different for each agent), such that the sum of all such numbers is and the total value is .

If there exists an equal-sum partition of the numbers into two subsets , then there exists an allocation of the goods with no sharings:

  • Bob takes either or for which his value is higher;

  • Alice takes either or for which Bob’s value is lower;

  • Each personal agent takes its unique personal good.

The allocation is envy-free, hence also proportional:

  • Alice does not envy, since she values all bundles at exactly .

  • Bob does not envy Alice since he values his bundle more then hers; he does not envy the other agents, since his bundle is worth more than and the personal goods are worth for him less than .

  • The personal agents do not envy since they value their personal goods at and the other bundles at less than .

Conversely, suppose there exists a proportional allocation (obviously the same argument holds if there exists an envy-free allocation). In any proportional allocation, each agent must get a value of at least . Therefore each personal good must be given to its corresponding agent. Now, both Alice and Bob must be given a value of at least from the number goods. We claim that Alice’s value must be exactly . This is because, if Alice’s value is at least , then Alice’s valuation of Bob’s bundle is at most . But the difference between Alice’s and Bob’s values is at most , so Bob’s value of his own bundle is at most , contradicting proportionality. Hence, the bundles of Alice and Bob correspond to an equal partition of the numbers . ∎

Remark 4.3.

The hardness remains even if we add the requirement of discrete PO. It is sufficient to adapt the first part of the above proof: we have to prove that, if there exists an equal-sum partition of the numbers, then there exists a dPO+EF allocation of the goods with no sharings.

Let be the EF allocation constructed in the proof. If is also dPO then we are done. Otherwise, let be a dPO allocation that Pareto-dominates . We claim that is EF too:

  • Since dominates , each of the personal-agents must have a value of at least , so he must still get his personal-good. Hence, the personal agents still do not envy. This also implies that Alice and Bob still get all and only the number-goods.

  • Alice’s value must be at least . Hence, her valuation of Bob’s bundle is at most , so Alice does not envy.

  • Bob’s value must be at large as his value in , so Bob’s valuation of Alice’s bundle is at most as large as in , so Bob does not envy too.

In any case, there exists an envy-free+proportional+dPO allocation with no sharings. ∎

4.2 Finding a fair allocation with one or more sharings

With agents, Theorem 4.2 completely characterizes the computational hardness of sharing minimization: a fair allocation with 1 sharing always exists, and deciding whether a fair allocation with 0 sharings exists is NP-hard.

With agents, the problem of sharing minimization becomes richer, since the minimum number of sharings in a given instance can be anything between and . The smallest case that is not covered by Theorem 4.2 is FairBoundedSharing.

Somewhat surprisingly, in the case of identical valuations, FairBoundedSharing can be solved in polynomial time; this was recently proved by Mikhail Rudoy.333 https://cstheory.stackexchange.com/a/42316/9453 For and , the computational complexity of FairBoundedSharing with identical valuations is still open.

When the valuations are not identical, the hardness result of Theorem 4.2 can be partially generalized.

Theorem 4.4.

For any integers and , FairBoundedSharing is NP-complete for any degeneracy degree, and even when all valuations are strictly-positive.

Proof.

We adapt the reduction in the proof of Theorem 4.2 as follows. There are goods: “number goods” and “personal goods” and “common good”. There are agents: Alice, Bob, “personal agents” and “common agents”. Alice and Bob still value mainly the number goods; each personal-agent still values mainly its unique personal-good; and the new common-agents value only the single common-good. The valuations are described in Table 3, where are small perturbations (as in the proof of Theorem 4.2) selected such that the desired degeneracy degree is attained and that the total value for each agent is .

Number-goods Personal-goods Common-good Total
Alice
Bob
“personal agents”
“common agents”
Table 3: Values for proof of Theorem 4.4.

If there exists an equal-sum partition of the numbers into two subsets , then there exists an allocation of the goods with exactly sharings:

  • Bob takes either or for which his value is higher;

  • Alice takes either or for which Bob’s value is lower;

  • Each of the common agents receives a fraction of the common good;

  • Each of the personal agent receives its unique personal good.

The allocation is envy-free, hence also proportional; the proof is the same as for Theorem 4.2.

Conversely, suppose there exists a proportional allocation with sharings (obviously the same argument holds if there exists an envy-free allocation). In any proportional allocation, each agent must get a value of at least . The only way to give such a value to the common agents is to give each of them a fraction of the common good. Hence, the common good must be shared among the common agents. This generates sharings, so the other goods must be allocated with no sharing. Each personal good must be given to its corresponding personal agent, and the number-goods must be shared between Alice and Bob. Similarly to Theorem 4.2, the bundles of Alice and Bob correspond to an equal partition of the numbers . ∎

Theorem 4.4 leaves open the case . The smallest open case is and .

Open problem 2.

What is the run-time complexity of FairBoundedSharing? of FairBoundedSharing for any ?

Table 4 illustrates the results and open cases for .

Note that Theorem 4.4 considers the number of sharings. If we are interested in the number of shared goods instead, then in the reduction, we should replace the single common-good with common-goods, each of which is valued by all common-agents at approximately . In any envy-free allocation, all common-goods must be shared by all common-agents, so that they do not envy each other. This proves that EnvyFreeBoundedSharedObjects is NP-hard. However, the proof does not work for proportionality, so the run-time complexity of ProportionalBoundedSharedObjects is still open.

Open problem 3.

Given and , what is the run-time complexity of deciding whether a given -agent instance admits a proportional allocation with at most shared objects?

Valuations
Allocation Agents () Sharings () Identical Degenerate Non-degenerate
Fair 2 1 [Sec.3]
0 NP-complete [Thm.4.2]
Fair 3 2 Proportional: [Sec.3]. Envy-free: poly()
1 poly() [ftn.3] ???
0 NP-complete [Thm.4.2]
Fair 4 3 Proportional: [Sec.3]. Envy-free: poly()
2 ???
1 ??? NP-complete [Thm.4.4]
0 NP-complete [Thm.4.2]
Fair+fPO [*] 2 1 O(poly()) [*]
0 NP-complete [*] O(poly()) [*]
Fair+fPO [*] 3 2 O(poly()) [*]
1 poly() [ftn.3] ??? O(poly()) [*]
0 NP-complete [*] O(poly()) [*]
Fair+fPO [*] 4 3 O(poly()) [*]
2 ??? O(poly()) [*]
1 ??? O(poly()) [*]
0 NP-complete [*] O(poly()) [*]
Table 4: Run-time complexity of dividing goods among agents, for small values of . The “degenerate” column refers to valuations that are not identical, but not non-degenerate (for example, two valuations are identical and the third is different). For comparison, we show results for fairness+fPO from Sandomirskiy and Segal-Halevi (2019), denoted by [*].

5 Truthful fair division

A division algorithm is truthful if for every agent , it is a weakly-dominant strategy to report the true values . Truthfulness, fairness, and Pareto-optimality are incompatible, see Zhou (1990). However, truthfulness can be achieved by introducing some inefficiencies. This section surveys several such truthful mechanisms and checks whether any of them can be adapted to minimize the sharing.

5.1 Consensus allocation mechanism

Mossel and Tamuz (2010) present a truthful randomized mechanism which uses a consensus allocation. An allocation is called a consensus allocation if for every two agents : , where . Given a consensus allocation , a permutation over is selected uniformly at random, and the bundle is allocated to agent . Thus, the expected utility of any agent , whether truthful or not, is , so the agent cannot gain by false reporting. Moreover, a truthful agent gets a utility of exactly with certainty, while a non-truthful agent might get more or less than . So for a risk-averse agent, truthfulness is a strictly dominant strategy.

At first glance, consensus allocation requires to share all goods. However, when we can do substantially better.

Theorem 5.1.

In any instance with agents, there exists a consensus allocation with at most sharings. The is tight even for shared objects.

Proof.

The proof is similar to Theorem 3.1 and is based on an LP with the following constraints:

  • feasibility constraints;

  • consensus constraints: for all .

Note that for the equality holds automatically. Since there are constraints, there exists a basic feasible solution with at most sharings.

For tightness, consider an instance with agents and goods. For each agent, of the goods are “big” and the other goods are “small”. Each agent values each of his big goods at and each of his small goods at . All sets of big goods are pairwise-disjoint, so that each good is “big” for exactly one agent and “small” for all other agents. For each agent, the sum of all values is , so in a consensus allocation, the value of each bundle should be exactly . However, the value of each big good to its agent is larger than , so all goods must be shared. ∎

Open problem 4.

Can we find in strongly-polynomial time, a consensus allocation with at most sharings?

Finding a consensus allocation with minimal sharing is NP-hard when the valuations may be identical, by reduction from Partition. Moreover, it is NP-hard even with non-degenerate valuations.

Theorem 5.2.

Deciding whether a given instance admits a consensus allocation with no sharings is NP-complete, even with non-degenerate valuations.

Proof.

Membership in NP is obvious. For hardness, we reduce from DistinctBalancedPartition — a variant of Partition in which the input integers must be distinct and the output parts must have the same cardinality. See Appendix B for a proof that it is NP-hard. Given a DistinctBalancedPartition instance with . Pick any number . Create a fair division problem with goods and two agents with the following valuations:

  • Alice values each good at .

  • Bob values each good at .

For each object , the value-ratio is . Since all the numbers are distinct, the resulting valuations are non-degenerate.

Let be a partition of the numbers into two subsets with equal sum and equal cardinality, . In the induced partition of the objects, we have and , so it is a consensus allocation. Conversely, let be a consensus allocation of the objects. Since , the induced partition of the integers has an equal sum. Since , and is sufficiently small, we must have , so the induced partition of the integers has equal cardinality. ∎

Open problem 5.

The hardness proof of Theorem 5.2 is weaker than that of Theorem 4.2, since it uses only a one-dimensional perturbation. It does not rule out the possibility that all instances except a subset of measure zero are easy.

Combining the algorithm of Mossel and Tamuz (2010) with Theorem 5.1 gives:

Corollary 5.3.

There exists a randomized truthful algorithm that (with certainty) returns an envy-free allocation with at most sharings.

5.2 Partial-allocation and strong-demand mechanisms

Cole et al. (2013a) suggest a different approach to truthful fair division, called Partial Allocation Mechanism (PAM). Their benchmark for fairness is the competitive equilibrium with equal incomes (CEEI), that we already mentioned in Section 3.444They call CEEI the Proportionally-Fair allocation. It is known that, for linear additive valuations, CEEI is equivalent to the Nash-optimal allocation — the allocation maximizing the product of the agents’ utilities. Informally, PAM works as follows.

  1. Find a CEEI allocation .

  2. For each agent , compute the ratio between the product of the other agents’ utilities when is present, and the product of their utilities when is not present.

  3. Give to each agent the bundle (that is, a fraction of each good receives in the original CEEI).

They prove that, under reasonable assumptions, , so each agent is guaranteed at least of his/her CEEI utility.

As explained in Section 3, there always exists a CEEI allocation with at most sharings. However, the process of giving each agent only a fraction of each object is, arguably, equivalent to forcing the agent to share each and every object (e.g. with the mechanism designer, the government or the public). Therefore, it seems that PAM is not compatible with sharing minimization.

Cole et al. (2013a) present a different mechanism called Strong Demand Mechanism (SDM), which is particularly efficient when there are many agents and few goods (as in the case of coupon-based privatization). SDM gives to each agent a fraction of a single good, so all objects are shared. Hence, SDM too does not seem compatible with sharing minimization.

Remark 5.4.

For the case of two agents, Cole et al. (2013b) present a mechanism called MAX, which runs both the consensus-allocation mechanism and the partial-allocation mechanism and returns the outcome with the highest social welfare. They prove that this combination is still truthful and guarantees at least of the optimal social welfare.

5.3 Mechanism for binary valuations

In the problem of fair cake-cutting, most positive results for truthful allocation are designed for the special case in which the agents have piecewise-uniform valuations. the cake is assumed to be an interval; each agent desires a finite set of sub-intervals of the cake, and does not care about the rest of the cake. For this setting, Chen et al. (2013) present a truthful mechanism that guarantees envy-freeness and Pareto-optimality. Informally, the CLPP mechanism proceeds as follows.

  1. For each subset of agents, calculate their average length — the total length of intervals desired by at least one member of .

  2. Pick an with a smallest average length (breaking ties arbitrarily);

  3. Allocate to the members of , all their desired sub-intervals, such that each member of gets a value of exactly the average length (this means that all the desired sub-intervals are allocated to agents who desire them).

  4. Divide the remaining cake recursively among the remaining agents.

  5. Discard all parts of the cake that are undesired by any agent.

In our setting, piecewise-uniform valuations means that each agent assigns to each object a value of either or . Under this assumption, an agent cares only about the total amount he/she gets from desired objects. Therefore, in step 3, the allocation can be implemented using at most sharings. When is the set of all agents, the allocation requires sharings, which is the worst-case upper bound on any fair division.

Corollary 5.5.

For binary valuations, there exists a deterministic truthful algorithm that (with certainty) returns an envy-free and Pareto-optimal allocation with at most sharings.

Open problem 6.

In some situations, it may be possible to attain the same allocation as the CLPP mechanism with less than sharings. Is it possible to minimize the amount of sharing, while keeping the mechanism truthful, envy-free and Pareto-optimal?

5.4 More truthful mechanisms

There are other truthful fair allocation mechanisms. We plan to study them in the future.

6 Related Work

Related work is surveyed in Sandomirskiy and Segal-Halevi (2019).

7 Acknowledgement

This work was inspired by Achikam Bitan, Steven Brams and Shahar Dobzinski, who expressed their dissatisfaction with the current trend of approximate-fairness (SCADA conference, Weizmann Institute, Israel 2018). We are grateful to participants of De Aequa Divisione Workshop on Fair Division (LUISS, Rome, 2019), Workshop on Theoretical Aspects of Fairness (WTAF, Patras, 2019) and the rationality center game theory seminar (HUJI, Jerusalem, 2019) for their helpful comments. Suggestions of Herve Moulin, Antonio Nicolo, and Nisarg Shah were especially useful.

provided very helpful answers, in particular: D.W, Peter Taylor, Gamow, Sasho Nikolov, Chao Xu, Mikhail Rudoy, xskxzr, Philipp Christophel and Kevin Dalmeijer .

We are grateful to an anonymous referee of WTAF 2019 for helpful comments and to Lillian Bluestein for proofreading the early version.

Fedor’s work was partially supported by the Lady Davis Foundation, by Grants 16-01-00269 and 19-01-00762 of the Russian Foundation for Basic Research, by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement n740435), and by the Basic Research Program of the National Research University Higher School of Economics.

Appendix

Appendix A Linear Programming and Bounded Sharings

The above proof raises the question of whether the minimization problem (finding an allocation minimizing the number of sharings) can also be found using LP techniques. For this, it could be very helpful to have an algorithm for finding the smallest number of nonzero variables in a given LP. This problem is called Min-RVLS — Minimum Relevant Variables in a Linear System. Unfortunately, Min-RVLS is NP-hard, and it is also hard to find multiplicative approximations to the minimum (Amaldi and Kann, 1998).

Moreover, even finding a very modest additive approximation is NP-hard:

Theorem A.1.

Unless P=NP, there is no polynomial-time algorithm that accepts as input a linear program with constraints and decides whether it has a feasible solution with at most nonzero variables.

Proof.

The proof is by reduction from Partition. Suppose we are given numbers whose total sum is , and have to decide whether they can be partitioned into two subsets such that the sum in each subset is . We can solve this problem using a linear program with variables. For each and , the variable determines what fraction of the number is in subset . There are constraints (besides non-negativity):

  • For each : .

  • The equal-sum constraint:

There always exists a solution with at most nonzeros. In this solution, at most one number is “cut” between the sets. Indeed, it is easy to solve the partition problem if we are allowed to cut one number: just order the numbers on a line and cut the line into two parts with equal sum.

Now, if we could solve the “few nonzeros” problem, then we could decide whether the above LP has a solution with at most nonzeros, which would imply a solution to the partition problem (in which no number is cut). ∎

Remark A.2.

Partition is considered “the easiest NP-hard problem” and there are several algorithms that solve it very fast in practice (Schreiber et al., 2018). So, while “few nonzeros” is NP-hard, it may still be easy in practice. Alternatively, it may be possible to reduce to “few nonzeros” from a harder NP-hard problem; its exact hardness is still open.

Appendix B NP-hardness of Distinct-Balanced-Partition

In the DistinctBalancedPartition problem, the input is distinct positive integers with sum , and the goal is to decide whether there is a subset of integers that sum up to .

Theorem B.1.

DistinctBalancedPartition is NP-hard.

Proof.

There is a known reduction from Partition to DistinctPartition.555 See Yuval Filmus’ answer here: https://cs.stackexchange.com/a/13032/1342 We now show a reduction from DistinctPartition to DistinctBalancedPartition. Let the positive integers be an instance of DistinctPartition, and assume that their sum is . We create an instance of DistinctBalancedPartition with the following numbers:

  • big numbers: for each .

  • small numbers: triplets of numbers, where triplet contains and two integers whose sum is , for example: .

In the new instance, there are numbers; the sum of the big numbers is and the sum of the small numbers is , so the goal is to find a subset of numbers with a sum of .

Note that all big numbers are distinct (since all are), all small numbers are distinct as well by the construction, and the largest small number () is smaller than the smallest large number (), so no two numbers coincide.

Every large number is a multiple of , which is larger than the sum of all small numbers. Hence, in every solution to the DistinctBalancedPartition instance, the sum of all big numbers must be , so it constitutes a solution to the DistinctPartition.

Conversely, suppose we are given a solution to the DistinctPartition instance — a subset with (for some ) and . Without loss of generality, we assume that , since otherwise we can just replace with its complement, whose sum is too.

We construct a solution to DistinctBalancedPartition by taking the big numbers corresponding to , and adding small numbers as follows:

  • From the first triplets of small numbers, we take the ;

  • From the last triplets of small numbers, we take the two smaller numbers whose sum is .

The number of elements in the generated set is . The sum of the generated set is . Hence it is indeed a solution to DistinctBalancedPartition. ∎

References

  • Alijani et al. (2017) Reza Alijani, Majid Farhadi, Mohammad Ghodsi, Masoud Seddighin, and Ahmad S Tajik. Envy-free mechanisms with minimum number of cuts. In AAAI, pages 312–318, 2017.
  • Amaldi and Kann (1998) Edoardo Amaldi and Viggo Kann. On the approximability of minimizing nonzero variables or unsatisfied relations in linear systems. Theoretical Computer Science, 209(1-2):237–260, 1998.
  • Barman and Krishnamurthy (2018) Siddharth Barman and Sanath Kumar Krishnamurthy. On the proximity of markets with integral equilibria, 2018.
  • Bixby and Saltzman (1994) Robert E Bixby and Matthew J Saltzman. Recovering an optimal lp basis from an interior point solution. Operations Research Letters, 15(4):169–178, 1994.
  • Bogomolnaia et al. (2016) Anna Bogomolnaia, Herve Moulin, Fedor Sandomirskiy, and Elena Yanovskaya. Dividing goods or bads under additive utilities, 2016.
  • Bogomolnaia et al. (2017) Anna Bogomolnaia, Herve Moulin, Fedor Sandomirskiy, and Elena Yanovskaya. Competitive division of a mixed manna. Econometrica, 85(6):1847–1871, February 2017. URL http://arxiv.org/abs/1702.00616. arXiv preprint 1702.00616.
  • Branzei and Sandomirskiy (2019) Simina Branzei and Fedor Sandomirskiy. Algorithms for competitive division of chores, 2019.
  • Chen et al. (2013) Yiling Chen, John K. Lai, David C. Parkes, and Ariel D. Procaccia. Truth, justice, and cake cutting. Games and Economic Behavior, 77(1):284–297, January 2013. ISSN 08998256. doi: 10.1016/j.geb.2012.10.009. URL http://dx.doi.org/10.1016/j.geb.2012.10.009.
  • Cole et al. (2013a) Richard Cole, Vasilis Gkatzelis, and Gagan Goel. Mechanism design for fair division: allocating divisible items without payments. In Proceedings of the fourteenth ACM conference on Electronic commerce, pages 251–268. ACM, 2013a.
  • Cole et al. (2013b) Richard Cole, Vasilis Gkatzelis, and Gagan Goel. Positive results for mechanism design without money. In Proceedings of the 2013 international conference on Autonomous agents and multi-agent systems, pages 1165–1166. International Foundation for Autonomous Agents and Multiagent Systems, 2013b.
  • Crew et al. (2019) Logan Crew, Bhargav Narayanan, and Sophie Spirkl. Disproportionate division. 2019. arXiv preprint 1909.07141.
  • Even and Paz (1984) Shimon Even and Azaria Paz. A Note on Cake Cutting. Discrete Applied Mathematics, 7(3):285–296, March 1984. ISSN 0166218X. doi: 10.1016/0166-218x(84)90005-2. URL http://dx.doi.org/10.1016/0166-218x(84)90005-2.
  • Khachiyan (1980) Leonid G Khachiyan. Polynomial algorithms in linear programming. USSR Computational Mathematics and Mathematical Physics, 20(1):53–72, 1980.
  • Matousek and Gärtner (2007) Jiri Matousek and Bernd Gärtner. Understanding and using linear programming. Springer Science & Business Media, 2007.
  • Megiddo (1991) Nimrod Megiddo. On finding primal-and dual-optimal bases. ORSA Journal on Computing, 3(1):63–65, 1991.
  • Mossel and Tamuz (2010) Elchanan Mossel and Omer Tamuz. Truthful Fair Division. In Spyros Kontogiannis, Elias Koutsoupias, and Paul G. Spirakis, editors, SAGT, volume 6386, pages 288–299, Berlin, Heidelberg, July 2010. Springer Berlin Heidelberg. ISBN 978-3-642-16169-8. doi: 10.1007/978-3-642-16170-4_25. URL http://dx.doi.org/10.1007/978-3-642-16170-4_25.
  • Orlin (2010) James B Orlin. Improved algorithms for computing fisher’s market clearing prices: computing fisher’s market clearing prices. In

    Proceedings of the forty-second ACM symposium on Theory of computing

    , pages 291–300. ACM, 2010.
  • Sandomirskiy and Segal-Halevi (2019) Fedor Sandomirskiy and Erel Segal-Halevi. Efficient fair division with minimal sharing, 2019. arXiv preprint 1908.01669.
  • Schreiber et al. (2018) Ethan L Schreiber, Richard E Korf, and Michael D Moffitt. Optimal multi-way number partitioning. Journal of the ACM (JACM), 65(4):24, 2018.
  • Segal-Halevi (2019) Erel Segal-Halevi. Cake-Cutting with Different Entitlements: How Many Cuts are Needed? Journal of Mathematical Analysis and Applications, 480(1):123382, 2019. doi: 10.1016/j.jmaa.2019.123382. arXiv preprint 1803.05470.
  • Steinhaus (1948) Hugo Steinhaus. The problem of fair division. Econometrica, 16(1):101–104, jan 1948. URL http://www.jstor.org/stable/1914289.
  • Stromquist (1980) Walter Stromquist. How to Cut a Cake Fairly. The American Mathematical Monthly, 87(8):640–644, October 1980. ISSN 00029890. doi: 10.2307/2320951. URL http://dx.doi.org/10.2307/2320951.
  • Stromquist (2008) Walter Stromquist. Envy-free cake divisions cannot be found by finite protocols. Electronic Journal of Combinatorics, 15(1):#R11, January 2008. URL http://www.emis.ams.org/journals/EJC/Volume_15/PDF/v15i1r11.pdf. Research paper 11, 10 pp., 91B32.
  • Su (1999) Francis E. Su. Rental Harmony: Sperner’s Lemma in Fair Division. The American Mathematical Monthly, 106(10):930–942, December 1999. ISSN 00029890. doi: 10.2307/2589747. URL http://www.math.hmc.edu/{̃}su/papers.dir/rent.pdf.
  • Wilson (1998) Stephen J Wilson. Fair division using linear programming. preprint, Departement of Mathematics, Iowa State University, 1998.
  • Zhou (1990) Lin Zhou. On a conjecture by gale about one-sided matching problems. Journal of Economic Theory, 52(1):123–135, 1990.