1 Introduction
Producing an envyfree allocation of an infinitely divisible resource is a classic problem in fair division. As it is customary in the literature, the resource is represented by the interval
, and each agent has a probability measure encoding her preferences over subsets of
. The goal is to divide the entire interval among the agents so that no one envies the subset received by another agent. We note that the partition does not need to consist of contiguous pieces; the piece of an agent may be any finite collection of subintervals.The problem has a long and intriguing history. It has been long known that envyfree allocations exist for any number of agents, via nonconstructive proofs [8, 17, 19]. For algorithms, the standard approach is to assume access to the valuation functions via evaluation and cut queries (see Section 2). Under this model, we are interested in counting the number of queries needed for producing an envyfree allocation. For two agents, the famous cutandchoose protocol requires only two queries. For three agents, the procedure of Selfridge and Conway [5] guarantees an envyfree allocation after at most 14 queries. For four agents and onwards, however, the picture changes drastically. The first finite, yet unbounded, algorithm was proposed by [4]. This was followed up by other more intuitive algorithms, which are also unbounded, e.g., [14, 11]. Finding a bounded algorithm was open for decades and positive results had been known only for certain special cases, like piecewise uniform or polynomial valuations [3, 9, 6]. It was only recently that a major breakthrough was achieved by Aziz and Mackenzie, presenting the first bounded algorithms, initially for four agents [1], and later for an arbitrary number of agents [2].
Despite these significant advances, the algorithms of [1, 2] are still of very high complexity. For an arbitrary number of agents, , the currently known upper bound involves a tower of exponents of , and even for the case of four agents, the known algorithm requires close to queries. On top of that, these algorithms are rather complicated and their proof of correctness requires tedious case analysis in certain steps. Hence, a cleancut and more intuitive algorithm is still missing.
Contribution: We focus on the case of four agents and present an improved algorithm that reduces the query complexity roughly by a factor of (requiring cut queries and evaluation queries). Our algorithm utilizes building blocks that are similar to the ones used by [1], but by incorporating new insights and simplifying several steps, we obtain a solution with significantly fewer queries. The main differences between our work and [1] are highlighted at the end of this section. Our algorithm works by maintaining a partial allocation along with a leftover residue. Throughout its execution, it keeps updating the allocation and reducing the residue, until certain structural properties are satisfied. These properties involve the notion of domination, where we say that an agent dominates another agent , if allocating the whole remaining residue to will not create any envy for . A crucial part of the algorithm is to get a partial allocation where one agent is dominated by two others. Once we establish this, we then exhibit how to produce a complete allocation of the cake without introducing any envy. Overall, this results in an algorithm with markedly lower query complexity.
Further related work: We refer the reader to the book chapters [10, 13] for a more proper treatment of the related literature. Towards simplifying the algorithm of Aziz and Mackenzie [1], the work of SegalHalevi et al. [16] (see their Appendix B) proposes a conceptually simpler framework, without, however, improving the query complexity. Apart from the algorithmic results mentioned above, there has also been a line of work on lower bounds. For envyfreeness, Stromquist [18] showed that there is no finite protocol for producing envyfree allocations where all the pieces are contiguous. Later on, Procaccia [12] established an lower bound for producing noncontiguous envyfree allocations. Apparently, there is still a huge gap between the known lower and upper bounds for the problem for any . Interestingly, for the stricter notion of strong envyfreeness, where we require each agent to believe she is strictly better off than anyone else, the known lower bound is also [7].
An Overview of the Algorithm
We start with a high level description of the main ideas. As with most other algorithms, our algorithm maintains throughout its execution a partial allocation of the cake, along with an unallocated residue. The goal is to keep updating the allocation and diminishing the residue, with the invariant that the current partial allocation is always envyfree. Once the residue is eliminated, we are left with a complete envyfree allocation. As mentioned earlier, the notion of domination is pivotal in our approach. The algorithm creates certain domination patterns between the agents, working in phases as follows:
Phase One. We find this first phase of particular importance, as it is also the most computationally demanding one. Here the goal is to get a partial envyfree allocation in which some agent is dominated by two other agents as in Figure 0(a). In order to establish dominations among agents, we use as a subroutine the socalled Core protocol. In the Core protocol one agent has the role of the “cutter”, and the output is a new allocation with a strictly diminished residue. The properties of Core have several interesting and crucial consequences. First, if Core is executed twice with the same agent as the cutter, then this cutter dominates at least one other agent in the resulting allocation. Moreover, if we run Core two more times, we may not get any extra dominations right away but we can still make a small correction so that the cutter dominates one more agent. This is done by using a protocol, referred to as the Correction protocol, which performs a careful redistribution. Finally, by running Core one more time with a different cutter and the current residue, we show how further dominations arise that lead to the desired structure of one agent being dominated by two others. In total, phase one requires up to 6 calls to the Core protocol.
Phase Two. Suppose that at the end of phase one, agent is dominated by agents and . The goal in the second phase is to produce a partial envyfree allocation where both and dominate both and . To achieve this goal, we execute Core twice on the residue with as the cutter. Then, if we still do not have the required dominations, we use again the Correction protocol to appropriately reallocate one of the last two partial allocations produced by Core. This suffices to create the dominations shown in Figure 0(b).
Phase Three. Since both and are now dominated by and , we can simply execute the cutandchoose protocol for and on the remaining residue.
Similarities and Differences with the AzizMackenzie Algorithm in [1]
Our algorithm uses similar building blocks as the algorithm for four agents in [1], combined with new insights. Namely, our Core and Correction protocols on a high level serve the same purpose as the core and the permutation protocols in [1]. Conceptually, a crucial difference is the target structure of the domination graph. The initial (and most querydemanding) step of [1] is to have every agent dominate two other agents. Here, our goal in phase one is to have just one agent dominated by two other agents. Once this is accomplished, it is possible to reach a complete envyfree allocation much faster. Another important difference is the implementation of the Core protocol itself. Our version is simpler regarding both its statement and its analysis. It also differs in the sense that it takes as input more information than in [1], such as the current allocation, and it is not required to always output a partial envyfree allocation of the current residue. This extra flexibility allows us to avoid the tedious case analysis stated in the core protocol of [1] and, at the same time, further reduce the number of queries.
2 Preliminaries
Let be a set of four agents. The cake is represented as the interval ; a piece of the cake can be any finite union of disjoint intervals. Each agent is associated with a valuation function defined on all finite unions of intervals. We assume that the valuation functions satisfy the following standard properties for all :

