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 approximatelyfair allocation. There are several definitions of approximate fairness, the most common of which are envyfreeness 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 exante.
While approximate or exante fairness are reasonable when allocating lowvalue objects, such as seats in a course or in a school, they are not suitable for highvalue 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 envyfree 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 reallife 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 envyfreeness (each agent weakly prefers his/her bundle to the bundle of any other agent).
In a companion paper (Sandomirskiy and SegalHalevi, 2019), we assumed that there is an additional requirement of fractional Paretooptimality (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:

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

An upper bound on the number of fPO allocations: when is fixed, and the valuations are nondegenerate (for every pair of agents, there are no two objects with the same valueratio), 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 nondegenerate valuations.
The present paper focuses on situations in which there is no requirement for fractionalPO. 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 Paretoefficiency (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.

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. 
In contrast, there is no polynomial upper bound on the number of fair allocations, even with nondegenerate valuations. In fact, we show that minimizing the number of sharings subject to fairness is NPhard even with two agents, with either degenerate or nondegenerate 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  Nondegenerate 
Proportional  at most  [Sec.3]  
minimal  NPhard [T4.2]  
Envyfree  at most  [Sec.3*]  
minimal  NPhard [T4.2]  
Equitable  at most  Weaklypolynomial [Sec.3]  
minimal  ???  
Consensus  at most  Weaklypolynomial [Sec.5]  
minimal  NPhard [T5.2]  
Fair and dPO  at most  ???  
minimal  NPhard [T4.2]  
Fair and fPO  at most  when fixed [*]  
minimal  NPhard [*]  when fixed [*] 
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 envyfreeness 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 envyfree (EF) if every agent prefers her bundle to the bundles of others. Formally, for all : . Every envyfree allocation is also proportional; with agents, envyfreeness 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, nonimprovable way is captured by Paretooptimality. An allocation is Paretodominated 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 Paretooptimal (fPO) if it is not dominated by any feasible . It is discrete Paretooptimal (dPO) if it is not dominated by any feasible with . fPO implies dPO but not viceversa.
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 Worstcase 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 fractionalPO (Bogomolnaia et al., 2016, Barman and Krishnamurthy, 2018). Some of these results are generalized in the companion paper (Sandomirskiy and SegalHalevi, 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 nonzero (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 nonnegativity 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 nonzero: . 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 nonzeros. 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 worstcase upper bound on sharing. The simplex method finds such solutions for any LP, and it may be sufficient for all practical purposes, but its worstcase runtime is exponential. Khachiyan (1980) showed that the ellipsoid method can be used to find an optimal basic feasible solution in weaklypolynomial time, but its practical performance is not very good. Interiorpoint 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 stronglypolynomial time that, given a pair of optimal solutions for the primal and dual problems, finds an optimal basic feasible solution.^{2}^{2}2 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 worstcase runtime guarantees.
All the above algorithms still require a solution to the original LP, for which we currently have only weaklypolynomial 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 cakecutting. Arrange the objects arbitrarily on an interval, where each object corresponds to a homogeneous subinterval. 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 EvenPaz 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).
Envyfreeness.
The existence of envyfree allocations with at most sharing does not follow directly from Theorem 3.1. For allpositive or allnegative valuations, it can be deduced by a reduction to the problem of envyfree cakecutting 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 envyfree allocations cannot be found using a finite number of queries (Stromquist, 2008). However, for piecewisehomogeneous 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 polynomialtime algorithms exist.
Another way to deduce the existence of envyfree 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 envyfree. Moreover, competitive equilibria satisfy the property of Paretoindifference: 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, polynomialtime algorithms for computing CE are known only for restricted cases:
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 maxequitable allocation with sharings exists. Currently, we do not know a stronglypolynomial 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 , envyfree 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 cakecutting, since for some vectors of entitlements, there may be no connected cakeallocation that satisfies the generalized proportionality property (SegalHalevi, 2019, Crew et al., 2019).
Existence for both proportionality and envyfreeness can be derived from the existence of a CE with different incomes: when the income of each agent is , any CE is both envyfree and proportional.
Open problem 1.
All computational results stated above are derived by adding strong constraints, such as connectivity or competitiveequilibrium. It is very reasonable that without these constraints faster algorithms are possible. What is the runtime complexity of finding an allocation with at most sharings that is:
(a) Proportional?
(b) Envyfree?
(c) Equitable?
(d) Proportional/envyfree/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 NPhard 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 NPhard, since we can reduce Partition to an instance of FairBoundedSharing in which all agents have identical valuations.
In the companion paper (Sandomirskiy and SegalHalevi, 2019), we considered the related problem FpoBoundedSharing — deciding if a given instance with agents admits a fair and fractionallyPO division with at most sharings. Here, too, FpoBoundedSharing is NPhard 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 valueratios are different: (a condition called nondegeneracy). Note that, in the space of all valuematrices, the subset of degenerate matrices has a measure of zero; the hard case of identical valuations is a knifeedge 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 nondegenerate valuations.
4.1 Finding a fair allocation with zero sharings
Theorem 4.2.
For any integer , the problem FairBoundedSharing() is NPcomplete even for nondegenerate and strictlypositive 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):
Numbergoods  Personalgoods  Total  
Alice  
Bob  
“personal agents” 

Alice values each numbergood at , and each personalgood at . Hence Alice’s total value is .

Bob values each number good at and each personal good at , where the and are small strictlypositive perturbations selected such that the valuations are nondegenerate, 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 equalsum 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 envyfree, 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 envyfree 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 equalsum 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 Paretodominates . We claim that is EF too:

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

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 envyfree+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 NPhard.
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.^{3}^{3}3 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 NPcomplete for any degeneracy degree, and even when all valuations are strictlypositive.
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 personalagent still values mainly its unique personalgood; and the new commonagents value only the single commongood. 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 .
Numbergoods  Personalgoods  Commongood  Total  

Alice  
Bob  
“personal agents”  
“common agents” 
If there exists an equalsum 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 envyfree, 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 envyfree 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 numbergoods 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 runtime 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 commongood with commongoods, each of which is valued by all commonagents at approximately . In any envyfree allocation, all commongoods must be shared by all commonagents, so that they do not envy each other. This proves that EnvyFreeBoundedSharedObjects is NPhard. However, the proof does not work for proportionality, so the runtime complexity of ProportionalBoundedSharedObjects is still open.
Open problem 3.
Given and , what is the runtime complexity of deciding whether a given agent instance admits a proportional allocation with at most shared objects?
Valuations  
Allocation  Agents ()  Sharings ()  Identical  Degenerate  Nondegenerate 
Fair  2  1  [Sec.3]  
0  NPcomplete [Thm.4.2]  
Fair  3  2  Proportional: [Sec.3]. Envyfree: poly()  
1  poly() [ftn.3]  ???  
0  NPcomplete [Thm.4.2]  
Fair  4  3  Proportional: [Sec.3]. Envyfree: poly()  
2  ???  
1  ???  NPcomplete [Thm.4.4]  
0  NPcomplete [Thm.4.2]  
Fair+fPO [*]  2  1  O(poly()) [*]  
0  NPcomplete [*]  O(poly()) [*]  
Fair+fPO [*]  3  2  O(poly()) [*]  
1  poly() [ftn.3]  ???  O(poly()) [*]  
0  NPcomplete [*]  O(poly()) [*]  
Fair+fPO [*]  4  3  O(poly()) [*]  
2  ???  O(poly()) [*]  
1  ???  O(poly()) [*]  
0  NPcomplete [*]  O(poly()) [*] 
5 Truthful fair division
A division algorithm is truthful if for every agent , it is a weaklydominant strategy to report the true values . Truthfulness, fairness, and Paretooptimality 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 nontruthful agent might get more or less than . So for a riskaverse 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 pairwisedisjoint, 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 stronglypolynomial time, a consensus allocation with at most sharings?
Finding a consensus allocation with minimal sharing is NPhard when the valuations may be identical, by reduction from Partition. Moreover, it is NPhard even with nondegenerate valuations.
Theorem 5.2.
Deciding whether a given instance admits a consensus allocation with no sharings is NPcomplete, even with nondegenerate 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 NPhard. 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 valueratio is . Since all the numbers are distinct, the resulting valuations are nondegenerate.
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.
Corollary 5.3.
There exists a randomized truthful algorithm that (with certainty) returns an envyfree allocation with at most sharings.
5.2 Partialallocation and strongdemand 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.^{4}^{4}4They call CEEI the ProportionallyFair allocation. It is known that, for linear additive valuations, CEEI is equivalent to the Nashoptimal allocation — the allocation maximizing the product of the agents’ utilities. Informally, PAM works as follows.

Find a CEEI allocation .

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.

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 couponbased 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 consensusallocation mechanism and the partialallocation 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 cakecutting, most positive results for truthful allocation are designed for the special case in which the agents have piecewiseuniform valuations. the cake is assumed to be an interval; each agent desires a finite set of subintervals 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 envyfreeness and Paretooptimality. Informally, the CLPP mechanism proceeds as follows.

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

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

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

Divide the remaining cake recursively among the remaining agents.

Discard all parts of the cake that are undesired by any agent.
In our setting, piecewiseuniform 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 worstcase upper bound on any fair division.
Corollary 5.5.
For binary valuations, there exists a deterministic truthful algorithm that (with certainty) returns an envyfree and Paretooptimal 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, envyfree and Paretooptimal?
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 SegalHalevi (2019).
7 Acknowledgement
This work was inspired by Achikam Bitan, Steven Brams and Shahar Dobzinski, who expressed their dissatisfaction with the current trend of approximatefairness (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 160100269 and 190100762 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 MinRVLS — Minimum Relevant Variables in a Linear System. Unfortunately, MinRVLS is NPhard, 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 NPhard:
Theorem A.1.
Unless P=NP, there is no polynomialtime 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 nonnegativity):

For each : .

The equalsum 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 NPhard problem” and there are several algorithms that solve it very fast in practice (Schreiber et al., 2018). So, while “few nonzeros” is NPhard, it may still be easy in practice. Alternatively, it may be possible to reduce to “few nonzeros” from a harder NPhard problem; its exact hardness is still open.
Appendix B NPhardness of DistinctBalancedPartition
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 NPhard.
Proof.
There is a known reduction from Partition to DistinctPartition.^{5}^{5}5 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. Envyfree 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(12):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 multiagent 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/0166218x(84)900052. URL http://dx.doi.org/10.1016/0166218x(84)900052.
 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 primaland dualoptimal 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 9783642161698. doi: 10.1007/9783642161704_25. URL http://dx.doi.org/10.1007/9783642161704_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 fortysecond ACM symposium on Theory of computing
, pages 291–300. ACM, 2010.  Sandomirskiy and SegalHalevi (2019) Fedor Sandomirskiy and Erel SegalHalevi. 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 multiway number partitioning. Journal of the ACM (JACM), 65(4):24, 2018.
 SegalHalevi (2019) Erel SegalHalevi. CakeCutting 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. Envyfree 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 onesided matching problems. Journal of Economic Theory, 52(1):123–135, 1990.
Comments
There are no comments yet.