Consensus splitting

Consensus splitting, also called exact division,  is a partition of a continuous resource ("cake") into some k pieces, such that each of n people with different tastes agree on the value of each of the pieces. For example, consider a cake which is half chocolate and half vanilla. Alice values only the chocolate and George values only the vanilla. The cake is divided into three pieces: one piece contains 20% of the chocolate and 20% of the vanilla, the second contains 50% of the chocolate and 50% of the vanilla, and the third contains the rest of the cake. This is an exact division (with k = 3 and n = 2), as both Alice and George value the three pieces as 20%, 50% and 30% respectively. Several common variants and special cases are known by different terms:
 * Consensus halving – the cake should be partitioned into two pieces (k = 2), and all agents agree that the pieces have equal values.
 * Consensus 1/k-division, for any constant k > 1 – the cake should be partitioned into k pieces, and all agents agree that the pieces have equal values.  Another term is consensus splitting.
 * Perfect division – the number of pieces equals the number of agents: the cake should be partitioned into n pieces, and all agents agrees that all pieces have equal values.
 * $$\varepsilon$$-near-exact division, for any constant $$\varepsilon>0$$, the agents may disagree on the pieces values, but the difference between the values should be at most $$\varepsilon$$. Similarly, the approximate variants of the above-mentioned problems are called $$\varepsilon$$-consensus-halving, $$\varepsilon$$-consensus 1/k-division or $$\varepsilon$$-consensus-splitting, and $$\varepsilon$$-perfect-division.
 * Problem of the Nile – there are infinitely many agents.
 * Necklace splitting – the resource to divide is made of a finite number of indivisible objects ("beads").

When both n and k are finite, Consensus divisions always exist. However, they cannot be found by discrete protocols (with a finite number of queries). In some cases, exact divisions can be found by moving-knife protocols. Near-exact divisions can be found by discrete protocols.

Definitions
Let $$w_1, w_2, \ldots, w_k$$ be k weights whose sum is 1. Assume there are n agents, all of whom value the cake C as 1. The value measure of agent i is denoted by $$V_i$$. It is assumed to be a nonatomic measure on C. An exact division in the ratios $$w_1, w_2, \ldots, w_k$$ is a partition of the cake into k pieces: $$C = X_1 \sqcup \cdots \sqcup X_k$$, such that for every agent i and every piece j:
 * $$V_i(X_j)=w_j$$

It is also called a consensus division, since there is a consensus among all agents that the value of piece j is exactly $$w_j$$. Some special cases are:
 * Consensus 1/k division – the special case in which $$w_1 = \cdots = w_n= 1/k$$.
 * Consensus halving – the special case in which $$k=2$$ and $$w_1=w_2 = 1/2$$.
 * Perfect division – the special case in which $$k=n$$ and $$w_1=\cdots=w_n = 1/n$$.

Near-exact division
For every $$\varepsilon>0$$, An $$\varepsilon$$-near-exact division in the ratios $$w_1, w_2, \ldots, w_k$$ is a division in which:
 * $$|V_i(X_j)-w_j| < \varepsilon$$

That is, there is a consensus among all partners that the value of piece j is nearly-exactly $$w_j$$, where the difference is less than $$\varepsilon$$. Some special cases are:
 * $$\varepsilon$$-consensus 1/k division – the special case in which $$w_1 = \cdots = w_n= 1/k$$.
 * $$\varepsilon$$-consensus halving – the special case in which $$k=2$$ and $$w_1=w_2 = 1/2$$.
 * $$\varepsilon$$-perfect division – the special case in which $$k=n$$ and $$w_1=\cdots=w_n = 1/n$$.