Normalization: .

Additivity: for all disjoint : .

Divisibility: for every and every , there exists such that . Note that this implies that , for all .

Nonnegativity: for every it holds that .
By we denote the allocation where agent is given the piece .
Definition 1 (Envyfreeness).
An allocation is envyfree, if , for all , i.e., every agent prefers her piece to any other agent’s piece.
We say that is a partial allocation, if there is some cake that has not been allocated yet, i.e., . The unallocated cake is called the residue. During the execution of the algorithm the residue diminishes, until eventually it becomes the empty set. As we noted, an important notion is that of domination or irrevocable advantage [5]. It will be insightful to think of a graphtheoretic representation of our goals, via the domination graph of the current allocation.
Definition 2 (Domination and Domination Graph).
Given a partial allocation and a residue , we say that an agent dominates another agent , if . That is, would not be envious of even if were allocated all of . The domination graph with respect to is a directed graph where the nodes correspond to the agents and there exists a directed edge if and only if agent dominates agent .
Achieving certain patterns in the domination graph can make the allocation of the remaining residue straightforward. For example, if there exists a node with indegree , allocating all of the residue to agent results in an envyfree allocation. As another example, the protocol of [1] tries to get a domination graph where every node has outdegree at least . In our algorithm, we also enforce a certain structure on the domination graph.
The RobertsonWebb Model
The standard model in which we measure the complexity of cake cutting algorithms is the one suggested by Robertson and Webb [15] and formalized by Woeginger and Sgall [20]. In this model, two kinds of queries are allowed:

Cut queries: given an agent , a point and a value , with , the query returns the smallest such that .

