The Query Complexity of Cake Cutting
Abstract
We consider the query complexity of cake cutting in the standard query model and give lower and upper bounds for computing approximately envy-free, perfect, and equitable allocations with the minimum number of cuts.
The lower bounds are tight for computing contiguous envy-free allocations among n = 3 players and for computing perfect and equitable allocations with minimum number of cuts between n = 2 players.
We also formalize moving knife procedures and show that a large subclass of this family, which captures all the known moving knife procedures, can be simulated efficiently with arbitrarily small error in the Robertson-Webb query model
Introduction
We consider the classical cake cutting problem due to Steinhaus [43], which captures the fair division of a heterogeneous resource—such as land, time, mineral deposits, fossil fuels, and clean water [38]—among several parties with equal rights but different interests over the resource.
This model has inspired a rich body of literature in mathematics, political science, economics [40, 8, 33], and computer science [12, 22].
Implementations of fair division algorithms can be found, e.g., on the Spliddit website [32].
Mathematically, the problem is to divide the cake, which is the unit interval, among a set of n players with valuation functions induced by probability measures over [0 , 1] .
Given such a resource, the goal is to compute an allocation of the cake in which every player is content with the piece received.
A major challenge for a mediator trying to compute a desirable allocation is that the preferences of the players are private, and fair allocations can only be found when enough information is on the table.
An example of a cake cutting protocol is Cut-and-Choose, which dates back to more than 2500 years ago when it appeared in written records in the context of land division.
Cut-and-Choose can be used to obtain an envy-free allocation among two players, Alice and Bob, trying to divide a heterogeneous resource (e.g. a birthday cake with different toppings): First Alice cuts the cake in two pieces of equal value to her, then Bob picks his favorite and Alice takes the remainder.
More generally, discrete cake cutting protocols operate in a query model, due to Robertson and Webb [49], in which a center that does not know the players asks them cut and evaluate queries until it manages to extract enough information about their preferences to determine a fair allocation.
Two of the prominent fairness notions, envy-freeness and proportionality, have been the subject of in depth study from a computational point of view.
Proportionality requires that each player gets their fair share of the resources, which is their total value for the whole cake divided by the number of players, while envy-freeness is based on social comparison and means no player should want to swap their piece with anyone else’s.
The two notions are not necessarily comparable, since envy-freeness can be trivially achieved by throwing away the entire resource, which is not true for proportionality.
However, when the entire cake must be allocated, envy-freeness implies proportionality and can be surprisingly hard to reach.
The problem of finding an envy-free cake cutting protocol was suggested by Gamow and Stern [30] and solved by Selfridge and Conway for three players (cca.
1960, see, e.g., [40, 8]) and by Brams and Taylor 35 years later [11] for any number of players.
From a computational point of view, the
Brams and Taylor protocol has the major drawback that its runtime can be made arbitrarily long by setting up the valuations of the players appropriately.
In 2016, Aziz and Mackenzie [5] announced a breakthrough by giving the first bounded envy-free cake cutting protocol for any number of players, where bounded means that the number of queries is only a function of the number of players, and not of the valuations.
The query complexity of proportionality is well understood.
The problem of computing a proportional allocation with contiguous pieces can be solved with O ( n log n ) queries in the Robertson-Webb model by running a protocol due to Even and Paz [28], with a matching lower bound due to Woeginger and Sgall [49] for contiguous pieces that was extended to any number of pieces by Edmonds and Pruhs [27].
In contrast, for the query complexity of envy-free cake cutting a lower bound of Ω( n 2 ) was given by Procaccia [37] and an upper bound of O (cid:18) n n nnnn (cid:19) by Aziz and Mackenzie [5].
The bounded algorithm in [5] outputs highly fragmented allocations, which may be an issue in some settings.
Envy-free allocations with contiguous pieces do in fact exist for very general valuations 1 (see, e.g., [42, 44, 46]), but cannot be computed in the Robertson-Webb model [45] except for specific classes such as polynomial functions [13].
In light of this impossibility, it makes sense to study the computation of ϵ -envy-free allocations with few cuts.
For a general utility model where the valuations are arbitrary functions (not necessarily induced by probability measures), bounds on the query complexity of approximate envy-free cake cutting with contiguous pieces were given in [25] together with a proof of PPAD-hardness.
While the problem of computing contiguous ϵ -envy-free allocations is in PPAD [46], neither the computational hardness nor the query lower and upper bounds in [25] carry over (or are close to tight) in the usual cake cutting model, which leaves wide open the complexity of this problem.
Aside from proportionality and envy-freeness, a third notion of fairness is known as equitability, in which each player must receive a piece worth the same value.
Equitable and proportional allocations with contiguous pieces were shown to exist by Cechlarova, Dobos, and Pillarova [20].
The computational complexity of approximate equitability was investigated by Cechlarova and Pillarova, who gave an upper bound of O (cid:0) n (cid:0) log n + log ϵ − 1 (cid:1)(cid:1) for computing an ϵ -equitable and proportional allocation with contiguous pieces for any number of players, and by [39] who showed a lower bound of Ω (cid:0) log ϵ − 1 / log log ϵ − 1 (cid:1) for finding an ϵ -equitable allocation (not necessarily contiguous) for any number of players.
More stringent fairness requirements are also possible, such as ( i ) the necklace splitting problem, for which the existence of fair solutions was established by [34], with a bound on the number of cuts given by [2], ( ii ) the more general notion of exact division 2 , which generalizes necklace splitting and was shown to exist by [26], and ( iii ) the competitive equilibrium from equal incomes, the existence of which was determined by [48].
The necklace splitting problem is contained in PPA and in fact is PPAD-hard [29].
A well known instantiation of the necklace splitting solution is that of perfect allocations, which are simultaneously proportional, envy-free, and equitable.
The complexity and existence of various fairness concepts in cake cutting and related models, such as cake cutting where the resource is a chore, pie cutting, multiple homogeneous goods, multiple discrete goods have also been studied (see, e.g., [23, 35, 3, 18, 31, 24, 14, 10, 19, 36, 7, 1, 15]).
Our Contribution
In this paper we consider the query complexity of cake cutting in the standard Robertson-Webb (RW) query model [49] for several fairness notions: envy-free, perfect, and equitable allocations with the minimum number of cuts.
Such allocations are known to exist on any instance, but several impossibility results preclude their computation in the standard query model [45, 21].
Nevertheless, the computation of approximately fair solutions is possible by discretizing the cake in very small pieces.
For the fairness notions we consider, a number of queries that is polynomial in n and 1 /ϵ suffices to find ϵ -fair allocations for several fairness concepts, such as O ( n/ϵ ) for contiguous envy-free and O ( n ( k − 1) /ϵ ) for ( ϵ, k ) -measure splittings.
2.1 Lower bounds
Our first main contribution is to give lower bounds for the problems of computing approximately fair allocations (with deterministic protocols).
We show the following.
Theorem 2.1.
In the standard Robertson-Webb query model for cake cutting:
• Finding an ϵ -envy-free allocation with contiguous pieces for n players requires Ω (cid:0) log 1 ϵ (cid:1) queries.
• Finding a contiguous ϵ -equitable allocation for two players requires Ω (cid:0) log 1 ϵ (cid:1) queries.
• Finding an ϵ -perfect allocation with two cuts for two players requires Ω (cid:0) log 1 ϵ (cid:1) queries.
In the case of perfect allocations for two players, we are always guaranteed to have a solution with at most two cuts, while a solution with one cut may not exist.
The lower bounds for envy-freeness and perfect allocations are the first query lower bounds for these problems.
The main idea underpinning these results is that of maintaining a self-reducible structure throughout the execution of a protocol, which may be useful more generally for obtaining other lower bounds.
2.2 Upper bounds
We also give improved upper bounds for these fairness notions.
We show the next upper bounds.
Theorem 2.2.
In the standard Robertson-Webb query model for cake cutting:
• An ϵ -envy-free allocation with contiguous pieces for three players can be found with O (log 1 ϵ ) queries.
• An ϵ -perfect allocation for two players with at most two cuts be found with O (log 1 ϵ ) queries.
The upper bounds do not assume any restrictions on the valuations and the proofs rely on approximately simulating in the RW model two moving knife procedures, due to [6] and [4], respectively.
An upper bound of O (cid:0) log 1 ϵ (cid:1) for computing a contiguous ϵ -equitable allocation for two players was given by [21].
A summary of our bounds for the query complexity of computing fair allocations can be found in
Table 1, together with those from previous literature.
2.3 Moving knife protocols.
Our second main contribution is to formalize the class of moving knife procedures, which was previously viewed as disjoint from the RW query model.
Using this definition, we show that any fair moving knife procedure with a fixed number of players and devices can be simulated in O (log 1 ϵ ) queries in the RW model when the players have value densities that are bounded from above by a constant.
The next theorem is written for an abstract fairness notion, which we later formalize.
Theorem 2.3.
Consider a cake cutting problem where the value densities are bounded from above and below by strictly positive constants.
Let M be an RW moving knife protocol with at most r steps, such that M outputs F -fair allocations demarcated by at most a constant number C of cuts.
Then for each ϵ > 0 , there is an RW protocol M ϵ that uses O (cid:0) log 1 ϵ (cid:1) queries and computes ϵ - F -fair partitions demarcated with at most C cuts.
This simulation immediately implies that all the known moving knife procedures, such as the procedures designed by Austin, Barbanel-Brams, Webb [47], and Brams-Taylor-Zwicker [9], can be
[Table]
simulated efficiently within ϵ -error in the RW model when the measures of the players are bounded.
In this context we also found a moving knife procedure for computing contiguous equitable allocations for any number of players, which was discovered independently by Segal-Halevi [41].
Note that our version of the protocol works only for hungry valuations (i.e. when the value densities are strictly positive everywhere), while the protocol of Segal-Halevi [41] works for value densities that could be zero as well.
Model
The resource (cake) is represented as the interval [0 , 1] .
There is a set of players N = { 1 , . . . , n } interested in the cake, such that each player i ∈ N is endowed with a private valuation function
V i that assigns a value to every subinterval of [0 , 1] .
These values are induced by a non-negative integrable value density function v i , so that for an interval I , V i ( I )
= (cid:82) x ∈
I v i ( x ) dx .
The valuations are additive, so V i (cid:16)(cid:83) mj
=
I j (cid:17) =
(cid:80) mj
=1 V i
( I j ) for any disjoint intervals I 1 , . .
, I m ⊆
The value densities are non-atomic, and in fact sets of measure zero are worth zero to a player.
Without loss of generality, the valuations are normalized to V i ([0 , 1])
= 1 , for all i = 1 . . .
n .
A piece of cake is a finite union of disjoint intervals.
A piece is contiguous (or connected) if it consists of a single interval.
An allocation A =
( A 1 , . . .
, A n ) is a partition of the cake among the players, such that each player i receives the piece
A i , the pieces are disjoint, and (cid:83) i ∈
N A i
=
We say that a value density v is: ( i ) hungry if v ( x ) > 0 for all x ∈ [0 , 1] , ( ii ) uniform on an interval [ a, b ] if v ( x ) = 1 for all x ∈ [ a, b ] , and ( iii ) bounded on interval [ a, b ] if there exists a constant
D > 0 such that v ( x ) ≥ D for all x ∈ [ a, b ] (or simply bounded if a = 0 and b = 1 ).
We will sometimes to refer to a valuation (or player) as hungry to simply mean that the corresponding density is strictly positive.
3.1 Fairness Notions
An allocation A is said to be proportional if V i ( A i ) ≥ 1 /n for all i ∈ N ; envy-free if V i ( A i ) ≥
V i ( A j ) for all i, j ∈ N ; perfect if V i
( A j ) =
1 /n for all i, j ∈ N ; equitable if V i
( A i )
=
c , for all i ∈ N and some value c ∈ [0 , 1] .
In addition to allocations, we will refer to partitions as divisions of the cake into pieces where the number of pieces need not equal the number of players.
A partition
A =
( A 1 , . . .
, A k ) is a k -measure splitting if V i ( A j )
= 1 /k for each player i and piece A j .
Envy-free allocations with contiguous pieces and equitable allocations with contiguous pieces always exist [46, 20], while k -measure splittings exist with n ( k − 1) cuts [2].
We will also be interested in ϵ -fair division, where the fairness constraints are satisfied within ϵ -error; for instance, an allocation A is ϵ -envy-free if V i ( A i ) ≥
V i ( A j ) − ϵ , for each i, j = 1 . . .
n , and an ( ϵ, k ) measure splitting if V i ( A j ) ∈ (1 /k − ϵ, 1 /k + ϵ ) for each i = 1 . . .
n , j = 1 . . .
k .
More generally, we consider an abstract definition for fairness notions that admit approximate versions.
Definition 1 (Abstract fairness) .
A fairness notion F must satisfy the following condition:
• Let A =
( A 1 , . . .
, A n ) be any allocation that is F -fair with respect to some valuations ⃗v =
( v 1 . . .
v n ) .
Then for any ϵ > 0 and valuations ⃗v ′
= ( v ′ 1 . . .
v ′ n ) , if | V i ( A j ) − V
i
( A j ) | ≤ ϵ/ 2 , ∀ i, j = 1 . . .
n , then it must be the case that the allocation A is ϵ - F -fair with respect to valuations ⃗v ′ .
Proportionality, envy-freeness, and perfection are instantiations of this notion of abstract fairness.
For example, if an allocation A is envy-free with respect to some valuations ⃗v , then A is also ϵ -envy-free for valuations ⃗v ′
that are close to ⃗v .
3.2 Query Complexity
All the discrete cake cutting protocols operate in a query model known as the Robertson-Webb model (see, e.g., the book of [40]), which was explicitly stated by [49].
In this model, the protocol communicates with the players using the following types of queries:
• Cut i ( α ) :
Player i cuts the cake at a point y where V i ([0 , y ])
=
α , where α ∈ [0 , 1] is chosen arbitrarily by the center 3 .
The point y becomes a cut point .
• Eval i
( y ) :
Player i returns V i ([0 , y ]) , where y is a previously made cut point.
An RW protocol asks the players a sequence of cut and evaluate queries, at the end of which it outputs an allocation demarcated by cut points from its execution (i.e. cuts discovered through queries).
Note that the value of a piece [ x, y ] can be determined with two Eval queries, Eval i ( x ) and Eval i ( y ) .
A second class of protocols is known as “moving-knife” (or continuous) procedures, which typically involve sliding multiple knives across the cake, while evaluating the players’ valuations until some stopping condition is met.
This class has not been formalized until now.
Examples of such procedures include Austin’s procedure, which computes a perfect allocation for two players, Stromquist’s procedure, for finding a contiguous envy-free allocation for three players, and Dubins-Spanier, for computing a proportional allocation for any number of players.
The latter is the only moving knife procedure that can be simulated exactly in the RW model.
Envy-Free Allocations
Exact contiguous envy-free allocations are guaranteed to exist (see, e.g., [44], Su [46]), but cannot be computed by finite RW protocols ( [45]).
However, the impossibility result of Stromquist does not explain how many queries are needed to obtain contiguous ϵ -envy-free allocations.
Our first result is that an ϵ -envy-free allocation with contiguous pieces can be computed for three players using O (cid:0) log 1 ϵ (cid:1) queries.
The proof relies on approximately computing the outcome of a moving knife procedure due to Barbanel-Brams [6].
A detail that must be handled is that a discrete RW protocol does not allow the center to cut the cake directly, so the simulation has to search for the position of the “sword” in the moving knife protocol by keeping track of a small interval that must be made very small from the perspective of each player.
The details can be found in the full version [17], together with the other omitted proofs.
Theorem 4.1.
A contiguous ϵ -envy-free allocation for three players can be computed with O (cid:0) log 1 ϵ (cid:1) queries.
We provide a matching lower bound for this problem, which will extend to any number of players.
Theorem 4.2.
Computing a contiguous ϵ -envy-free allocation for three players requires Ω (cid:0) log 1 ϵ (cid:1) queries.
Generally there are many envy-free allocations, so the proof must ensure that for a long enough time none of these solutions are near.
We will start from a family of valuations known as “rigid measure systems” [45], which were studied by Stromquist in the context of showing that no exact contiguous envy-free allocation can be computed in general in the RW model.
The difficulty is that while in [45] it was sufficient to avoid a single point in order for the protocol to not be able to find an exact envy-free solution with one more query, here we must avoid an entire interval and fit the valuations accordingly in order for an approximately envy-free solution to remain far away after one more query.
Towards this end, we will make a self reducible structure from a generalized version of this class of valuations, which will then be used to give the required lower bound.
We first slightly generalize rigid measure systems to allow a different parameter t i for each player i .
Definition 2.
A tuple of value densities ( v 1 , . .
. , v n ) is a generalized rigid measure system if:
• the density of each player i is bounded by: 1 √ 2 < v i ( x ) < √ 2 , ∀ x ∈ [0 , 1] .
• there exist points
= x 0 < x 1 < . . .
<
x n − 1 < x n = 1 and values s i , t
i for each player i such that 0 < s i < 1 /n <
t i < 1 / 2 and the next constraints hold: V j ( x j − 1 , x j ) =
V j ( x j , x j +1 )
=
t j for all j = 1 . . .
n − 1 and V n ( x n − 1 , x n ) =
V n (0 , x 1 ) =
t n .
An example can be found in the full version [17].
Generalized rigid measure systems satisfy the property that the valuations of the players for any given piece cannot differ too much.
Lemma 1. Consider any cake cutting problem where for two players i and j where there exist a, b > 0 such that for all x ∈ [0 , 1] , 1 /a < v i ( x ) < b and 1 /a < v j ( x ) < b .
Then for any two pieces
S 1 , S 2 of the cake, if V i ( S 1 ) ≥ ab · V i ( S 2 ) , it follows that ab · V j ( S 1 ) >
V j ( S 2 ) .
A useful notion to measure how close a protocol is to discovering an approximately envy-free solution on a given instance will be that of a partial rigid measure system, which we define for three players; the n > 3 definition works similarly.
Definition 3.
A tuple of value densities ( v 1 , v 2 , v 3 ) is a partial rigid measure system if
• the density of each player i is bounded everywhere: 1 √ 2 < v i ( x ) < √ 2 , for all x ∈ [0 , 1] .
• there exist values k > 0 and 1 / 2 > ℓ i > 1 / 3 > m i > 0 for each player i , and points x, x ′ , y, y ′ ∈ [0 , 1] , so that the matrix of valuations for pieces demarcated by these points is:
[Equation]
Partial rigid measure systems have the property that if there is a collection of cut points P = { z 1 , . .
z k } ⊂ [0 , 1] , such that there are no points from P in the intervals ( x, x ′ ) and ( y, y ′ ) , then any contiguous partition attainable using cut points from P has envy at least 0 .
01 k .
Lemma 2.
Let ( v 1 , v 2 , v 3 ) be a partial rigid measure system with parameters k, m i , ℓ i so that for each i , V i ([ x, x ′ ])
=
V i ([ y, y ′ ])
=
k for some x, x ′ , y, y ′ .
If P = { z 1 , . . .
, z t } ⊂ [0 , 1] is a collection of cut points such that x, x ′ , y,
y ′ ∈ P
and there are no points from P in the intervals ( x, x ′ ) and ( y, y ′ ) , then any contiguous partition demarcated by points in P has envy at least 0 .
01 k .
Next we show how queries can be answered one at a time so that the valuations remain consistent with (some) partial rigid measure system throughout the execution of a protocol.
Lemma 3.
Suppose that at some point during the execution of an RW protocol for three players the valuations and cuts discovered are consistent with a partial rigid measure system with parameters k > 0 , 0 < m i < 1 / 3 < ℓ i < 1 / 2 for each i , and points x, y , so that the valuations are:
If the intervals I =
[ x, x + k ] and J =
[ y, y + k ] have no cut points inside, then a new cut query can be answered so that the valuations remain consistent with a partial rigid measure system where two new intervals I ′ ⊆
I and J ′ ⊆
J have no cuts inside, length 0 .
01 k , and the densities of all the players are uniform on I ′ , J ′ .
Proof.
(of Theorem 4.2) Set the initial configuration to a partial rigid measure system with k = 0 .
01 , ℓ i = 0 .
35 , m i = 0 .
28 for each player i .
Declare initial cuts at 0 .
67 , 0 . 68 and set the intervals I =
[0 . 34 , 0 . 35] and J =
(see visual depiction in the full version).
It can be verified there exist compatible valuations for which the densities are in (1 / √ 2 , √ 2) .
By iteratively applying Lemma 3 with every Cut query, a protocol discovers with every cut query a partial rigid system, where the intervals I and J always have uniform density, and their length cannot be diminished by a factor larger than 100 in each iteration.
By Lemma 1, if a protocol encounters a partial rigid measure system for which there are no cuts inside I and J , where | I | = | J | =
k , then any configuration attainable with the existing cuts leads to envy of at least 0 .
01 k .
To get ϵ -envy, we need k/ 100 < ϵ , and so the number of queries is Ω (cid:0) log 1 ϵ (cid:1) .
The construction can be extended to give a lower bound for any number of players.
Theorem 4.3.
Computing a contiguous ϵ -envy-free allocation for n ≥ 3 players requires Ω (cid:0) log 1 ϵ (cid:1) queries.
The lower bound of Ω (cid:0) log 1 ϵ (cid:1) is in fact tight for the class of generalized rigid measure systems, for any (fixed) number of players.
We show an upper bound of O (cid:0) log 1 ϵ (cid:1) for this class by designing a moving knife procedure and then simulating it in the discrete RW model.
Theorem 4.4.
For the class of generalized rigid measure systems, a contiguous ϵ -envy-free allocation can be computed with O (cid:0) log 1 ϵ (cid:1) queries for any fixed number n of players.
Perfect Allocations
We show that for n = 2 players, the problem of computing ϵ -perfect allocations can be solved more efficiently by simulating Austin’s moving procedure in the RW model.
Theorem 5.1.
An ϵ -perfect allocation for two players can be computed with O (log 1 ϵ ) queries.
As we show next, this bound is optimal.
Theorem 5.2.
Computing an ϵ -perfect allocation with the minimum number of cuts for two players requires Ω (cid:0) log 1 ϵ (cid:1) queries.
We prove the lower bound by maintaining throughout the execution of any protocol two intervals in which the cuts of the perfect allocation must be situated, such that the distance to a perfect partition cannot decrease too much with any cut query.
Lemma 4.
Let ϵ > 0 .
Consider a two player instance consistent with Figure 1, where
ϵ < 0 .
001 min { a, d } . 2.
any allocation obtained with cuts 0 < k < ℓ < 1 that is ϵ -perfect from the point of view of player 1 is worth to player 2 less than 0 .
5 − d/ 100 − ϵ when k < x and more than 0 .
5 + d/ 100 + ϵ when k > x + a . 3.
there are no cut points inside the intervals I =
[ x, x + a ] and J =
[ y, y + a ] .
Then a new query can be handled so that the valuations remain consistent with Figure 1, such that conditions 2 and 3 still hold with respect to intervals I ′ =
[ x ′ , x ′ + a ′ ] , J ′ =
[ y ′ , y ′
+ a ′ ]
and parameters x ′ , a ′ =
a/ 100 , and d ′ = d/ 100 .
By iteratively applying Lemma 4 with every cut query received from a suitably chosen starting configuration, we will obtain that the number of rounds is Ω (cid:0) log 1 ϵ (cid:1) , implying Theorem 5.2.
Equitable Allocations
Cechlarova, Dobos, and Pillarova [20] showed that for any number of players and any order, there exists a contiguous equitable allocation in that order.
Moreover, the equitable allocation is proportional for some order.
We give a tight lower bound on the number of queries required for finding contiguous ϵ -equitable allocations; an upper bound was given in [21].
Theorem 6.1 ( Cechlarova and Pillarova [21]) .
For any fixed number n of players, a contiguous ϵ -equitable and proportional allocation can be computed with O (log 1 ϵ ) queries.
Theorem 6.2.
Computing a contiguous ϵ -equitable allocation for two players requires Ω (cid:0) log 1 ϵ (cid:1) queries.
For two hungry players, the contiguous equitable and proportional allocation is unique.
Lemma 5.
For two players with hungry valuations, the cut point of the equitable allocation is unique.
Next we show that when the valuations of the players are as in the next table and no cuts may be used from the interval ( x, y ) , the distance from a contiguous equitable allocation is high.
Lemma 6.
Consider a two player problem where there exist points 0 < x < y < 1 and values 0 < a < b < 0 .
5 such that the valuations are consistent with Figure 2,
where V 1 (0 , x ) = 0 .
5 + a =
V 2 ( y, 1) , V 2 ( x, 1) = 0 .
5 + b = V 1 (0 , y ) .
Then any contiguous allocation that can be formed with cut points outside the interval ( x, y ) has distance at least b − a from equitability.
Given such a configuration, queries can be handled in a way that preserves the symmetry and the distance to equitability gets reduced by a constant factor.
Lemma 7. Consider a two player problem where there exist points 0 < x < y < 1 and values 0 < a < b < 0 .
5 such that V 1 (0 , x ) = 0 .
5 + a = V 2 ( y, 1) , V 2 ( x, 1) = 0 .
5 + b = V 1 (0 , y ) .
Then any Cut query (addressed to either player) can be answered so that the new configuration has two new points z < t such that z, t ∈ ( x, y ) , the valuations satisfy V 1 (0 , z ) = 0 .
5 + a ′
=
V 2 ( t, 1) ,
V 2 ( z, 1) = 0 .
5 + b ′ =
V 1 (0 , t ) , and b ′ − a ′ ≥ ( b − a ) / 100 .
The proof of Theorem 6.2 follows from the previous lemmas (see full version [17]).
Moving Knife Protocols
We will consider a family of protocols that seems to, on one hand, capture all types of protocols that have so far been called “moving knife” procedures and, on the other hand, be simple enough for a transparent simulation.
An important ingredient of the definition is that knife positions must be continuous.
To ensure that “cut queries" fall within the definition, we will only require continuity for hungry valuation functions.
The formal definition together with the omitted proofs of this section can be found in the full version.
Theorem 7.1.
Consider a cake cutting problem where the value densities are bounded from above and below by strictly positive constants.
Let M be an RW moving knife protocol with at most r steps, such that M outputs F -fair allocations demarcated by at most a constant number C of cuts.
Then for each ϵ > 0 , there is an RW protocol M ϵ that uses O (cid:0) log 1 ϵ (cid:1) queries and computes ϵ - F -fair partitions demarcated with at most C cuts.
Theorem 7.2.
The Austin, Austin’s extension, Barbanel-Brams, Stromquist, Webb, Brams-TaylorZwicker, and Saberi-Wang moving knife procedures can be simulated with O (cid:0) log 1 ϵ (cid:1) RW queries when the value densities are bounded from above and below by positive constants.
An Equitable Protocol : Next we show a simple moving knife protocol in the Robertson-Webb model for computing equitable allocations for any number of hungry players.
A more complex moving knife procedure for computing exact equitable allocations that is not in the RW model but works even when the valuations are not hungry was discovered independently by [41].
Equitable Protocol : Player 1 slides a knife continuously across the cake, from 0 to 1 .
For each position x 1 of the knife, player 1 is asked for its value of the piece [0 , x 1 ] ; then each player i = 2 . . .
n iteratively positions its own knife at a point x i ∈
[ x i − 1 , 1] with V i ( x i − 1 , x i ) =
V 1 (0 , x 1 ) if possible, and at x i = 1 otherwise.
Player n shouts “Stop!"
when its own knife reaches the right endpoint of the cake (i.e., x n = 1 ).
The cake is allocated in the order 1 . . .
n , with cuts at x 1 . . .
x n − 1 .
Theorem 7.3.
There is is an RW moving knife protocol that computes a contiguous equitable allocation for any number n of hungry players.
This immediately implies a moving knife protocol for computing an allocation that is not only equitable, but also proportional; this can be achieved by running Equitable Protocol for every permutation of the players and choosing the one that is proportional.
The Stronger and Weaker Models
We also discuss two other query models; the proofs for this section can be found in the full version [17].
The first one, which we call RW + , is stronger in that the inputs to evaluate queries need not be previous cut points and at the end the protocol can use arbitrary points (i.e. not just cuts discovered through queries) to demarcate the final allocation.
Definition 4 ( RW + query model) .
An RW + protocol for cake cutting communicates with the players via two types of queries:
• Cut i ( α ) :
Player i cuts the cake at a point y where V i ([0 , y ])
=
α , for any α ∈ [0 , 1] .
• Eval i
( y ) :
Player i returns V i ([0 , y ]) , for any y ∈ [0 , 1] .
At the end of execution an RW + protocol outputs an allocation that can be demarcated by any points of its choice, regardless of whether they have been discovered through queries or not.
The RW + model differs from the RW model in subtle ways.
For instance, in RW there exists a characterization of truthful protocols (i.e. all truthful protocols are dictatorships for n = 2 players, with a similar statement for n ≥ 3 players [16]).
A similar characterization is not known in the RW + model.
However the RW + model allows a general simulation of moving knife protocols without requiring that valuations are bounded from below.
Our constructions for the lower bounds work against this stronger query model.
The lower bounds from the RW model still hold, since our constructions did not use in any crucial way the fact that the evaluate inputs must come from previous cut queries.
Corollary 1.
Computing a contiguous ϵ -envy-free allocation among n = 3 players, an ϵ -perfect allocation with two cuts between n = 2 players, and a contiguous ϵ -equitable allocation between n = 2 players in the RW + models requires Θ(log 1 ϵ ) queries.
Computing a contiguous ϵ -envy-free allocation for any fixed number n of players requires Ω(log 1 ϵ ) queries.
In the RW + model we can simulate moving knife protocols without the requirement that the valuations are bounded from below since the center can reduce (half) the time directly with each iteration, instead of reducing it through the lens of the players’ valuations.
Theorem 8.1.
Consider a cake cutting problem where the value densities are bounded from above by constant D > 0 .
Let M be an RW + moving knife protocol with at most r steps, such that M outputs F -fair allocations demarcated by at most a constant number C of cuts.
Then for each ϵ > 0 , there is an RW + protocol M ϵ that uses O (cid:0) log 1 ϵ (cid:1) queries and computes ϵ - F -fair partitions demarcated with at most C cuts.
We also introduce a weaker model, which we call RW − , where the protocol can ask the players only the evaluate type of query.
Definition 5 ( RW − query model) .
An RW − protocol for cake cutting communicates with the players via queries of the form
• Eval i ( y ) :
Player i returns V i ([0 , y ]) , where y ∈ [0 , 1] is arbitrarily chosen by the center.
At the end an RW − protocol outputs an allocation that can be demarcated by any points.
If the valuations are arbitrary, then an RW − protocol may be unable to find any fair allocation at all.
The reason is that no matter what queries an RW − protocol asks, one can hide the entire instance in a small interval that has value 1 for all the players; this interval will shrink as more queries are issued, but can be set to remain of non-zero length until the end of execution.
However, if the valuations are bounded from above 4 , then an RW − protocol is quite powerful.
Theorem 8.2.
Suppose the valuations of the players are bounded from above by a constant D > 0 .
Then any RW + query can be answered within ϵ -error using O (log 1 ϵ ) RW − queries.
Proof.
Let there be an instance with arbitrary valuations v 1 . . .
v n such that v i ( x ) <
D for all x ∈ [0 , 1] and i ∈ N .
Since an RW − protocol can use the same type of evaluate queries as an RW + protocol, the simulation has to handle the case where the incoming query is a cut.
Let this be Cut i ( α ) and denote by x the correct answer to the query.
In order to find an approximate answer using only evaluate queries, initialize ℓ = 0 , r = 1 , and search for the correct answer: ( ∗ ) Let m = ( ℓ + r ) / 2 .
Ask player i the query Eval i ( m ) and let w be the answer given.
If | w − α | ≤ ϵ , return m .
Otherwise, if m > α , set r = m , and if m < α , set ℓ = m ; return to ( ∗ ) .
This procedure halves the interval [ ℓ, r ] with every iteration.
Moreover, from the bound on the valuations, an interval of length ϵ/D cannot be worth more than ϵ to any player.
Thus the search stops in O (log 1 ϵ ) rounds.
Discussion
An important open question is to obtain stronger lower bounds for n ≥ 4 players for computing contiguous envy-free allocations and for n ≥ 3 players for perfect allocations with minimal number of cuts.
We conjecture that unlike equitability, which remains logarithmic in 1 /ϵ for any number of players, computing a contiguous ϵ -envy-free allocation for n = 4 players and an ϵ -perfect allocation with minimal cuts for n = 3 players will require Ω( 1 ϵ ) queries.
Since moving knife protocols can be simulated with O (log 1 ϵ ) queries, this would imply that no moving knife protocol exists for computing an envy-free allocation for n ≥ 4 players or a perfect allocation for n ≥ 3 players (the existence of such procedures has been posed as an open question, e.g. in [9]).
Acknowledgements
This project has received funding from the European Research Council (ERC) under the European
Union’s Horizon 2020 Research and Innovation Programme (grant agreement no. 740282).
A part of this work was done while Simina Brânzei was visiting the Simons Institute for the Theory of
Computing.
Checklist
The checklist follows the references.
Please read the checklist guidelines carefully for information on how to answer these questions.
For each question, change the default [TODO] to [Yes] , [No] , or [N/A] .
You are strongly encouraged to include a justification to your answer , either by referencing the appropriate section of your paper or providing a brief inline description.
For example:
• Did you include the license to the code and datasets? [Yes] • Did you include the license to the code and datasets?
[No] The code and the data are proprietary.
• Did you include the license to the code and datasets?
[N/A]
Please do not modify the questions and only use the provided macros for your answers.
Note that the
Checklist section does not count towards the page limit.
In your paper, please delete this instructions block and only keep the Checklist section heading above along with the questions/answers below.
For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?
[Yes] (b) Did you describe the limitations of your work?
[Yes] (c) Did you discuss any potential negative societal impacts of your work?
[N/A] (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?
[Yes] 2.
If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?
[Yes] (b) Did you include complete proofs of all theoretical results?
[Yes] 3.
If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
[N/A] (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?
[N/A] (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?
[N/A] (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?
[N/A] 4.
If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?
[N/A] (b) Did you mention the license of the assets?
[N/A] (c) Did you include any new assets either in the supplemental material or as a URL?
[N/A] (d) Did you discuss whether
and how consent was obtained from people whose data you’re using/curating?
[N/A] (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?
[N/A]
If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?
[N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?
[N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?
[N/A]