Unbounded number of cuts
It is easy to prove the existence of an exact division when the agents have piecewise-constant valuations. This means that the cake can be partitioned into R regions, such that all agents agree that the value-density in each region is uniform. For example, consider a circular cake in which each of its 4 quarters has a different topping. The agents may value each of the toppings differently, but do not distinguish between different pieces having the same topping: the value of each piece to each agent only depends on the amount they get from each region. An exact division can be achieved in the following way:
 * Divide each region into k sub-regions, such that sub-region j contains exactly $$w_j$$ of the regions.
 * Let piece j be the union of the j-th sub-regions in all R regions.

The number of required cuts is $$k\cdot R$$, where R is the number of regions. This algorithm can be generalized to piecewise-linear valuations.

An exact division exists in the more general setting in which agents have countably-additive nonatomic measures. This is a corollary of the Dubins–Spanier convexity theorem (the existence of a consensus 1/k-division was previously noted by Jerzy Neyman ). However, this theorem says nothing about the number of required cuts.

Woodall showed that it is possible to construct an exact division of an interval cake as a countable union of intervals. Intuition: consider the division procedure for piecewise-homogeneous cakes described above. In general, the cake is not piecewise-homogeneous. However, because the value measures are continuous, it is possible to divide the cake to smaller and smaller regions such that the regions become more and more homogeneous. When $$R\to \infty$$, this process converges to a consensus division. However, the number of required cuts in the limit is infinite. Fremlin later showed that it is possible to construct such a division as a finite union of intervals.

Bounded number of cuts
Suppose the cake is an interval made of n districts (sub-intervals), and each of the n partners values only a single district. Then, a consensus division of the cake into k subsets requires $$n\cdot (k-1)$$ cuts, since each of the districts must be cut into k pieces which are equal in the eyes of the partner that values this district. This raises the question of whether there always exists a consensus division with this exact number of cuts. This question was studied extensively, focusing mainly on a one-dimensional cake (an interval).