Evaluation queries: given an agent and an interval , return .
Virtually all known discrete cakecutting protocols can be analyzed within this framework. For example, the cutandchoose protocol is implemented as follows: the algorithm makes one cut query for agent 1 with , starting from . This is followed by an evaluation query on agent for one of the pieces (which also reveals the value of the second piece).
Conventions on Ties, Marks, Partial Pieces, and Residues
All algorithms in this work ignore ties. However, assuming an appropriate tiebreaking scheme, this is without loss of generality (also see the discussion in [2]).
We follow some conventions—also adopted in related work—when it comes to handling trims and partial pieces. In various steps during the algorithm, one agent cuts the residue into pieces, and the other agents are asked to place marks on certain pieces. We always assume that marks are placed starting from the left endpoint of a piece, and this operation creates a partial piece, contained between the mark and the right endpoint. In particular, suppose we have a partition of the residue into four contiguous pieces. Then, an agent may be asked to place a mark on her most favorite piece so that the resulting partial piece has the same value as her second favorite piece (see Figure 2). The types of marks that the algorithm needs are described in the following definition.
Definition 3.
Given a partition of the residue into four pieces, we say that an agent performs an mark, if she places a mark on each of her most valuable pieces so that the resulting partial pieces all have the same value as her th favorite piece.
In the description of the algorithm we use marks and marks. Of course, after all marks are placed, each connected piece may have multiple marks on it. Whenever a connected piece is only partially allocated, the part of that is allocated is always the interval between the second rightmost mark and the right endpoint of . While at this point it is not clear whether a second mark on a piece even exists, we will argue later on that marked pieces will have at least two marks (Lemma 4). Hence, if some agent receives a partial piece , resulting from an initial piece , it is not necessarily true that is defined by ’s own mark. However, in such a case the algorithm always makes sure that receives a part of that is beyond ’s own mark. Formally, we say that is allocated a part of piece beyond (resp. strictly beyond) a mark , if is allocated with (resp. ).
Note that in the above discussion the residue is seen as a single interval, while in fact it may be a finite union of intervals. We keep this view throughout this work as it is conceptually easier and allows for a cleaner presentation. Asking queries on pieces can, of course, be simulated by asking queries on intervals, but the number of the latter can grow linearly on the number of intervals that make up a piece.^{1}^{1}1This issue has not been addressed in the query counting of [1], but there the main goal was to obtain a bounded algorithm. Here we do keep track of the extra queries. We take care of this by making sure that at any time, the algorithm knows for every agent the values of all the intervals that make up the residue (see the query counting argument in the last part of Section 4).
3 The Algorithm
The main result of our work is the following.
Theorem 1.
The Main Protocol returns an envyfree allocation and makes at most cut queries, and evaluation queries.
We discuss first the main steps of our algorithm and provide the relevant definitions and key properties, needed for the proof of correctness, in Section 3.1.
Phase One.
This is the most important part of the protocol, and computationally the most demanding one. The goal in phase one is to get a partial envyfree allocation, where some agent is dominated by two other agents, i.e., the underlying domination graph has a node with indegree at least , as depicted in Figure 0(a). In order to establish dominations among agents, we use a subroutine called Core protocol (stated in Section 4). This protocol takes as input a specified agent, called the cutter, the current partial allocation, and the current residue. For technical convenience, Core also takes as an input a subset of agents that we choose to exclude from competition (this is made precise in the description of Core in Section 4 but it roughly means that the excluded agents will choose their piece late in the Core protocol). In most cases, this argument is just the empty set. In particular, when no such argument is specified we mean that it is . The output of Core is a partial (usually envyfree) allocation of the residue with some additional properties described below. In the initial step of Core, the cutter divides the current residue into four equalvalued pieces according to her own valuation function. Throughout the protocol the rest of the agents—the noncutters—may mark these pieces, and at the end, agents may be allocated either partial (marked) or complete pieces. Of course, if at any point Core outputs an envyfree allocation of the whole cake, the algorithm terminates. The full description and the analysis of Core is given in Section 4. For now, we treat it as a black box and we assume that it satisfies the following properties.
Core Property 1.
The cutter and at least one more agent receive complete pieces, each worth exactly of the value of the current residue according to the cutter’s valuation.
Core Property 2.
The allocation output by any single execution of Core when no agent is excluded from competition, is a (possibly partial) envyfree allocation.
The above properties allow us to deduce an important fact: if Core is executed at least twice with the same agent as the cutter, then this cutter dominates at least one agent in the resulting allocation. In fact, we can be more specific about the agent who gets dominated. The important observation here, stated in Lemma 1 (Section 3.1), is that a second run of Core makes the cutter dominate whoever received the socalled insignificant piece in the first execution.
Definition 4.
Let be an allocation produced by a single run of Core. Among the four pieces given to the agents, the partial piece that is least desirable to the cutter is called the insignificant piece of .
Hence, if we run Core twice, say with agent as the cutter, we enforce one edge in the domination graph. In order to proceed further and obtain a node with indegree two, we first attempt, as an intermediate step, to have a domination graph where one node has outdegree equal to two. One may think that the intermediate step can be achieved by running Core more times with agent as the cutter. The problem with this approach is that even if we further execute Core any number of times, there is no guarantee that new dominations will appear; the same agent may receive the insignificant piece in every iteration.
To fix this issue, it suffices to run Core 4 times with agent as the cutter and then make a small correction to one of the partial allocations produced by Core. In particular, denote by , with , the suballocation output by the th execution of Core within the for loop of line 1 of Main Protocol, and let be the residue after the th execution. Then clearly for each agent , , and the current allocation of the algorithm after the 4 calls to Core is , with . Among these suballocations that consists of, we identify one in which we can perform a certain redistribution without introducing any envy. To do this, we exploit the notion of gain, which is the difference between the value that an agent has for her own piece compared to the pieces of agents she does not dominate.
Definition 5 (Gain).
Let be the current partial allocation of the cake, and be a suballocation of , i.e., for . Further, let be the set of agents that are dominated by in and . Then the gain of with respect to , , is the difference between and the maximum value of for a piece in given to any agent in , i.e., .^{2}^{2}2Note that is not defined when . In fact, we never need it in such a case.
Using Definition 5, we identify a suballocation among , where the gain of each agent is small compared to her combined gain from the other three suballocations (line 1 of the algorithm). The existence of such an allocation is shown in Lemma 2. Then, the redistribution is performed via the Correction protocol which takes as input an allocation , produced by Core, and outputs an allocation , where is a permutation on . In doing so, special attention is paid to the insignificant piece of . For now, we treat Correction as a black box and ask that it satisfies the three properties below; see Section 5 for its description and analysis.
Correction Property 1.
The insignificant piece of is given to a different agent in . In particular, it is given to an agent that has marked it in .
Correction Property 2.
If a noncutter was allocated her favorite unmarked piece in , she will again be allocated a piece of the same value in .
Assume there is no agent dominating everyone else, meaning that is defined for all . For a partial envyfree allocation like , the gain of any agent is nonnegative. However, this may not be true for , as it is not necessarily envyfree. What we need is for to be envyfree, and towards this should not be too small for any .
Correction Property 3.
for all agents .
By Correction property 1, the insignificant piece has changed hands after line 1. This allows us to make one extra call to Core in order to enforce one more domination (line 1). Hence, the intermediate step is completed and we know that agent dominates at least 2 other agents. If she dominates all three of them, we can run any of the known procedures for 3 agents on the residue, and be done with only a few queries. The interesting remaining case is to assume that agent currently dominates exactly two other agents.
At this point there are various ways to proceed, each with a different query complexity. E.g., we could repeat the whole process so far, but with agents and as cutters, and get at least 6 edges in the domination graph. This would ensure a node with indegree two, but it requires several calls to Core. Instead, and quite remarkably, we show that it suffices to run Core only one more time, with the agent who is not dominated by agent as the cutter. As we prove in Lemma 3, this makes the cutter dominate one of the agents that are dominated by agent . Hence, phase one is now complete, as we have one agent with indegree two.
Remark 1.
The intermediate step of getting a node with outdegree two has also been utilized in [1]. The goal there however was to make every agent dominate two other agents, whereas we only needed this to hold for one agent.
Phase Two.
Suppose phase two starts with a partial envyfree allocation where some agent, say , is dominated by agents and (Figure 0(a)). Our next goal is to produce a partial envyfree allocation where both and dominate both and (Figure 0(b)). To achieve this goal, we execute Core twice with as the cutter, i.e., with the agent not involved in the dominations of Phase one. Again, we need to argue about the behavior of Core under the existing dominations, and we ask for the following property.
Core Property 3.
Assume we run Core with as the cutter, and suppose agent is dominated by the other two noncutters, and , neither of whom dominates the other. Then, (1) gets her favorite of the four complete pieces without making any marks, (2) at least three complete pieces are allocated, and (3) if a noncutter, say , gets a partial piece, then the remaining noncutter, , is indifferent between her piece and ’s piece.
Using this property, we can show that after one call to Core (1st execution of line 1), agents and will both dominate either or . However, we need domination over both and . The second call to Core (2nd execution of line 1) ensures that we can again resort to the Correction protocol. If, after the two calls to Core, only one of and , say , is dominated by both and , then running Correction on one of the two core allocations from this phase—the one where the gain of is smaller—resolves the issue, and makes and dominate both and .
Phase Three.
Since both agents and are dominated by and , we just execute the cutandchoose protocol for and , where cuts the residue in two equal pieces and chooses her favorite piece. This completes our algorithm.
3.1 Proof of Correctness of the Main Protocol
In this section we analyze the correctness and the complexity of the main protocol. For our proof, we assume that Core and Correction satisfy the properties mentioned earlier. For now, we take as granted the following theorems, which are proved in Sections 4 and 5 respectively.
Theorem 2.
Theorem 3.
We start with one of the most important observations for our analysis: running Core twice with the same cutter creates an edge in the domination graph. Lemma 1, as well as Lemma 2 below, has its counterpart in [1] concerning their core protocol.
Lemma 1.
Starting with an envyfree partial allocation, if Core is executed two (not necessarily consecutive) times with the same agent, say , as the cutter, then in the resulting allocation dominates the agent who got the insignificant piece in the first execution. Moreover, if the insignificant piece was the only partial piece in the first execution, then the above domination is directly established at the end of the first execution.
Proof.
If only one piece is partially allocated in the first execution, let , where , are the allocated and unallocated parts of respectively. It holds that , and, for all other pieces allocated in that execution, . Therefore, is the insignificant piece and is allocated to . Moreover, for the total residue after the execution, , we have that . Combining the above, we get that , and since the cutter was allocated value equal to , she won’t be envious of even if the latter where allocated the entire residue . That is, dominates .
If more than one piece was partially allocated, then by Core property 1 exactly two pieces were partially allocated. Therefore, the residue after the first execution is , where , are the unallocated parts of the insignificant and the other partially allocated piece respectively. By the definition of we have and thus . Let be the new residue after any possible inbetween executions of Core. Clearly, we have . Finally, let be the residue after the second execution of Core with as cutter. Then , since two out of the four equal pieces are allocated whole by Core property 1. Combining the two inequalities we get . However, in the first execution ’s piece was worth to her at least more than ’s piece, and all the intermediate partial allocations between the two executions are envyfree by Core property 2. This means that would not be envious even if the whole was given to . ∎
Next, we need the existence of a suitable input for Correction at line 1 of the main protocol. Recall that is the allocation output by the th execution of Core. The following lemma is rather straightforward using a pigeonhole principle argument.
Lemma 2.
Suppose Core is run consecutive times with agent as the cutter. Then, there exists an allocation such that for all agents :
Proof.
It is possible that only if is the maximum of , . Let , for . It suffices to show that for some , for all . This, however, is straightforward since there are at least options for and only takes values. ∎
Finally, the next lemma guarantees that lines 11 do create a second domination over an agent already dominated by agent , if such a domination is not already there, without destroying envyfreeness of the overall allocation.
Lemma 3.
Suppose we have an envy free allocation where an agent, , dominates two other agents, and . If we run Core with the remaining agent as the cutter, excluding from competition, then will dominate or in the resulting envyfree allocation.
Proof.
The exclusion of from competition greatly simplifies the execution of Core. It is easy to check that in this case Core is equivalent to the following algorithm:

cuts the residue into 4 equalvalued pieces.

If agents and have different favorite pieces, the agents choose a piece in the order and the algorithm terminates with a complete envyfree allocation.

Otherwise, and make a 2mark on their common piece. Suppose has the rightmost mark on this piece (the other case is symmetric).

gets the marked piece up to ’s mark.

gets her second favorite piece.

gets her favorite piece among the two remaining.

gets the remaining piece.
Clearly now dominates since the initial allocation was envyfree, is the cutter and got the unique partial piece. It remains to show that the resulting allocation is still envyfree. First, as the cutter gets a piece of equal value to her favorite piece. Moreover, it is straightforward that and cannot envy each other, neither do they envy as they choose their pieces before her. Finally, was dominating both and , hence she will continue to dominate them, and she chose her piece before . ∎
Given all the above ingredients, we are ready to prove our main theorem.
Proof of Theorem 1. We first argue about the correctness of the Main Protocol. It suffices to prove that phases one and two terminate with the desired domination structures. Then it is straightforward that the third phase results in an envyfree allocation.
Phase one: Lemma 1 guarantees that once the for loop is completed in phase one, we have a domination graph where node has outdegree at least one.
We first consider the case where at least 2 agents got an insignificant piece in lines 11. Then Lemma 1 guarantees that after line 1 agent dominates all those agents. If lines 11 are executed, Lemma 3 guarantees that some agent becomes dominated by both agents and and phase one is successfully completed. Otherwise, lines 11 are executed and the algorithm terminates returning a complete envyfree allocation. The latter holds because when agent dominates all other agents, we only need to divide the residue among them. What is left to be shown is that after line 1 the overall (possibly partial) allocation is envyfree. Then, either the SelfridgeConway protocol completes the allocation without introducing any envy, or Lemma 3 guarantees that the overall allocation at the end of phase one is envyfree. Core property 2, however, takes care of the envyfreeness after line 1 because so far we have only executed Core with no excluded agents from competition (5 times).
The remaining case is when the same agent got the insignificant piece in all 4 iterations in lines 11, i.e., when the condition in line 1 is true. Among the 4 Core allocations produced in lines 11, let be an allocation satisfying the conditions of Lemma 2. The execution of Correction with input gives an allocation where the insignificant piece with respect to is given to a different noncutter, due to Correction property 1. Since the insignificant piece has gone now to a different agent, Lemma 1 implies that running Core one more time with agent as the cutter results in agent dominating a new agent in addition to the old one. Thus, with respect to the target domination graph, we argue about lines 11 like above. That is, either we get the desired domination pattern in lines 11 or the algorithm terminates with lines 11. We still have to show that the allocation right after line 1 is envyfree. However, by the choice of and Correction property 3, for we have for all agents , i.e., is envyfree. Core property 2 and Lemma 3 guarantee that the allocation at the end of phase one is envyfree as well.
Phase two: Having obtained a partial allocation where one agent, say , is dominated by two others, say and , we execute Core twice on the current residue with the remaining agent as the cutter (line 1 of the main protocol). First, suppose that there is at least one agent excluded from competition. Without loss of generality, we may assume is such an agent. Then it is very easy to check (see Core in the next section) that this execution of core is equivalent to having cut in four equal pieces, and agents pick in order , , , , thus resulting in a complete allocation of the residue. Taking into account the dominations of over as well as of over and , we see that such an allocation is also envyfree.
We conclude that, if line 1 is reached, there was no domination between and before each of the last two Core executions. That is, these executions excluded no one from competition. Therefore, we can combine Core property 3 (which guarantees there is only one partial piece) with the fact that the allocation so far is envyfree to guarantee that the first Core execution resulted in and both dominating one of and , specifically, the one who got the only partial piece (if there is no such piece, the algorithm terminates with a complete envyfree allocation). To see this, suppose is the agent who received the partial piece. By Core property 3, we know that gets her favorite piece, gets a complete piece (equivalent to her favorite piece), and the leftover residue is derived only from the partial piece of . Hence, and cannot be envious even if the whole residue is given to .
A possible complication now is that the second Core execution might result again in getting the partial piece. Let be the overall partial allocation so far, i.e., at line 1. We execute Correction on the Core allocation (out of the two last ones) where is smaller. By Core property 3, we have that agent never marked a piece in . But neither did , since she is the cutter. Thus, by Correction property 1, the unique partial piece of goes to in . At the same time and received the value of their favorite complete piece in both corresponding executions of Core, following Correction properties 2 and 3 (note that , as is the cutter). Combining this with the fact that and each received the unique partial piece of one suballocation, we get that and now dominate both and .
Finally, we argue about the overall partial allocation being envyfree. Clearly, and are nonenvious. By the choice of , we have , where , thus is not envious. On the other hand, is not envious since by Core property 3 she was indifferent between her piece and ’s piece in the first place.
Counting Queries: In the worst case, at most calls to Core are required followed by a call to Cut and Choose. Theorem 2 directly gives an upper bound cut and evaluation queries. For a more detailed argument matching the statement of the theorem, see the last part of the next section. ∎
4 The Core Protocol
An important building block of the whole algorithm is the Core protocol, used for allocating part of the current residue every time it is called. We begin with a highlevel idea of how Core works. It takes as input an agent, specified as the cutter, the current residue, and the current partial allocation. Core first asks the cutter to divide the residue into four equally valued contiguous pieces. The cutter is going to be the last one to receive one of these four pieces. Regarding the remaining three agents, each of them will either be immediately allocated her favorite piece or will be asked to place a mark on certain pieces, based on the relative rankings of the noncutters for the pieces, and on possible domination relations that have already been established. Marks essentially provide limits on how to partially allocate pieces that are desired by many agents, so that they can be given without introducing envy.
As seen in the pseudocode description of Core, there are two possible types of marks that can be placed; marks and marks. The type of mark that the agents will be asked to place depends mainly on the conflicts that arise for the favorite and second favorite pieces of each agent. The conditions that determine whether an agent will be asked to place a mark or a mark are described in lines 2 and 2 of the core protocol. These conditions simplify significantly the numerous cases that arise in the core protocol of [1]. To describe the protocol, we need to formalize conflicts between agents for certain pieces.
Definition 6.
During an execution of Core, let be a set of pieces and be a subset of noncutters. We say that an agent has competition for a piece , if (1) is not dominated by everyone in , and (2) there exists such that is ’s favorite or second favorite piece in . We call a competitor of for the piece .
Definition 6 helps us identify whether we need to perform a mark or mark on the available pieces. Furthermore, in some cases where we know that certain domination patterns appear, it is convenient to prevent some agents from competing for any piece. Hence, Core also takes as an input a subset of agents that are excluded from competition in line 2. In most cases, this argument is the emptyset, with the exception of lines 1 and 1 of the Main Protocol.
The main result for Core, which is crucial for the entire algorithm to work, is the next theorem.
Theorem 2. The Core protocol satisfies Core properties 1, 2 and 3, and makes at most cut queries and evaluation queries.
The proof of Theorem 2 is based on a series of lemmas regarding the properties of Core. We start by establishing the following key lemma.
Lemma 4.
Let , be the four pieces created by the cutter in the initial step of Core. After all markings have taken place, at most two pieces have marks and each marked piece has at least two marks.
Proof.
We prove the statement for the case where no agent is excluded from competition. Note that when someone is excluded from competition, the lemma is either straightforward (at least two agents excluded) or reduces to case (1.) below.
To facilitate the proof we use a convenient matrix notation to describe instances. E.g.,
1  2  

