The concept of dividing valuable resources in a way that is fair has a long history in economic thinking and underpins the very notion of justice in society [Fol67, Raw71, Var74, Mou03]. An instantiation of this challenge is the problem of allocating a set of goods—such as land, time, mineral deposits, or an inheritance—among multiple participants with equal rights but distinct interests. The model that encapsulates the pure fair division problem444In economies with production, the participants may have different contributions to the product of society, so their claims may not necessarily be equal, but our focus here will be on equal rights. is due to Steinhaus [Ste48]
under the name of cake cutting. The “cake” is a metaphor for the collection of interest, formally defined as the unit interval, while the value of each participant (player) for a piece of cake is given by the integral of a private probability measure over that piece. The cake cutting model can be seen as the limit of a discrete model of fair division—in which the players have additive valuations over a finite set of indivisible goods—by letting the number of goods (i.e. “atoms”) grow to infinity.
This model has given rise to a rich literature concerned with understanding what fairness itself means and what procedures can materialize it [BT96, RW98, Pro13]. The outcome of a protocol is an allocation, which is an assignment of (non-overlapping) pieces to the players, so that each piece is a union of intervals and the whole cake is allocated. Four of the commonly considered notions of fairness are proportionality, envy-freeness, equitability, and perfection. A simple envy-free protocol is the Cut-and-Choose procedure for two players, Alice and Bob, in which a mediator asks Alice to cut the cake in two pieces of equal value to her, after which Bob is allowed to take his favorite while Alice is left with the remainder.
Moving beyond Cut-and-Choose, protocols for more players can get very complex and, in fact, a central question in the cake cutting literature is that of computing fair allocations despite the informational challenge of private preferences. The goal of a mediator (or center) is to help the parties reach a fair solution, which in turn requires it to learn enough valuation information. The existing cake cutting protocols are broadly classified in three categories as follows. The largest class contains so called “discrete” protocols, which operate in a query model (due to Robertson and Webb[RW98, WS07]), where the center can repeatedly ask the players to make a cut or evaluate an existing piece. Despite the fact that the Robertson-Webb (RW) query model is viewed as discrete in the cake cutting literature, it is an infinite precision model, which is unavoidable for the purpose of computing exact solutions (or even approximate ones for arbitrarily complex instances.) Continuous (moving knife) procedures generally involve multiple knives sliding over the cake, with stopping conditions that signal the presence of a fair allocation. In a companion paper [BN17] we formalize a general class of moving knife procedures and prove that they can be approximately simulated by logarithmically many queries in the RW model. Finally, direct revelation protocols were studied also in the context of mechanism design [MT10, MN12, CLPP13, BM15], where the players directly submit their entire valuation to the center, whose goal is to compute a fair allocation despite the strategic behavior of the players. The positive results in the direct revelation model are either only for very restricted preferences, such as piecewise uniform functions [CLPP13], or rely again on infinite precision for general preferences [MT10].
In this paper we study the communication complexity [KN96, LS09] of cake cutting: we assume that each player knows its own valuation function, and study the amount of communication that the players need to exchange (between themselves or with a mediator) in order to find an -fair allocation, for various notions of fairness.
There are several motivations for studying the communication complexity of fair allocation problems. First, it is natural to use discrete protocols for studying notions of complexity rather than infinite-precision ones like the RW model, and communication complexity is the strogest, most general, model that allows only discrete queries to each player’s valuation555Any query that has possible answers to the valuation of player can be simulated in a communication protocol by bits of communication from player .. Second, we will show that communication lower bounds also imply lower bounds not only in the RW model but also in various moving-knife models, allowing us to utilize the strong tools already developed in the theory of communication complexity for proving results on cake cutting in other models. Third, cake cutting problems seem to be interesting challenges from the point of view of communication complexity: these problems have low non-deterministic communication complexity666I.e. specifying a fair allocation requires a small number of bits, and its fairness can be easily verified., and there are rather few such problems for which good deterministic or randomized lower bounds are known (specifically [BR17, RW16] and Karchmer-Wigderson games [KW90].) Since the existence proofs of fair allocations are based on fixed point theorems such as Sperner, Brower, or Borsuk-Ulam [Ney46, Sim80, Str80, Alo87, Su99, DQS12, FRFGZ16, FRG18], their study is a basic instance of understanding various “PPAD-like” classes [Pap94] in the communication complexity model. Finally, this work is part of the general thread of understanding the communication complexity of economic problems, such as markets, auctions [NS06, BNS07, DV13, DNO14, ANRW15, Ass17, BMW17], matchings [GNOR15], and voting [CS05].
It is clear that in discrete models such as communication complexity exact fairness is impossible to achieve and we thus focus on the approximate notion, -fairness. We note that understanding -fairness is motivated by the fact that in reality the goods to be allocated are rarely completely continuous but rather, at best, are fine enough so that a continuous model is a good approximation. Similarly, in reality we do not need (or can really get) exact fairness, but rather approximate fairness should suffice. It is thus interesting, from a complexity point of view, to study the complexity of achieving various notions of fairness as a function of the desired approximation parameter . While much previous work has studied the complexity of cake cutting notions in terms of the number of players [BT96, RW98, EP06b, WS07, Pro09, AM16], recent work [CP12, PW17, BN17] started studying the dependence in terms of as well. In this paper we will always treat as a small fixed constant, and focus on the complexity in terms of the desired approximation level . There does remain work in understanding the joint dependence on both and .
1.1 Our Results
We study both general notions of fairness and in particular the following four standard notions: proportionality, envy-freeness, equitability, and perfection [RW98]:
An allocation of the cake among players , where each player receives piece , is called:
-proportional if for every : .
-envy-free if for every : .
-equitable if for every : .777The equitability requirement is considered particularly relevant in situations of heightened conflict, such as divorce settlements or war negotiations.
-perfect if for every : .
Our first contribution is a careful definition of the communication complexity model for cake cutting. We observe for the problem to make sense we must have the following two features be part of the setting: the valuations of the players must have bounded density (this is the correct equivalent to the no-atoms assumption in the usual cake cutting model) and that the number of cuts (pieces, intervals) in the produced allocation must be bounded.
Without bounded density, nothing can be done, as is captured by the following proposition.
Let be a constant approximation parameter. No finite discrete protocol can output a -proportional allocation between players for all atom-less valuations (but whose densities are not necessarily bounded). The same impossibility holds for every other number of players , , and any other standard fairness criteria.
On the other hand, if the protocol is allowed to produce allocations with an unbounded number of cuts then allocations that are -fair can be found with high probability without any communication.
For every and , there exists a randomized protocol, with public coins, that without any communication or queries produces with high probability an -perfect allocation with at most cuts. The protocol may be turned into one with private coins by adding a single round of communication of bits. The same holds for any other standard fairness criteria.
From this point on we will therefore assume valuations with bounded densities and protocols that produce allocations with a bounded number of cuts.
Our second set of contributions is providing general simulation results that apply to a rather general class of (abstract) fairness notions, including all those studied in the literature (the formal requirement for such general fairness notions can be found in Section 2.1). We start with a general simulation of the (infinite precision) RW model by the (discrete, finite precision) communication model.
Let be any protocol in the RW model that makes at most queries and outputs -fair allocations, where is a fairness notion. Then there exists a communication protocol with rounds of bits of communication each, such that outputs --fair allocations.
A more general class of protocols is that of moving knife protocols, in which “knives” are continuously moved across the cake until some condition is met (perhaps in addition to RW queries). In a companion paper [BN17] we defined a general class of such protocols that can be approximately simulated in the RW model, and here we define an even more general class that can be approximately simulated with small communication. All known moving-knife procedures fall into this class, using a constant number of steps. While the formal definition is a bit cumbersome, in an intuitive sense it captures protocols that rely on the simple intermediate value theorem (rather than a “full-fledged” fixed point theorem.)
Let be any moving knife protocol that runs in constantly many steps and outputs -fair partitions. Then for every , there is a communication protocol that uses rounds each with bits of communication and outputs --fair partitions.
For fairness notions for which no protocols are known in existing models, we still show that a fair allocation can be found with nearly linear communication.
For any fairness notion (that is guaranteed to always exist and has at most a constant number of cuts), an --fair allocation can be found using a single round of bits of communication.
Armed with these general simulation results we get a high-level map of the communication complexity of various notions of fairness. We qualitatively categorize the standard fairness criteria in terms of their communication complexity into three categories: “Easy”, “Medium”, and “Hard”. Let us discuss each of these categories.
The first class of problems consists of fair division problems that have known bounded protocols in the RW model, i.e. can be solved with a constant number of rounds of logarithmic (or even poly-logarithmic) bits. Applying our simulation theorem to known protocols in the RW model [AM16, EP84] we get:
The following problems have communication protocols with a constant number of rounds of communication of bits each round:
For any fixed number of players , a connected -proportional allocation among players.
For any fixed number of players , for some constant that depends on , an -envy-free allocation with at most cuts.
We show that this upper bound is tight in a strong way:
Every (deterministic or randomized) protocol for (not-necessarily connected) -proportional allocation among any players requires bits of communication (with no restriction on the number of rounds.)
The second class corresponds to problems that have known moving-knife protocols: computing a connected equitable allocation between players, an perfect allocation with two cuts (the minimum possible) between players, and a connected envy-free allocation among players. We show these problems have logarithmic or poly-logarithmic total communication complexity: equitable and envy-free can be solved approximately with bits, perfect with , and general moving knife protocols with .
Our main technical result is a lower bound that applies to the two player problems above (i.e. perfect and equitable) showing that they are not in the “easy class” and thus separating the “easy” and “medium” classes.
Our technical analysis of these problems proceeds by introducing a natural discrete communication problem that we call the “crossing problem”.
The general problem is the following: Alice gets a sequence of integer numbers with for all and similarly Bob gets a sequence of integer numbers with for all , and such that and . Their goal is to find an index such that either both and or that both and .888An even more difficult variant of this problem would insist that the output is the former rather than the latter. This variant does not seem to correspond directly to any fair division problem so we will not name it. It is worth noting that the protocol in the proof of theorem 5.1 solves this harder variant as well.
In the monotone variant, , Alice and Bob are also assured that and and again need to find an index such that and .
Our upper bounds on the communication complexity of the crossing problem are as follows.
The deterministic communication complexity of is . The randomized communication complexity of is .
The (deterministic) communication complexity of the problem is .
In terms of total communication we have a logarithmic lower bound, so closing the gap for the general crossing problem remains an open problem. Our main technical result is a lower bound that shows that even the monotone variant of the crossing problem cannot be solved using a constant number of rounds of logarithmic many bits of communication each and thus is not in the “easy” class described above. Our proof uses “round elimination” lemmas from communication complexity [MNSW95, SV08].
Any (deterministic or randomized) protocol that solves using rounds of communication of -bits each (with ) requires rounds of communication.
It turns out the the monotone crossing problem exactly captures the complexity of finding a connected equitable allocation between players, while the general crossing problem captures exactly the complexity of finding a perfect allocation (with 2-cuts) between players. The monotone variant also implies an upper bound for finding a connected envy-free allocation among players.
The deterministic communication complexity of finding an -perfect allocation with two cuts between players is . The randomized communication complexity of this problem is .
The deterministic communication complexity of finding a connected -equitable allocation between players and a connected -envy-free allocation among players is .
Any (deterministic or randomized) protocol for finding an -perfect allocation with 2-cuts between players or for finding a connected -equitable allocation between players using rounds of communication of -bits each requires rounds of communication.
In particular, this theorem implies nearly logarithmic lower bounds on the number of queries in the RW model for these two problems. Comparing our result for equitability to the recent lower bound of by [PW17] in the RW model, our result has two advantages and one disadvantage. The first advantage is that the communication complexity model is significantly stronger, and the second is that our lower bound applies also to randomized protocols (with public coins and two-sided error). The disadvantage is that our lower bound is only for connected allocations.999Notice however that as mentioned above if an arbitrary number of cuts is allowed (a finite number that may depend on ) then the lower bound is false in a very strong sense.
We conjecture that the -equitable and -perfect allocation problems remain of “medium” complexity (rather than “easy”) for any fixed constant number of cuts (that does not depend on ). Similarly we conjecture that for players the envy-free problem with connected pieces is not “easy”.
The final class of problems are ones where reasonable protocols are not known. Our general result above states that nearly linear (in ) many bits of communication suffice for essentially any fairness criteria. The main open problem left by this paper is to prove a separation between the “medium class” and the “hard class”. I.e., to prove a super-logarithmic lower bound on the communication complexity of some fairness criteria. This would in particular imply that such a problem has no moving knife protocol for it (in a rather general class of moving knife procedures), a type of result that is not known. Natural candidates for such problems are those that have no known protocols for them:
An -perfect allocation among players and any (bounded) number of cuts.
A connected -envy-free allocation among players
2 Model and Preliminaries
We have a cake, represented by the interval , and a set of players . Each player has a value density function . We denote the value of player for any interval by . The valuations are additive, so for any disjoint intervals . Note that, by definition, atoms are worth zero, and w.l.o.g. the valuations are normalized so that for each player .
A piece of cake is a finite union of disjoint intervals. A piece is connected if it’s a single interval. An allocation is a partition of the cake among the players, such that each player receives piece , the pieces are disjoint, and .101010Some works also consider the problem of fair division where cake can be discarded; see, e.g., [CLPP13, SHA16]. An allocation has cuts if is the minimum number of cuts needed to demarcate ; e.g. the allocation where and has cuts, at and .111111The number of cuts used to demarcate the allocation would not increase if the piece were expressed as .
We assume that the valuations are private information. We will always have
Bounded density: For some fixed constant (that may depend on ), for all , we have that .
A valuation is hungry if it has positive density everywhere: for all .
2.1 Fairness Notions
Given player valuations , our goal is to partition the cake into pieces in a way that satisfies certain fairness criteria, at least approximately. The following are some of the most commonly considered notions of fairness:
-proportionality: For all : .
-envy-freeness: For all and : .
-equitability: For all and : .
-perfection: For all and : .
For every profile of valuations, it is possible to achieve each one of these fairness notions exactly, i.e. with (see, e.g., [BT96, RW98, Pro13]). The question is how many cuts are needed. In the simplest case, we can give each participant a connected piece of the cake (i.e. , for all and some interval ), but this is not always possible and for some notions of fairness the cake must be cut into a larger number of sub-intervals. Proportional cake cutting, envy-free cake cutting, and equitable cake cutting are each possible with connected pieces (i.e. cuts), while perfect cake-cutting is possible with cuts (but not less). Clearly the more cuts do we allow a protocol to make, the easier its job may become.
The number of players will be fixed and arbitrary. The number of cuts for any allocation that a protocol can output will be bounded by a constant which may depend on the number of players. Finally, some of our results will be about general (abstract) notions of fairness, which encompass the four notions above. We will require from a fairness notion that it admits an approximate version as follows.
Definition 3 (Abstract fairness).
An abstract fairness notion must satisfy the condition:
Let be any allocation that is -fair with respect to some valuations . Then for any and valuations , if , the allocation is also --fair with respect to valuations .
2.2 Communication Complexity
The players will embark on a communication protocol. Each player starts by knowing its own valuation and the communication task is to find an allocation that is (approximately) fair from the point of view of all the players. We will count not only bits of communication but also the number of rounds of interaction. Some of our protocols are randomized (with public coins) and need to compute the desired output with a specified probability of error.
Fair allocation problems are relations and their communication complexity will be defined next (see [KN96]
, chapters 3 and 5). Each party knows its own valuation function. For randomized protocols, each party is also allowed to flip a random coin; that is, each party has access to a private random string of some arbitrary length, where the strings are chosen independently according to some probability distribution. For example, in the case of two parties, Alice and Bob, holding valuationsand , and random strings and of arbitrary lengths, each combination of determines a leaf in the protocol tree, which is marked with some allocation . The allocation is defined as the output of the protocol on input .
Definition 4 (Deterministic and randomized communication complexity).
For any notion of fairness , a protocol computes an allocation that is fair according to if for every profile of valuations , the protocol reaches a leaf marked by an allocation that is -fair with respect to the valuations . The deterministic communication complexity of the fairness notion , denoted , is the number of bits sent on the worst case input by the best protocol that computes -fair allocations.
The randomized -error communication complexity of a fairness notion , , is the worst case number of bits sent by the best randomized protocol that computes -fair allocations with probability . The error probability is taken over the random choices of the protocol on the worst case input.
In the definition of randomized protocols above, each party has its own random coins to flip; this is referred to as the “private” coin model. It is also possible to allow the parties to have a “public” coin, where all of them can see the results of a single series of random coin flips.
We will always require that our protocols produce allocations with at most a bounded number of cuts , where may depend on , but not on .
A communication protocol is a -protocol if it has rounds of communication each using at most bits of communication.
2.3 Why Bound the Density?
The bounded density requirement is the analogue of having no atoms. The necessity of bounding the density can be demonstrated by the following impossibility result that applies not only to communication protocols but also to any type of protocol that uses any type of queries that have a finite number of possible answers (in contrast to the usual RW protocols in which answers to queries are real numbers).
A cake cutting problem is called reasonable if whenever all players have all their weight on some sub-interval , i.e. , then the allocation must cut the cake somewhere within this interval (and perhaps at finitely many other locations as well).
Notice that all studied notions of approximate fairness are reasonable in this sense. For concreteness think about the simplest challenge of -approximate proportional cake cutting between players.
A finite query protocol that always makes only a finite number of cuts cannot solve any reasonable cake cutting challenge in time that is bounded by any function of and on all possibly-unbounded-density valuations.
Assume by way of contradiction that the number of queries made by the protocol is finite (for some fixed and ), i.e. the “computation tree” of the protocol has finite depth. Since every query in the tree can have only a finite number of answers, every node in the tree has a finite number of children, and so by Konig’s lemma, the whole computation tree is finite. Since the protocol always makes only a finite number of cuts, the total number of locations at which the protocol ever makes a cut is finite – call this number .
Now if we consider the possible input valuation profiles where all players have their valuation concentrated on the sub-interval then, since the challenge is reasonable, the protocol is required to be able to output a cut in every such interval. But when , more than such possible answers are required. ∎
2.4 Why Bound the Number of Pieces?
It turns out that if a protocol is not bounded in the number of pieces that it can produce, then even -perfect cake-cutting becomes very easy.
There exists a randomized public-coin protocol that produces an -perfect allocation among any constant number of players using pieces with high probability without any communication.
The unit interval is pre-split to intervals of equals lengths (the hidden constant in the big-O notation depends polynomially on ). The public random coins are used to allocate each interval to one of the
players at random. With high probability each player will get a total weight of within a few standard deviations from. The bounded density assumption implies that each sub-interval has weight for each of the players which implies that the standard deviation here is . Thus the allocation specified by the public random coins is -perfect with high probability. ∎
While this protocol uses public coins, the standard simulation of [New91] implies a simultaneous private-coin protocol with bits of communication.
Open Problem 1.
What is the deterministic simultaneous communication complexity of finding a perfect allocation with cuts?
3 Basic Simulations
We provide several simulations, which use the observation that valuations with bounded density can be approximated by simple piecewise-constant-density valuations.
A valuation is called -simple if (a) for every integer , we have that is itself an integer multiple of and (b) for every we have that .
Initially each player will approximate its valuation function by a simple one.
For any valuation , there exists an -simple valuation such that for every sub-interval we have that , where .
Let be the smallest integer greater than and define, for every integer , that , where is the smallest integer multiple of that is greater or equal to
. Then interpolate and for everyset . The valuation obtained has the required property. ∎
From this we can easily deduce the following general simulation, which in particular implies that bounded RW protocols can be simulated efficiently in the communication model.
For any notion of fairness that is guaranteed to exist and has at most a constant number of cuts, an -approximate version of this notion can be found by a simultaneous protocol that uses bits of communication.
Each player approximates its valuation by an -simple one, as in Lemma 3, for , and sends the complete description of the simple approximation. The assured fair allocation for the approximating valuations is found, and by Lemma 3 (and the definition of abstract fairness) it is also -fair for the original valuations. ∎
3.1 Simulating the RW Model
Cake cutting protocols usually operate in a query model attributed to Robertson and Webb [RW98] (and explicitely stated by Woeginger and Sgall [WS07]). In this model, the protocol communicates with the players using the following types of queries:
: Player cuts the cake at a point where . The point becomes a cut point.
: Player returns , where is a previously made cut point.
Note the questions and answers have infinite precision. Any RW protocol asks the players a sequence of cut and evaluate queries, at the end of which it outputs an allocation where the pieces are demarcated by cut points.
We show a general simulation theorem for RW protocols as follows. First, we say that two valuations are -close if for each interval .
Let be any protocol in the RW model which makes at most queries and produces an allocation of the cake with a number of cuts bounded by a constant . Then there exists a communication protocol with rounds of bits of communication each, such that for every valuation tuple , , for a valuation tuple that is -close to .
Each player that was given a valuation will first approximate it by a -simple valuation as shown in Lemma 3 with , where is the maximum number of intervals that the cake can be cut into by protocol . The players will run the simulated protocol below on the ’s and as Lemma 3 guarantees that for every sub-interval , and each player gets at most connected intervals, the lemma will follow.
To run the RW protocol on the approximate valuations , note that the answer to any RW query on these types of “simple” valuations requires only bits of communication. Specifically, the exact real-valued answer to a query “” with can be given by specifying the values and which are integer multiples of and thus require bits of communication. Similarly the answer to a query “” can either be given by an integer such that if such an integer exists, or otherwise by specifying the single integer such that as well as these two values themselves, still bits of communication. Thus the players can simulate the RW protocol using rounds of bits per round, which implies a communication protocol with the required properties. ∎
By the definition of the closeness of to and relying on the bounded number of cuts, we immediately get:
Let be any protocol in the RW model that makes at most queries and outputs -fair allocations. Then there exists a communication protocol with rounds of bits of communication each, such that outputs (-)-fair allocations.
For every , -proportional cake cutting and -envy-free cake cutting among any fixed number of players can be done with rounds of bits of communication.
We note that our simulation theorem falls short of approximately simulating arbitrary RW protocols for arbitrary problems since information can be lost when approximating by simple valuations. This is demonstrated by the following example for players.
Ask Alice to cut the cake in half: .
If is irrational, Alice takes the whole cake.
Else, Bob gets its favorite piece in and Alice the remainder.
Let . Consider hungry valuations such that Alice’s midpoint is . When running the protocol on valuations , Alice takes the whole cake. However, when the players approximate their valuations by some simple valuations , with intervals, Alice’s midpoint of the cake with respect to her new valuation is a number , since , , and her value for each interval is an integer multiple of . Thus the only kind of execution observed on simple valuations is the computation of envy-free allocation between the two players. 121212This type of discrepancy can also be observed for fair protocols, such as the RW implementation of the Dubins-Spanier protocol, where each player submits their mark (i.e. the point such that ), then the player with the leftmost mark receives the piece , and the protocol is repeated with the remaining players on the leftover cake. If a player “trembles” when answering the cut queries, it can get pieces worth very different values when running the protocol on simple valuations compared to the original valuations. However, in this case, the allocation remains approximately proportional in both scenarios.
3.2 Simulating Moving Knife Procedures
A family of protocols that has remained undefined until recently is that of moving knife procedures, which involve multiple knives sliding over the cake until some stopping condition is met (such as Austin’s moving knife procedure for finding a perfect allocation between two players [RW98]). In a companion paper [BN17] we formalized moving knife protocols that can be approximately simulated in the RW model. Here we provide a more general definition of a class of protocols that can be approximately simulated with little communication.
An example of a moving knife protocol is Austin’s procedure [RW98], which computes a perfect allocation between two players with two cuts (which is the minimum number of cuts required for perfect allocations) and operates as follows:
Austin’s procedure: A referee slowly moves a knife from left to right across the cake. At any point, a player can call stop. When a player called, a second knife is placed at the left edge of the cake. The player that shouted stop – say 1 – then moves both knives parallel to each other. While the two knives are moving, player 2 can call stop at any time. After 2 called stop, a randomly selected player gets the portion between player 1’s knives, while the other one gets the two outside pieces.
The correctness is obtained by using the Intermediate Value Theorem. If at the beginning of the operation player 2 values the piece between the knives at less than 1/2, then his value for the remainder of the cake is more than 1/2. Then by the intermediate value theorem there exists a position of the sword such that player 2’s value for the piece between the knives is exactly 1/2. In general, moving knife protocols can have multiple knifes and multiple players that move them across the cake until some stopping condition is met.
The high level description of our formal model has an ordered collection of “knives” each of them controlled by a single player, who can place his knife on the cake based on the locations of the previous knives in the collection as well as his own valuation. Each player moves his knife continuously as a function of “the time” and the locations of the previous knives, until some condition happens. The basic idea of the simulation is that (a) Given the position of previous knives (and the current time), each player can announce the (approximate) position of his knife using a small () amount of communication (b) to find the (approximate) time where the condition happens, the players can engage in a simple binary search which takes rounds (in each of which each player had to announce his location).
The details of the definition balance between ensuring that everything is smooth and robust enough so that this general idea can work and allowing enough flexibility to capture a wide family of reasonable protocols including all known ones. In particular, our definition allows multiple “moving knife steps” with “simple” and “robust” decisions between these steps, where all known moving knife protocols require only a constant number of steps. The exact definition appears in Appendix B, and it allows the following simulation statement.
Let be any moving knife protocol that runs in constantly many steps and outputs -fair partitions.
Then for every , there is a communication protocol that uses rounds each with bits of communication and outputs --fair partitions.
This implies that procedures such as the Austin [Aus82] procedure, the Barbanel-Brams, Stromquist, and Webb moving knife protocols [BB04, RW98], and the moving knife step for computing equitable allocations among any number of players [BN17, SHS17] can be simulated efficiently in the communication model.
Austin’s procedure for computing a perfect allocation between two players, the Barbanel-Brams, Stromquist, and Webb procedures for computing an envy-free allocation with connected pieces among players, and the moving knife step for computing an equitable allocation for any fixed number of players can be simulated using rounds each with bits of communication for all .
Notice that this simulation requires rounds of communication, as opposed to the simulation of the RW model that only requires a constant number of rounds. Our lower bounds (Corollary 8) will imply that this is unavoidable.
4 Proportional Cake Cutting
We turn to the problem of computing allocations for specific fairness notions and start with the most basic, known as proportionality.
4.1 A General Logarithmic Lower Bound
A logarithmic (in ) lower bound is trivial not just for communication protocols but for any model with a bounded number of answers to every query. This lower bound applies to essentially any cake cutting challenge, and we will prove it for the simplest one of proportional cake cutting between any fixed number of players.
For every fixed , any protocol whose queries all have a bounded number of possible answers and always makes at most cuts requires queries for -proportional cake cutting between of players.
We will show that the computation tree of the protocol requires leaves. Let be the total number of leaves of the protocol and let be the set of all cuts made at all leaves of the protocol (thus ).
We will now choose a profile of valuations on which it is impossible that the protocol achieves -proportionality. In this chosen profile, all players will have the exact same valuation . We will choose in a way that puts a weight that is an integer multiple of , for some fixed integer , in every sub-interval . That would imply that every player gets a total value that is an integer multiple of . If we choose to be relatively prime to then certainly for every integer we would have . If then at least one player would have to get a value that is less than by more than .
We will choose which is relatively prime to which ensures that and now need to construct the required valuation . Our goal is to assign to every sub-interval a weight that is an integer multiple of that is close to its length . This is done by first rounding down to an integer multiple of and setting it as (our initial version of) . This is not quite a valuation since we may be missing a total weight that is at most (a rounding loss of at most for each of the sub-intervals). Now, if then the longest of the sub-intervals is longer than and we can put all the missing weight on it, increasing the density on it from at most to at most satisfying the condition of bounded density. ∎
4.2 A Simultaneous Upper Bound
The number of rounds in the general RW simulation is the same as the number of queries in the original RW protocol. In some cases one can get very simple communication protocols, such as the following, which is derived from a simultaneous protocol from [BBKP14].
For every fixed , there exists a protocol for finding a connected -proportional allocation between players, where the players simultaneously, in a single round, send bits of communication and the allocation is determined by the sent messages.
The players first approximate their valuations by -simple ones (for ) and then each player sends the locations that split its simple valuation into pieces each of weight exactly . (As in the proof of Lemma 5, the simplicity of the approximating valuation allows representing each of these locations using bits.)
We can now use this information to construct a proportional allocation among the approximating valuations: denote to be the location sent by player , and for notational convenience define and for all players. Thus we have that for all and (here is the approximate simple valuation, not the original one.)
Let and let and allocate to . Let and , and allocate to . Similarly, at each stage we allocate the next piece the the player who wants the smallest amount. The correctness of this allocation follows from the fact that at each step of the allocation, the allocated piece of the cake was to the left of for all unallocated players . ∎
Open Problem 2.
What is the simultaneous communication complexity of -envy-free cake cutting between players (into an arbitrary finite number of pieces)?
5 Equitable, Perfect, and Envy-Free Cake-Cutting
Finally we study fairness notions 131313We focus on allocations that use a minimum number of cuts. for which moving knife protocols exist: equitable and perfect allocations for players, and envy-free for players.
5.1 The Crossing Problem
We will relate these fair division problems through a discrete search problem called crossing that we now introduce.
The general problem is the following: Alice gets a sequence of integer numbers with for all and similarly Bob gets a sequence of integer numbers with for all , and such that and . Their goal is to find an index such that either both and or that both and .141414An even more difficult variant of this problem would insist that the output is the former rather than the latter. This variant does not seem to correspond directly to any fair division problem so we will not name it. It is worth noting that the protocol in the proof of theorem 5.1 solves this harder variant as well.
In the monotone variant, , Alice and Bob are also assured that and and again need to find an index such that and .
The -equitable cake cutting problem can be seen as equivalent to monotone crossing as follows.
For players, the -equitable cake-cutting problem into connected pieces can be reduced to the problem for with an additional single round where each player send bits to the other one.
The players will start by rounding their valuations to -simple ones as allowed by Lemma 3 (with ), and will achieve an equitable allocation on these simple valuations which by Lemma 3 also approximately solves the problem on the original valuations. So for the rest of this proof let us assume that each is already -simple.
Now, for a fixed player, if we define , we certainly get that . Let us denote, just for Bob, so . (And for Alice we keep the notation.)
A solution for the
problem on these vectorsand will give an index such that and and thus while which implies that for some intermediate value we have exactly and moreover since simple valuations, by definition, are linear between and , the exact value of can be computed from the values which the players can send to each other in a single round. Now splitting the cake at location is an equitable allocation since . ∎
The problem can be reduced (without any additional communication) into the -equitable cake cutting problem among players into connected pieces, with .
Given her input , Alice will construct the following valuation :
. (I.e. only weight is left for the sub-interval .)
Constant density within and . I.e. the density in these two sub-intervals is .
For every integer , let .
Constant density within each subinterval . I.e. the density is .
Bob will similarly create his own valuation using the values . Notice that for each we have that , and so . In particular, due to the integrality of and , if then while if then .
Now consider a solution to the -equitable cake cutting problem where , equivalently, . If then this cannot be the case if either or . It thus follows that and as needed. ∎
Next we show that -perfect cake cutting is equivalent to the general crossing problem. The omitted proofs of this section can be found in Appendix A.1.
For players, the -perfect cake-cutting problem into intervals can be reduced to the general problem for with a single additional round of bits of communication.
The general problem can be reduced (without any additional communication) into the -perfect cake cutting problem among players into intervals, with .
Finally, we show -envy-free cake cutting for players can be reduced to monotone crossing.
For players, the -envy-free cake-cutting problem with connected pieces can be reduced to the problem for with an additional constant number of rounds of bits of communication.
5.2 The Communication Complexity of the Crossing Problem
We study the communication complexity of the crossing problem and start with an upper bound.
The deterministic communication complexity of is . The randomized communication complexity of is .
The deterministic upper bound follows from our general simulation result of moving knife procedures, but here is a simple protocol: the players perform a binary search over the indices. At each point during the search they have a sub-interval of indices where and , looking at the middle point between and , once they determine whether or they know which sub-interval to continue the search in. Since and are integers in the range , comparing and requires bits of communication. The binary search itself requires such comparisons.
For the randomized protocol, we invoke the results of [Nis93] stating that the randomized communication complexity of determining which of two -bit integers (here we have ) is larger is . Moreover, with that complexity the probability of error can be made reduced to be for any desired constant . Thus each of the comparisons in our protocol can be done, with probability of error, say, by a randomized protocol with bits of communication. Since we make at most such comparisons, the total probability of error still stays low, and the total number of bits of communication is as required. ∎
For the monotone variant we give a more efficient protocol that uses only communication. Towards this end, we consider two parameters for the problem: , the number of integers held by the players and , the upper bound on their values.
The problem is the following: Alice gets a sequence of integer numbers and Bob gets a sequence of integer numbers . Their goal is to find an index such that and .
The (deterministic) communication complexity of the problem is . In particular when (what we called the problem), the communication complexity is .
In the first step Alice and Bob each send a single bit describing whether and . Now there are four possible answers:
If and then define and . Notice that and , so we solve the problem recursively on the ’s and ’s and find an index such that and .
Now if then and so and and since also , while for we only know that . So we get that and as needed.
On the other hand if i.e. then and so and and since also , while for we only know that . So we get that and as needed.
If and then define and . Notice that and , so we solve the problem recursively on the ’s and ’s and find an index such that and