Consider first the consensus halving case: $$k=2$$ and equal weights. The lower bound on the number of cuts is $$n\cdot (k-1)=n$$. Indeed, a consensus halving with at most n cuts always exists. This is a direct corollary of the Hobby–Rice theorem. It can also be proved using the Borsuk-Ulam theorem: Although the agents' preferences are modeled with measures, the proofs do not require the value functions to be positive or additive over subsets; they may be any continuous set functions defined on the Borel sigma-algebra. Thus it is not required that partners' valuations over subsets of the cake be additively separable.
 * Every partition of an interval using $$n$$ cuts can be represented as a vector of length $$n+1$$, in which the elements are the lengths of the sub-intervals.
 * Every element of the vector can be either positive (if it belongs to piece #1) or negative (if it belongs to piece #2).
 * The set of all partitions is homeomorphic to the sphere $$S^n$$.
 * Define a function $$V: S^n \to \mathbb{R}^n$$ in the following way: for every partition $x$, $$V(x)$$ is a vector whose $i$-th element is the value of piece #1 in that partition according to partner $i$, minus 1/2.
 * The function $V$ is continuous. Moreover, for all $x$, $$V(x)+V(-x)=0$$.
 * Hence, by the Borsuk-Ulam theorem, there exists an $x$ such that $$V(x)=0$$. In that partition, all partners value piece #1 (and piece #2) at exactly 1/2.

Consider now the consensus 1/k-division case: any k>1 and equal weights. Noga Alon, in his 1987 paper about the necklace splitting problem, proved the following result. There are $$n$$ different measures on the interval, all absolutely continuous with respect to length. The measure of the entire necklace, according to measure $$i$$, is $$k\cdot a_i$$. Then it is possible to partition the interval into $$k$$ parts (not necessarily contiguous), such that the measure of each part, according to measure $$i$$, is exactly $$a_i$$. At most $$(k-1)n$$ cuts are needed, and this is optimal.

Consider now the case k=2 and arbitrary weights. Stromquist and Woodall proved that there exists an exact division of a pie (a circular cake) in which each piece contains at most n-1 intervals; hence, at most 2n-2 cuts are needed. See Stromquist–Woodall theorem. The number of cuts is essentially optimal for general weights. This theorem can be applied recursively to obtain an exact division for any k>1 and any weights, using O(n k) cuts.

Multi-dimensional cake, many partners, many subsets, equal weights
The Stone–Tukey theorem states that given $n$ measurable "objects" in $n$-dimensional space, it is possible to divide all of them in half (with respect to their measure, i.e. volume) with a single $(n − 1)$-dimensional hyperplane.

Stated differently: if the cake is the space $$\mathbb{R}^n$$, and the value measures of the partners are finite and vanish on any $$n-1$$ dimensional hyperplane, then there is a half-space whose value is exactly 1/2 to each partner. Hence there exists a consensus division using a single cut.

The original version of this theorem works only if the number of dimensions of the cake is equal to the number of partners. E.g, it is not possible to use this theorem to divide a 3-dimensional sandwich to 4 or more partners.

However, there are generalizations that enable such a division. They do not use a hyperplane knife but rather a more complicated polynomial surface.

There are also discrete adaptations of these multi-dimensional results.

Impossibility using discrete procedures
It is impossible to compute an exact division with a finite number of queries, even when there are only n=2 agents and k=2 pieces the weights equal 1/2. This means that the best we can achieve using a discrete algorithm is a near-exact division.

Proof: When the protocol is at step k, it has a collection of at most k pieces. To provide an exact division, the protocol must find an exact subset – a subset of the pieces which both partners value as exactly 1/2. We are going to prove that, for every k, there are situations in which at step k there is no exact subset, and hence the protocol might have to continue endlessly.

Initially, there is only one piece which both partners value as 1, so there is obviously no exact subset. After one step, at most one partner (say, Alice) has had an option to cut the cake. Even if Alice cuts the cake to two pieces that are equal in her opinion, they may be different in George's opinion, so again there is no exact subset.

Suppose now that we are at step k and there are k pieces. Without loss of generality, we may assume that each piece has a non-zero value to both partners. This is because, if Alice (for example) cuts a piece which she values as 0, it is possible that George also values the same piece as 0, so we can discard this piece and continue with the other pieces.

The total number of different subsets now is 2k, and by the induction assumption none of them is exact. At step k, the protocol can ask either Alice or George to cut a certain piece to two pieces. Suppose w.l.o.g. that the cutter is George and that he cuts piece X to two sub-pieces: X1 and X2. Now, the total number of subsets is 2k+1: half of them already existed and by assumption they are not exact, so the protocol's only chance of finding an exact subset is to look at the new subsets. Each new subset is made of an old subset in which the piece X has been replaced with either X1 or X2. Since George is the cutter, he can cut in a way which makes one of these subsets an exact subset for him (e.g. if a certain subset containing piece X had a value of 3/4, George can cut X such that X1 has a value of 1/4 in his opinion, so that the new subset has a value of exactly 1/2). But, George does not know Alice's valuation and cannot take it into account when cutting. Therefore, there is an uncountable infinity of different values that the pieces X1 and X2 can have for Alice. Since the number of new subsets is finite, there is an infinite number of cases in which no new subset has a value of 1/2 for Alice, hence no new subset is exact.

Moving-knife procedures
Two agents can achieve a consensus division using Austin moving-knife procedure.

The simplest case is when the weights are 1/2, i.e. they want to cut a piece that both of them agree to be half the cake value. This is done as follows. One agent moves two knives over the cake from left to right, always keeping the value between the knives as exactly 1/2. It is possible to prove (by the intermediate value theorem) that at some point, the value of the piece between the knives to the other partner will also be exactly 1/2. The other agent calls "stop!" at that point and the piece is cut.

The same protocol can be used to cut a piece that both agents agree that its value is exactly $$1/n$$. By combining several such pieces, it is possible to achieve a consensus division with any ratios that are rational numbers. But this may require a large number of cuts.

A better way to achieve a consensus division is to identify the two endpoints of the cake and treat it like a circle. I.e, when the right knife gets to the right side, it immediately goes to the left side, and the piece-between-the-knives is now actually the union of the piece to the right of the right knife and the piece to the left of the left knife. This way, it is possible to find a consensus division for every $$p\in[0,1]$$. One agent moves the knives cyclically around the cake, always keeping the value between them at exactly p. It is possible to prove that at some point, the value of the piece between the knives to the other partner will also be exactly p. The other agent calls "stop!" at that point and the piece is cut. This requires only two cuts.

By repeatedly applying the above procedure, it is possible to achieve a consensus division among n=2 partners and any k>1 subsets. The number of cuts is $$2(k-1)$$.

As of 2015, there is no known generalization of this moving-knife procedure to n>2 agents.

Crumb-and-pack procedure
For any given $$\varepsilon > 0$$, one can give each partner a piece such that all partners believe that the values they have differ by less than $$\varepsilon$$, i.e., for every i and every j:
 * $$|V_i(X_j)-w_j| < \varepsilon$$

The near-exact division procedure has two steps: crumbing and packing.

Crumbing step: the goal is to cut the cake to tiny bits ("crumbs") such that each partner assigns a sufficiently small value to each crumb. This is done in the following way. Let k be a certain constant. Ask partner #1 cut the cake to k pieces that he values as 1/k. Ask partner #2 to trim pieces as needed (using at most k-1 cuts) such that each piece has a value of at most 1/k. These new pieces of course still have a value of at most 1/k for partner #1. Continue with partners #3, #4, …, #n. Finally all n partners value each resulting crumb as at most 1/k.

Packing step: the goal here is to partition the crumbs to n subsets, such that the sum of values in each subset j is near wj. Here is an intuitive explanation of the packing step for two partners (Alice and George) when the weights are 1/2.


 * 1) Get an empty bowl.
 * 2) Insert into the bowl one of the crumbs.
 * 3) If the value in the bowl becomes more than 1/2 to either partner, give the bowl to that partner and give the other crumbs to the other partner.
 * 4) Otherwise (the value in the bowl is less than 1/2 to both partners), if the value in the bowl is larger for Alice than for George, then find a crumb whose value for George is more than its value for Alice (such a crumb must exist because the sum of values of all crumbs is 1 both for Alice and for George). Add this crumb to the bowl and return to step 2.