1  3  2  4 
2  1 
Each row corresponds to a noncutter, call them . Each column corresponds to a piece: , , and . The number in cell indicates the rank of piece for agent . A blank cell means “any of the remaining options”. We say that two instances are isomorphic if their matrix notation is the same, up to renaming of the agents and pieces. We consider four cases:

Line 2 is not executed and all agents have a different favorite piece; the lemma is clearly true since there are no marked pieces in this case.

Line 2 is not executed and exactly two agents have the same favorite piece. The instance is isomorphic to:
1 1 1 
If agent has no competition for her favorite piece, she takes it and leaves. The remaining agents make exactly one 2mark each, on the first piece.

If agent has competition with exactly one agent for her favorite piece:
1 2 1 2 1 In this case, makes a 3mark, marking and , and makes a mark, marking . Therefore, will definitely have at least marks. can make a mark or a mark, depending on which is her second favorite piece, but she will definitelly make a mark on (and thus will have exactly two marks on it). It remains to show that no other piece is marked. If ’s second favorite piece is or , she makes a mark. Otherwise, she makes a mark, but her second mark is on .

If agent has competition with exactly two agents for her favorite piece:
1 2 1 2 1 Agents and make marks, on and , and thus at least two pieces are marked with marks each. It remains to show that no other piece is marked. If ’s second favorite piece is or she makes a mark on . Otherwise, she makes a mark on and .


Line 2 is not executed and all agents have the same favorite piece. If they also have the same second favorite piece, then they all make marks on the same two pieces. If they have different second favorite pieces, they all make marks on . Otherwise, the instance is isomorphic to:
1 2 1 2 1 2 In this case, and make a mark on and , while makes a mark on : two pieces marked with at least marks each. ∎
An almost immediate corollary is the following:
Corollary 1.
Proof.
If there existed two marked pieces and the same agent had the rightmost mark in both, then they will both be allocated in line 2. By Lemma 4, there are no other marked pieces, hence the pieces that have remained in lines 2 and 2 are unmarked. Otherwise, the else part in line 2 is executed (no agent has the rightmost mark in two pieces), and all partial pieces are allocated in line 2 of the algorithm. Hence, again, any pieces that have remained when the algorithm goes beyond line 2 are unmarked. ∎
Given Lemma 4, and since only marked pieces are allocated partially, it follows that the cutter and at least one other agent receive complete pieces, each of which the cutter values as of the input residue, thus establishing Core property 1: See 1 Towards proving the remaining Core properties, we first establish the following two lemmata. Note that the lemmata still hold when some agents are excluded from competition.
Lemma 5.
If all noncutters have placed their marks, as dictated by the Core protocol, and some agent has marked a piece , her value for up to her mark is equal to her value for her favorite unmarked piece.
Proof.
Assume agent has made an mark. We need to prove that her th favorite piece has remained unmarked after all agents have placed their marks. Suppose this is not the case. If had made a mark and someone marked her second favorite piece, it means she had competition for it. Thus, the condition in line 2 must have been true. But the condition would be true for her single competitor as well. So would also make a mark, leaving their common second favorite piece unmarked, leading to a contradiction. On the other hand, if had made a mark and some agent marked her third favorite piece, then at least three pieces would have been marked: ’s most, second, and third favorite piece. By Lemma 4, this is again a contradiction. ∎
Lemma 6.
If agent has made an mark, , she receives a piece with value at least equal to the value she has for her th favorite piece out of those that were still unallocated when she made her marks.
Proof.
First, we prove the statement for the case where gets a partial piece, i.e., gets her piece in line 2 or line 2. If makes a mark on a piece and she is allocated a part of in either step, she either gets the part of up to her mark (when she is the “other agent” of line 2) or a part of beyond her mark, i.e., of value at least that of her second favorite (original) piece by the definition of a mark. The argument for agents with 3marks who get partial pieces is identical.
Next, we prove it for the case where is allocated a complete piece in line 2, i.e., she did not have the rightmost mark on her favorite piece, nor was she the “other agent” of line 2. Then, by Lemma 5, ’s th favorite piece has remained unmarked and will be allocated completely. It remains to show that will be the one who gets that piece. If there is no other agent, apart from and the cutter, remaining in line 2, will surely get her th favorite piece. Suppose there is another agent remaining in line 2. Since at this point only unmarked pieces are unallocated, and three agents—, , and the cutter—are yet to receive a piece, it follows that only a single piece was marked, i.e., both and made marks on the same piece. But since neither nor got their favorite piece, there must have been a third agent competing for it. Therefore, condition (2) in line 2 does not apply, and the only way and are qualified for making a mark, is if they do not have competition for their second favorite piece (line 2). No competition for their second favorite piece, however, implies nonconflicting preferences in line 2. ∎
To continue with the analysis, we need to understand what could possibly cause agents to experience envy during the execution of the protocol. For this, suppose that an agent has made a mark on a piece. If an agent is allocated this piece strictly beyond ’s mark, Lemma 6 is not enough to ensure that will remain envyfree.
Lemma 7.
If agent marked a piece and she does not have the rightmost mark in two pieces, then no agent will be allocated strictly beyond ’s mark.
Proof.
Since has a mark on it, by Corollary 1, it could not have been allocated in line 2 or 2. If has the rightmost mark on , and since does not have the rightmost mark in another piece, it is her who gets (a part of) in line 2. If does not have the rightmost mark on , then can be allocated to another agent in line 2, or 2, or 2. But in these lines, pieces are allocated up to the second rightmost mark, hence, no agent can get a part of strictly beyond ’s mark. ∎
See 2
Proof.
Envyfreeness for an agent who either is the cutter, or was allocated her favorite piece completely is straightforward: If is the cutter, she considers all pieces to be equal and is allocated one of them completely, while the other agents are each allocated at most one complete piece. If is not the cutter but she still got her favorite piece completely, she is envyfree for the same reason.
Let be a noncutter who did not get her complete favorite piece. This means she was asked to make an mark, which, by definition, means that pieces left unmarked by have value at most her value for her th favorite piece. Let be this value. By Lemma 6, gets a piece of value . The pieces which are allocated completely are a subset of the pieces not marked by , thus they all have value at most to her. Therefore, will not be envious of any agent getting a complete piece. Now, if did not have the rightmost mark in two pieces, no partial piece will be allocated beyond her mark by Lemma 7. This means that such pieces will have a value of at most to her. Finally, if had the rightmost mark in two pieces, she will be given her favorite among the two, as seen in line 2, so she will not envy the agent who gets the other. This completes the proof of envyfreeness. ∎
See 3
Proof.
Agent is allocated her favorite piece completely in Line 2, since she is dominated by and and has no competition, thus satisfying (1). Towards (2), in case the remaining noncutters, and , have no competition for their favorite piece out of those remaining, each is allocated her favorite piece, the cutter is allocated the last piece and the algorithm terminates. Otherwise, they each have at most one competitor for their second favorite piece, therefore one of the conditions of lines 2 or 2 is met. This directly implies that only one piece will be marked, their common favorite, and since only marked pieces are allocated partially, three pieces will be allocated completely. Finally, towards (3), the condition of line 2 is not valid since there is only one marked piece, therefore line 2 is executed. Agent must have the rightmost mark on the marked piece and the only candidate for the second rightmost mark is agent . Since gets the piece up to the second rightmost mark, i.e., ’s 2mark, and gets her second favorite piece (excluding the piece given to ) completely, has the same value for her own and ’s allocated piece. ∎
Counting Queries
Recall the discussion in Section 2 about the residue being a finite union of intervals and not a single interval. It is important that our algorithm should know, at any time during its execution, the values of all the agents for all the intervals that make up the residue. Otherwise, our queries cannot be simulated by simple queries of the RobertsonWebb model. E.g., a query may ask to evaluate the pieces and of the residue . In fact, without any prior knowledge, one needs 3 simple evaluation queries for that; one query for , one for , and one for . However, assume we already knew the values of and . Then we only need one query for . During the execution of our protocols we want each of our “queries” to actually correspond to only one RobertsonWebb query. So we make sure that the relevant information is always available. In particular, when cutting or evaluating consecutive pieces, we do it from left to right, and by the end of each execution of Core we learn the value of any agent for any trim of a partially allocated piece.
When we ask agents to place a mark on a piece, this corresponds to 1 cut query, since we can simulate this action with a cut query. Thus Core requires evaluation and cut queries. We assume that in the beginning of the current execution all agents know the values of all the intervals that make up the residue.