It is possible to prove by induction, that the difference in the valuation of the bowl between Alice and George is always at most 1/k. Hence, when one of the partners receives the bowl, its value for both partners is between than 1/2-1/k and 1/2+1/k.

Formally, each piece can be represented as a vector of values, one per partner. The length of each vector is bounded, i.e. for each such vector v: $$||v||\leq \sqrt{n}/k$$. Our goal is to create, for each partner j, a vector all whose elements are near wj. To do this, we have to divide the vectors to subsets, such that the sum of vectors in each subset j is sufficiently close to a vector all whose elements are wj. This is possible thanks to a theorem by V.Bergström,

The Crumb-and-Pack procedure is a subroutine in the Robertson-Webb protocol. The latter protocol generates a division which is both near-exact and envy-free cake-cutting.

A different explanation of the crumb-and-pack procedure is provided by Brams and Taylor.

Computation of near-exact divisions with bounded number of cuts
Most results for bounded number of cuts focus on the case in which the weights are equal.

Two subsets (consensus halving)
An ε-approximate consensus halving can be computed by an algorithm based on Tucker's lemma, which is the discrete version of Borsuk-Ulam theorem. An adaptation of this algorithm shows that the problem is in the complexity class PPA. This holds even for arbitrary bounded and non-atomic valuations. However, the run-time of this algorithm may be exponential in the problem parameters. In fact, consensus halving is computationally hard in several respects.

First, assumed that ε is allowed to be inverse-exponential in n (that is, 1/ε is an exponential function of n). Then, finding an ε-approximate consensus-halving is PPA-hard. Hardness holds even with the following additional conditions:


 * Agents have piecewise-constant valuations. The input to the problem contains, for each agent, the endpoints and values of his piecewise-constant valuation; and all numbers (including the approximation accuracy ε) are represented in binary.


 * The number of pieces in the piecewise-constant valuations is polynomial in n (the values themselves may be exponential in n).
 * The approximation factor ε is allowed to be inverse-polynomial in n.
 * The agents' valuations are piecewise-uniform with only two blocks (However, when agents have piecewise-uniform valuations with a single block, the problem can be solved in parametrized-polynomial time for n cuts, and in polynomial time for 2n-d cuts for any constant d).
 * The number of agents is a constant and at least 3 (However, with 2 agents it can be solved in polynomial time).

Next, assume that ε is a constant (does not depend on n). Then, finding an ε-approximate consensus-halving is PPAD-hard, which is theoretically weaker than PPA-hard. The proof is by reduction from the ε-approximate Generalised Circuit problem. Hardness holds even in the following conditions:


 * The valuations are piecewise-constant;
 * It is allowed to use a constant number of additional cuts (that is, we search for a consensus halving for n agents using n+d cuts, for some constant d).
 * When ε is a constant, it is open whether ε-approximate consensus-halving is PPA-hard (which is stronger than PPAD-hard). 
 * Also, deciding whether there exists an ε-approximate consensus halving with n-1 cuts is NP-hard even when ε is a constant. The proof is by reduction from 3SAT.

When ε is a constant, two types of approximations can be computed in polynomial time. The algorithms work for general additive valuations (not necessarily piecewise-constant); the valuations are accessed using queries in the Robertson–Webb query model, including a mark-query to the sum of all n valuations. The following approximations can be attained:
 * Finding a partition such that each agent values each part at least 1/2n, using $$n$$ cuts.
 * Finding a partition such that each agent values each part at 1/2 ± ε, using $$O((n \log{n}) / (\varepsilon^2))$$ cuts in an online algorithm, or using $$n\cdot \lceil2+\log_2(1/\epsilon)\rceil$$ cuts in an offline algorithm.
 * Note that there is a gap between PPAD-hardness for n+d cuts for any constant d, and the polynomial-time algorithm for 2n+O(log(ε)).

When the resource to divide is not a cake but rather a set of divisible resources, the problem becomes easier:
 * When ε is constant or inverse-polynomial in n, ε-approximate consensus-halving is computationally equivalent to the necklace splitting problem – each one can be reduced to the other in polynomial time (this implies that necklace splitting is PPAD hard). 
 * If we are interested in finding an exact solution, then consensus halving is much harder: finding a solution with n cuts is FIXP-hard, and deciding whether there exists a solution with n-1 cuts is ETR-complete.
 * When agents' valuations are represented by algebraic circuits, ε-approximate consensus-halving is polynomial-time equivalent to computing an approximation to an exact solution of the Borsuk-Ulam search problem. This means that it is complete for the complexity class BU – a superclass of FIXP that involves solutions to problems whose existence is guaranteed by the Borsuk-Ulam theorem.
 * For agents with additive utilities, there is a polynomial-time algorithm for computing a consensus halving with at most n cuts, and for computing a consensus k-division with at most (k-1)n cuts
 * It is NP-hard to compute a consensus halving with the optimal number of cuts for a given instance. Moreover, it is NP-hard to compute a consensus halving with at most OPT+n-1 cuts, where OPT is the optimal number of cuts for the instance.
 * n cuts are almost surely necessary for consensus halving when agents' utilities are drawn from probabilistic distributions.
 * For agents with non-additive monotone utilities, consensus halving is still PPAD-hard, but there are polynomial-time algorithms for a fixed number of agents.