The cutter is asked to cut the residue into four pieces in line 2. ( cut queries)

We ask evaluation queries so that every agent learns the value of each marked piece up to the second rightmost mark. Worst case, there are two marked pieces and for each we asked everyone but the agent that placed the second rightmost mark. ( evaluation queries)
Note that the protocol now has all the information needed to check the condition on line 2, find the values of the partial pieces, calculate gain, and know the values of all the intervals that make up the new residue.
It should be noted that in a few cases we know we have less queries. In particular, the calls to Core in lines 1 and 1 of the Main Protocol, are guaranteed to produce at most one partial piece. Therefore, in these 3 calls we only need cut queries and evaluation queries for everyone to learn the value of the marked piece up to the second rightmost mark. In total, each of these special cases of Core requires evaluation and cut queries instead of evaluation and cut queries.
Moreover, on the second execution of line 1, agents and (as they are called in the Main Protocol) never need to know the value of the marked piece up to the second rightmost mark.
In particular, the total number of queries of the Main Protocol is cut and evaluation queries.
5 The Correction Protocol
Correction takes as input an allocation , produced by a single execution of Core. It outputs a redistribution of the pieces such that the insignificant piece goes to a different agent. Some of the pieces are marked (the ones partially allocated by Core), while others are unmarked (the pieces allocated completely). Note that each of the marked pieces of still has exactly two marks, the rightmost and the second rightmost marks of the original untrimmed piece of the execution of Core that produced . This second rightmost mark coincides with the left endpoint of the allocated piece as it appears in allocation .
The redistribution should satisfy further properties, so that both the envyfreeness of the overall partial allocation and certain dominations are preserved. Towards bounding the “local” envy that the redistribution may cause, the notion of gain (see Section 2) is crucial.
In the pseudocode description below, we refer to the cutter in allocation as , the noncutter who holds the insignificant piece as , the noncutter who gets the insignificant piece after executing Correction as , and the remaining noncutter as .
The main result about Correction is the next theorem. The remaining of this section is dedicated to its proof.
Theorem 3. The Correction protocol satisfies Correction properties 1, 2 and 3, and makes no queries.
We stick to the notation we used in the description of Correction. That is, given an allocation , is the cutter, is the noncutter who holds the insignificant piece, is the noncutter who gets the insignificant piece after executing Correction on , and is the remaining noncutter.
Correction property 1 trivially holds, since in line 3 of Correction the insignificant piece is allocated to agent : See 1
See 2
Proof.
If is a noncutter who received her favorite unmarked piece in Core, she has made no marks. Therefore, since by definition and have made marks on the insignificant piece and is the cutter, is the only noncutter agent who could have formerly been allocated her favorite piece. We need to show that in this context will be the first to choose one of the complete pieces in Correction. If we are in the case of line 3, this follows immediately. Otherwise, since has made no marks, she is not allocated the other partial piece, and is thus the “final noncutter” of line 3 who chooses first among the two unmarked pieces. ∎
See 3
For the proof of Correction Property 3 we assume that is produced by a call to Core where no agent was excluded from competition. Note that this is always the case when Correction is used in our main protocol (see the proof of Theorem 1). We need Lemma 8 below, but first it is helpful to establish some tiebreaking conventions for what follows. Whenever a marked and a complete piece have the same value, we will consider the marked piece to be better from the agent’s perspective. Moreover, if an agent has the second rightmost mark in two pieces, then we arbitrarily consider one to be her favorite, and the other her second favorite.
Lemma 8.
Any noncutter who was not allocated her favorite whole piece when was produced, receives in value at least equal to that of her favorite piece in among those formerly allocated to agents in .
Proof.
Let . In most cases we will show the stronger—but easier to prove—property that ’s new allocation has value to her at least equal to that of her second favorite piece among all four pieces in .
We start by proving this for the case when Correction allocates a partial piece to . Note that this may happen only if has a mark on (lines 3, 3). Thus ’s value for up to her mark is equal to her value for her favorite unmarked piece, and therefore there is only one piece which might value more than : the other marked piece (if it exists). That is, is allocated her overall favorite or second favorite piece.
Next, we move to the case where is allocated an unmarked piece by Correction, distinguishing among the two subcases where that could happen: (a) in line 3, and (b) in line 3, where there are one and two marked pieces respectively.
For subcase (a), we claim that it suffices to show that is allocated value at least equal to that of her favorite unmarked piece out of those formerly allocated to agents in . To see that, note that the fact that there is only one marked piece, immediately implies that she is allocated value at least equal to that of her second favorite piece out of those formerly given to agents in . Since the input contains only one marked piece, nobody has made a mark. Moreover, since agents and have marks on the marked piece, they both made a mark. Clearly, receives as much value as possible, given , by getting the marked piece up to her mark. As for agent , she either had made a mark as well, or she had been allocated her favorite whole piece. If the former occurred: , and had the same favorite piece (part of which now constitutes the insignificant piece), and all made marks. Since each clearly had more than one competitor for her favorite piece, for all three the Core condition of line (2) must have been true, i.e., they all had different second favorite pieces. Therefore, in the input of Correction, each has a different favorite unmarked piece and each of and is allocated her favorite unmarked piece. If the latter occurred: had no competition from . So, either ’s favorite piece is ’s third or fourth favorite, or is dominated by . Therefore, after chooses her favorite piece (of the three unmarked ones in line 3), ’s favorite unmarked piece out of those formerly allocated to agents in is still unallocated and she can take it.
For subcase (b), first notice that if does not have a mark in both pieces, then her favorite unmarked piece (i.e., the one she chooses in line 3) is either her overall favorite or second favorite piece. On the other hand, if has a mark in both marked pieces, one of them is her favorite and the other is her second favorite. Since she weren’t allocated the noninsignificant marked piece, she must have had the second rightmost mark on it, which means she considers it equal to her favorite unmarked piece that she chooses in line 3. Thus, if the insignificant marked piece is her favorite, then the other marked piece is her second favorite and so has value equal to her second favorite piece. If not, then the noninsignificant marked piece is her favorite, and so has value equal to that of her favorite piece. Either way she is allocated value at least equal to that of her second favorite piece. ∎
Proof of Correction Property 3. Towards proving Correction property 3, recall Definition 5. Given a partial allocation and a suballocation of , let be an agent who dominates agents in . If is agent ’s piece in and is ’s favorite piece out of those allocated to agents in , then .
Now assume was produced by Core (and recall that no agent was excluded from competition). By Correction property 2, if was a noncutter in who was formerly allocated her favorite complete piece, then and hence . Similarly, if was the cutter in , then by line 3 of Correction we have . Therefore the difficulty lies in proving that the property 3 holds for noncutters who did not get their favorite whole piece when was produced. Suppose that after the permutation output by Correction, such a noncutter is still allocated the same piece . By Core property 2, we again have . The remaining, and most interesting, case is when such a noncutter is allocated a piece and some other agent is allocated ’s former (and favorite among the pieces in ) piece. By Lemma 8 we have that it is always the case that , and therefore . ∎
References