Many subsets (consensus 1/k-division)
From a computational perspective, not much is known about the computation of an exact division with $$(k-1)n$$ cuts for $$k\geq 3$$. Note that the problem is not necessarily harder than for $$k\geq 2$$, since we are allowed to use a larger number of cuts. What is currently known is: Two types of approximations can be computed using polynomial number of Robertson-Webb queries:
 * The problem is in PPA-k for any k.
 * The problem is PPA-hard for k=3, when 1/ε may be an exponential function of n.
 * Finding a partition such that each agent values each part at least 1/kn, using $$(k-1)n$$ cuts, in an online algorithm.
 * It is open whether the 1/kn can be improved. Particularly, it is open whether there is an efficient (online or offline) algorithm such that each agent values each part at least 1/c(k), where c(k) is some function of k (independent of n), using $$(k-1)n$$ cuts.
 * Finding a partition such that each agent values each part at 1/k ± ε, using $$O(\frac{kn \log{(kn)}}{\varepsilon^2})$$ cuts in an online algorithm, or using $$n\cdot(k-1)\cdot \lceil2+\log_2(3k/\epsilon)\rceil$$ cuts.
 * It is open whether the numbers of cuts can be improved. For online algorithms, a lower bound on the number of cuts for k=2 is $$O(\frac{n}{\varepsilon^2})$$, so there is a logarithmic gap.

Comparison with other criteria
An exact division with equal weights ($$1/n$$) is, in particular, also proportional, envy-free and equitable. However, it is not necessarily Pareto efficient, since in many cases it is possible to take advantage of the subjective valuations and divide the resources such that all partners receive more than their fair share of $$1/n$$.

An exact division with different weights is not necessarily fair. Going back to the opening example, if the 20% piece is given to Alice and the other two pieces (of 50% and 30%) are given to George, this is obviously unfair to Alice. But such divisions can be used as subroutines for fair cake-cutting.

Unanimous proportionality
In the problem of cake-cutting among families,  there are n agents grouped into k families; the goal is to partition a cake into k pieces and allocate one piece per family. A natural fairness criterion in this setting is unanimous proportionality, which means that all members in all families value their family's share at least 1/k (for other criteria and related problems, see fair division among groups). The problem is equivalent to exact division in the following sense:
 * For every n and k, a solution to unanimous-proportional division among n(k-1)+1 agents grouped into k families implies a solution to exact division among n agents with k pieces (and equal weights). In particular, it implies that unanimous-proportional division requires at least n-1 cuts, and that finding an approximate unanimous-proportional division is PPA-hard.
 * For every n and k, a solution to exact-division among n agents and k pieces implies a solution to unanimous-proportional division among n+1 agents grouped into k families. In particular, it implies that exact unanimous-proportional division can be done with (n-1)(k-1) cuts, and that finding an approximate unanimous-proportional division is in PPA. The number of cuts is tight for k=2 families but not for k>2. 

Truthful mechanisms
Any algorithm for consensus division relies on the value measures reported by the partners. If the partners know how the algorithm works, they may have an incentive to lie about their value measures in order to receive more than their weight. In order to prevent this, a truthful mechanism should be used.

The simplest truthful division mechanism is: select a single partner at random (with probabilities determined by the weights) and give him the entire cake. This mechanism is trivially truthful because it asks no questions. Moreover, it is consensus in expectation: the expected value of each partner is exactly its weight, and this is true according to all value measures. However, the resulting division is of course not a consensus division.

A better truthful mechanism, which works for the case in which all weights are 1/n, can be built given any existing algorithm (or oracle) for finding a consensus division: Here, the expected value of each partner is still 1/n regardless of the reported value function, so the mechanism is still truthful – no partner can gain anything from lying. Moreover, a truthful partner is guaranteed a value of exactly 1/n with probability 1 (not only in expectation). Hence the partners have an incentive to reveal their true value functions.
 * 1) Ask each partner to report his value measure.
 * 2) Use the existing algorithm/oracle to generate a partition in which all n pieces are exactly 1/n according to the value functions reported by the partners.
 * 3) Perform a random permutation on the consensus partition and give each partner one of the pieces.

See also: truthful cake-cutting.