Aziz and Mackenzie [2016a]
H. Aziz and S. Mackenzie.
A discrete and bounded envyfree cake cutting protocol for four
agents.
In
48th ACM Symposium on the Theory of Computing, STOC 2016
, pages 454–464, 2016a.  Aziz and Mackenzie [2016b] H. Aziz and S. Mackenzie. A discrete and bounded envyfree cake cutting protocol for any number of agents. In 57th Annual IEEE Symposium on Foundations of Computer Science, FOCS 2016, pages 416–427, 2016b.
 Aziz and Ye [2014] H. Aziz and C. Ye. Cake cutting algorithms for piecewise constant and piecewise uniform valuations. In Proceedings of the 10th International Conference on Web and Internet Economics, WINE 2014, pages 1–14, 2014.
 Brams and Taylor [1995] S. J. Brams and A. D. Taylor. An envyfree cake division protocol. American Mathematical Monthly, 102(1):9–18, 1995.
 Brams and Taylor [1996] S. J. Brams and A. D. Taylor. Fair Division: from Cake Cutting to Dispute Resolution. Cambridge University press, 1996.
 Branzei [2015] S. Branzei. A note on envyfree cake cutting with polynomial valuations. Information Processing Letters, 115(2):93–95, 2015.
 Busch et al. [2005] C. Busch, M. S. Krishnamoorthy, and M. MagdonIsmail. Hardness results for cake cutting. Bulletin of the EATCS, 86:85–106, 2005.
 Dubins and Spanier [1961] L. Dubins and E. Spanier. How to cut a cake fairly. Amer. Math. Monthly, 68:1–17, 1961.

Kurokawa et al. [2013]
D. Kurokawa, J. K. Lai, and A. D. Procaccia.
How to cut a cake before the party ends.
In
Proceedings of the TwentySeventh AAAI Conference on Artificial Intelligence, AAAI 2013
, pages 555–561, 2013. 
Lindner and Rothe [2015]
C. Lindner and J. Rothe.
Cake cutting: Fair division of divisible goods.
In J. Rothe, editor,
Economics and Computation: An Introduction to Algorithmic Game Theory, Computational Social Choice, and Fair Division
, chapter 7. SpringerVerlag, 2015.  Pikhurko [2000] O. Pikhurko. On envyfree cake division. American Mathematical Monthly, 107(8):736–738, 2000.
 Procaccia [2009] A. D. Procaccia. Thou shalt covet thy neighbor’s cake. In Proceedings of the 21st International Joint Conference on Artificial Intelligence, IJCAI 2009, pages 239–244, 2009.
 Procaccia [2016] A. D. Procaccia. Cake cutting algorithms. In F. Brandt, V. Conitzer, U. Endriss, J. Lang, and A. D. Procaccia, editors, Handbook of Computational Social Choice, chapter 13. Cambridge University Press, 2016.
 Robertson and Webb [1997] J. M. Robertson and W. A. Webb. Near exact and envyfree cake division. Ars Combinatorica, 45:97–108, 1997.
 Robertson and Webb [1998] J. M. Robertson and W. A. Webb. Cake Cutting Algorithms: be fair if you can. AK Peters, 1998.
 SegalHalevi et al. [2015] E. SegalHalevi, A. Hassidim, and Y. Aumann. Waste makes haste: Bounded time algorithms for envyfree cake cutting with free disposal. Available at https://arxiv.org/pdf/1511.02599.pdf, 2015.
 Stromquist [1980] W. Stromquist. How to cut a cake fairly. The American Mathematical Monthly, 87(8):640–644, 1980.
 Stromquist [2008] W. Stromquist. Envyfree cake divisions cannot be found by finite protocols. Electr. J. Comb., 15(1), 2008.
 Su [1999] F. E. Su. Rental harmony: Sperner’s lemma in fair division. The American mathematical monthly, 106(10):930–942, 1999.
 Woeginger and Sgall [2007] G. Woeginger and J. Sgall. On the complexity of cake cutting. Discrete Optimization, 4(2):213–220, 2007.
Comments
There are no comments yet.