Equivalence of Models of Cake-Cutting Protocols

08/08/2021
by   Paul W. Goldberg, et al.
University of Oxford
0

The cake-cutting problem involves dividing a heterogeneous, divisible resource fairly between n agents. Brânzei et al. [6] introduced generalised cut and choose (GCC) protocols, a formal model for representing cake-cutting protocols as trees with "cut" and "choose" nodes corresponding to the agents' actions, and if-else statements. In this paper, we identify an alternative and simpler extensive-form game model for cake-cutting protocols, that we call branch choice (BC) protocols. We show that the class of protocols we can represent using this model is invariant under certain modifications to its definition. We further prove that any such protocol can be converted to a restricted form in which the agents first cut the cake and then get to choose between various branches leading to different allocations. Finally, we show that this model has the same expressive power as GCC protocols, i.e. they represent the same class of protocols up to a notion of equivalence involving the bounds on envy that each agent can guarantee for themselves. For this purpose, we introduce a new notion of envy-equivalence of protocols.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

06/27/2011

Online Cake Cutting (published version)

We propose an online form of the cake cutting problem. This models situa...
10/19/2020

Finding Cut-Offs in Leaderless Rendez-Vous Protocols is Easy

In rendez-vous protocols an arbitrarily large number of indistinguishabl...
04/15/2021

On Existence of Truthful Fair Cake Cutting Mechanisms

We study the fair division problem on divisible heterogeneous resources ...
11/14/2018

Cutting resilient networks -- complete binary trees

In our previous work, we introduced the random k-cut number for rooted g...
04/06/2020

Formal Verification of Flow Equivalence in Desynchronized Designs

Seminal work by Cortadella, Kondratyev, Lavagno, and Sotiriou includes a...
01/09/2018

A Deterministic Protocol for Sequential Asymptotic Learning

In the classic herding model, agents receive private signals about an un...
02/25/2020

RMB-DPOP: Refining MB-DPOP by Reducing Redundant Inferences

MB-DPOP is an important complete algorithm for solving Distributed Const...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The cake-cutting problem is a fair division problem which involves dividing a heterogeneous, divisible resource (the metaphorical “cake”) between several agents, who have different preferences over different parts of the cake. In practice, this framework can be used to divide various types of resources, such as land or time. The modern study of this problem dates back to Steinhaus [12] and a description of its history can be found in the books by Brams and Taylor [2] or Robertson and Webb [11].

To be able to tackle this problem, we need to establish what it means for a division to be fair. There are two common criteria for fairness, proportionality, in which each of the agents receives a piece that they consider to be worth at least of the entire cake, and envy-freeness, which means no agent prefers the piece another agent received over their own. If the entire cake is allocated, envy-freeness implies proportionality.

In the literature, well-known cake-cutting protocols are often described in plain language, but to be able to reason about protocols more generally or implement them on a computer, we require some formal model of computation. There are several such models, the most well-known ones being the Robertson-Webb model [11], which involves two types of queries: Eval queries, which ask an agent how much they value a given piece of cake, and Cut queries, in which an agent specifies where a piece of cake should be cut to be worth a certain value, and the moving-knives model (see, for example, Dubins and Spanier [8]), in which a referee continuously moves one or more knives across the cake until one of the agents calls “stop”.

More recently, Brânzei et al. [3, 4] introduced a new model for cake-cutting protocols, generalised cut and choose (GCC) protocols, in which rather than reporting their preferences to a referee, the agents divide the cake amongst themselves. In the GCC model, a protocol is represented as a tree with cut nodes, in which an agent makes a cut inside one of a set of pre-existing pieces of cake, choose nodes, in which an agent chooses from a set of existing pieces and is allocated that piece, and if-else statements depending on the execution history of the protocol.

In this paper, we propose an alternative model for representing cake-cutting protocols as trees, branch choice (BC) protocols: at cut nodes, an agent makes a cut inside a given piece of cake, similarly to GCC protocols, but at choose nodes, an agent instead gets to choose which branch of the tree to proceed to. The resulting pieces are allocated to various agents at leaf nodes. Having such a simple, restrictive model is an advantage when it comes to automation, since making the different possible choices and their outcomes more explicit would make it easier for AI agents to participate in a protocol.

We define various notions of equivalence between cake-cutting protocols, based on the bounds on value/envy that an agent can guarantee for themselves in the two protocols. We show that making various tweaks to the definition of BC protocols (such as considering protocols that can be represented as directed acyclic graphs rather than trees, or allowing agents to make a cut within a sequence of pieces rather than a single piece), results in the same class of protocols, up to what we call strong envy-equivalence. (Informally, an agent can guarantee the same bounds on their envy against the other agents in both protocols.)

We then prove that any BC protocol can be put into a special form in which all the cut nodes come before the choose nodes, making it easier to reason about the structure of the protocol. Finally, we show that in fact BC protocols have the same expressive power as GCC protocols, and we look into how some classic cake-cutting protocols can be represented as BC protocols.

1.1 Related Work

The Robertson-Webb query model, first introduced by Robertson and Webb [11] and formalised by Woeginger and Sgall [14], which is the standard model for discrete cake-cutting protocols in the literature, involves a referee who can ask the agents two types of queries related to their valuation functions (see Introduction), and divides the cake accordingly. A natural question is whether there is an incentive for the agents to report their valuation functions truthfully, i.e. whether there exist any strategy-proof protocols in the Robertson-Webb model. Here, strategy-proofness means truthful reporting is a dominant strategy for every agent, regardless of their valuation function.

Brânzei and Miltersen [5] show this is impossible for any “interesting” protocols in the Robertson-Webb model: any strategy-proof protocol for two agents is dictatorial (there is a fixed agent who always gets the entire cake), and, more generally, in any strategy-proof protocol for agents, at least one agent gets an empty piece. There are some other papers that deal with strategy-proofness and the closely related concept of truthfulness.

Notably, Chen et al. [7] design a cake-cutting protocol that is truthful, proportional, and envy-free for piecewise-uniform valuation functions, but which uses a direct-revelation mechanism (i.e. the agents reveal their entire valuation function to the referee), rather than the standard query model. A recent paper by Tao [13] proves that no such protocol can exist for the more general case of strictly positive piecewise-constant valuations, and designs a mechanism that satisfies a weaker notion of truthfulness.

Brânzei et al. [3, 4] introduce the GCC protocols model described above, and use it as a framework to design a protocol for which a contiguous allocation is envy-free if and only if it is the outcome of a Nash equilibrium.

The BC protocols model introduced in this paper is different from the GCC model in that instead of having agents choose which pieces of the cake they receive, they choose which branch of the protocol to proceed to. In addition, the agents’ actions are more restrictive, so that the ordering of the cuts is encoded in the tree structure, which eliminates the need for if-else statements.

Furthermore, our work does not focus on game-theoretic aspects like strategy-proofness, though this would be an interesting topic to address in the future, but rather on results related to the expressive power of the model, which is a topic that Brânzei et al. [3, 4] only touch on briefly, and considerations such as the space complexity of implementing common protocols in this format.

For a readable introduction to the better-known cake-cutting protocols, including algorithmic and strategic issues, see Procaccia [10].

2 Background

2.1 Setting

The cake, which is represented as the interval , must be divided between agents. Each agent must be allocated a piece of cake (i.e. a finite union of disjoint intervals). The pieces of cake allocated to different agents must be disjoint. We allow for an individual agent to be given no cake (or an empty piece ), but every piece of cake must be allocated to some agent.

The agents’ preferences are given by private valuation functions that assign a value to every subinterval . We extend the additively to pieces of cake, writing for the value of a piece of cake X. The valuation functions are assumed to have the following properties:

  • Normalization:

  • Additivity: For any two disjoint intervals and ,

  • Divisibility: For every interval and there exists such that . In particular, this implies the valuation functions are non-atomic: for every .

  • Non-negativity: for any .

For an allocation , where is the piece of cake assigned to agent , we define the envy of agent towards agent as:

2.2 Generalised Cut and Choose (GCC) Protocols

A generalised cut and choose (GCC) protocol [3, 4], is represented as a tree in which each node corresponds to the action of an agent. There are three types of nodes:

  • cut nodes: an agent makes a cut between two existing cuts. More specifically, agent is given a set of intervals representing contiguous piece of cake, such that the endpoints of every piece are either 0,1, or cuts made at a previous step. The agent picks an interval and makes a cut at some point in it.

  • choose nodes: an agent chooses between a set of pieces induced by the existing cuts. Agent is given a set as above. They choose an interval from , and this interval then gets allocated to them. In the special case , the agent is essentially assigned a piece and there is no actual “choice”.

  • if-else nodes: These nodes can have multiple branches. The protocol progresses to one of the branches based on an if-else statement. The conditions in the if-else statement depend on the order of the cut points made in the previous steps, and the execution history of the protocol (Equivalently, the conditions depend on which pieces the agents cut or chose at each of the previous steps).

Note that cut and choose nodes have at most one child each, so the protocol only branches out at if-else nodes.

In the original paper by Brânzei et al. [3], the if-else statements are not explicitly included in the tree structure. Instead, the cut/choose nodes have multiple children and progression to one of the children is based on an if-else statement. We view if-else statements as separate nodes for simplicity. It is easy to see that our interpretation and the original one have the same expressive power.

Algorithm 1 shows how the Selfridge-Conway protocol [11], a classic envy-free protocol for three agents, can be represented as a GCC protocol. Algorithm 2 shows the original protocol, for comparison.

1 CUT: Agent cuts in at point . CUT: Agent cuts in at point . CUT: Agent cuts a piece from Label this piece , dividing it into pieces and . Let the other two pieces be and . CHOOSE: Agent chooses a piece from . if Agent chose  then
2       CHOOSE: Agent chooses a piece from . CHOOSE: Agent chooses the last remaining piece in . CUT: Agent 2 cuts at of the value, resulting in two pieces , . CUT: Agent 2 cuts at , resulting in two pieces , . CHOOSE: Agent 3 chooses a piece out of , WLOG . CHOOSE: Agent chooses a piece out of . CHOOSE: Agent chooses the remaining piece.
3else
      // Agent did not choose
4       CHOOSE: Agent gets piece . CHOOSE: Agent chooses the last remaining piece in S. CUT: Agent 3 cuts at of the value, resulting in two pieces , . CUT: Agent 3 cuts at , resulting in two pieces , . CHOOSE: Agent 2 chooses a piece out of , WLOG . CHOOSE: Agent chooses a piece out of . CHOOSE: Agent 3 chooses the remaining piece.
Algorithm 1 The Selfridge-Conway protocol, represented as a GCC protocol. Strictly speaking, wherever the algorithm labels a piece or assumes w.l.o.g. that a certain piece was chosen, we should have an if-else node with multiple branches depending on which piece that is, but we have mostly omitted those for simplicity.
1 Agent divides the cake into three pieces of value Let be the largest piece according to agent . Let the other two pieces be and . Agent trims so that it is the same size as the second largest piece. Label the trimmed piece , and the trimmings . Agent chooses a piece from . if Agent chose  then
2       Agent chooses one of and .
3else
      // Agent did not choose
4       Agent gets piece .
Agent gets the last piece. It remains to divide the trimmings . One of agents and got . Call that agent , and the other agent . Agent cuts into three equal pieces. Agent chooses one of the three pieces. Agent chooses one of the remaining two pieces. Agent gets the last remaining piece.
Algorithm 2 The Selfridge-Conway protocol.

2.3 Equivalence of Cake-Cutting Protocols

Since we are working with multiple models for representing cake-cutting protocols, we need to define what it means for two protocols (possibly represented in different models) to be “the same”. We will present multiple possible notions of equivalence between cake-cutting protocols, which are all based on various bounds agents can guarantee for themselves in terms of value/envy, regardless of the other agents’ strategies, so they are independent of the model used to represent a protocol.

Let and be two cake-cutting protocols.

  1. Value equivalence: and are equivalent if the minimum value that each agent can guarantee for themselves is the same. That is, if in the worst case for protocol agent gets a piece of value , then in the worst case for protocol the piece agent gets must have the same value .

  2. Total envy equivalence: and are equivalent if the maximum total amount of envy an agent can guarantee for themselves is the same in both protocols.

  3. Pair-wise envy equivalence: and are equivalent if, for any two agents and , if in one of the protocols agent can guarantee , for some , then they can guarantee the same bound holds in the other protocol.

  4. Strong envy equivalence: and are equivalent if, for any agent and any set of agents not containing , if in one of the protocols agent can guarantee simultaneous bounds , for some , then they can guarantee the same bounds hold in the other protocol. This is the notion of equivalence we will be using the most throughout the paper. Note this is still quite broad, since, in particular, any two envy-free protocols will be strongly envy-equivalent. A lot of our results involve protocols that appear “similar” in a stronger sense (for example, some of our conversion algorithms involve mimicking the actions in a given protocol in a different model), but this is difficult to formalise and since, in practice, most protocols aim to guarantee certain bounds on envy, our definition is good enough.

    Note also that strong envy equivalence implies pair-wise envy equivalence (taking ).

3 An Alternate Model for Cake-Cutting Protocols

In Section 3.1 we define the class of Branch Choice (BC) protocols. In Sections 3.2 and 3.3 we consider variations of the definition, and we prove that they are equivalent to the original one. In Section 3.4 we show that no expressive power is lost in moving to a restricted version in which the “cut” nodes must precede the “choose” nodes. In Section 3.5 we show that BC protocols have the same expressive power as GC protocols. In Section 3.6 we show that certain proportional protocols can be expressed as BC (equivalently GCC) protocols.

3.1 Branch Choice (BC) Protocols

Consider the following alternative representation of cake-cutting protocols. As before, we represent the protocols as trees, but this time we divide the nodes into:

  • non-leaf nodes, which are further divided into:

    • cut nodes: We have a partition of the cake into contiguous pieces, ordered from left to right. Agent subdivides a piece by making one cut. Trivial cuts (i.e. cutting at one of the ends of the piece) are allowed. For convenience, we consider that for a piece , cutting at one of the ends, WLOG , divides it into and a new piece . Such “empty” pieces will have value to any agent, but they allow us to keep track of the number of pieces throughout the tree. Note and are both fixed, unlike in the previous section.

    • choose nodes: Given a partition of the cake as above, agent is allowed to choose which child of the current node to proceed to, based on the position of the cuts.

  • leaf nodes: Given a partition of the cake, each piece in the partition is allocated to an agent. The allocation is represented as a mapping where is the number of agents, and is the number of pieces in the partition. Note that for a given leaf, the number of pieces the cake has been divided into by the time we reach that leaf is one plus the number of cut nodes above the leaf, which does not depend on the execution history, so the mapping is well-defined.

We say a cut/choose node corresponding to an action of agent is controlled by agent .

We will refer to the class of protocols that can be represented in the above form as branch choice (BC) protocols to reflect the fact that at choose nodes, an agent chooses which branch of the tree is executed.

Note we need to keep track of the execution history at every node (i.e. how the cake is partitioned before the action corresponding to the current node). We can either store this information at every node (requiring extra space), or recover it from the unique path between the current node and the root (no extra space). Both take linear time in the number of nodes to read, so we will use the latter option and store no extra information at the nodes.

CUT: agent cuts into at point

CUT: agent cuts into at

*CHOOSE: agent chooses a branch

CUT: ag. cuts into at

CUT:ag. cuts into at

CUT:ag. cuts into at

**CHOOSE: ag. chooses a branch

CUT: ag. cuts into at

CUT: ag. cuts into at

***CHOOSE: ag. chooses a branch

****CHOOSE: ag. chooses a branch

*****CHOOSE: ag. chooses a branch

ALLOCATION:

ALLOCATION:

Figure 1: (Partial) tree representation of a BC protocol that is strongly envy-equivalent to the Selfridge-Conway protocol (i.e. it is envy-free). The omitted subtrees, represented by “…”, are essentially copies of the one shown, for some permutation of the pieces/agents. The complete tree would have nodes in total. See detailed explanation below.

In figure 1:

* - agent trims the largest piece according to them (as per the original protocol). In our representation of the protocol, they have to choose the largest piece to minimise their envy.

** - agent chooses which of the three “big” pieces and they get.

*** - agent chooses which of the remaining two “big” pieces they get. In the two branches we have left out, where agent hasn’t chosen , agent is assigned by default and does not get a choice here.

****, ***** - agents and choose which of the “trimmings” they are assigned.

It can be shown that all other conditions in the original protocol (e.g. agent cutting the piece into thirds at the beginning, agent trimming the largest piece to be the same size as the second largest, etc.) can be recovered by analysing where the agents need to cut to minimise their envy.

3.2 BC Protocols Represented as Directed Acyclic Graphs

As a generalisation, we can instead consider the class of cake-cutting protocols that can be represented as directed acyclic graphs (DAGs) using the same types of nodes as BC protocols.

A DAG representing a cake-cutting protocol will have a designated root node that corresponds to the first action in the protocol. We will also assume that every node is reachable from the root, as nodes that are not reachable will not be relevant to the protocol. To ensure the DAG represents a valid protocol, we must also require that if there are multiple paths from the root to a node, all of them result in the same number of cuts, so that the number of pre-existing cuts at a given node is well-defined and we can describe actions like “agent cuts into the -th piece”. This can provide a more compact representation for certain protocols, but we will see that it is no more “powerful” than the tree representation, that is, given a DAG representing some protocol, we can represent the same protocol as a tree.

Theorem 1.

The protocols that can be represented as DAGs are exactly the BC protocols as defined above.

Proof.

Clearly any BC protocol can be represented as a DAG by converting every edge in the tree representation to a directed parent child edge.

Conversely, let be a DAG representing a cake-cutting protocol. We will produce a tree representation of the same protocol. The root and nodes with a single parent can be translated directly into the tree. For nodes with multiple parents, the key idea is to make one copy of the node and its descendants for each parent. Every path from the root to the node in the initial graph corresponds to a path from the root to one of the copies of the node in the resulting graph. Therefore the new graph represents the same protocol. By repeating this step until there are no more nodes with multiple parents, we will obtain a tree representation of the protocol.

This algorithm will always terminate, but to eliminate repeated work we want to ensure that a node’s descendants are converted to tree nodes before the node itself (otherwise we might have to run the process multiple times for copies of the same descendant). We can do this by finding a topological ordering of the tree, and then converting the nodes in reverse topological order.

Therefore, any protocol represented as a DAG can also be represented as a tree, so the protocols that can be represented as DAGs are precisely the BC protocols. ∎

3.3 Extended BC Protocols

We will now consider a modified definition of BC protocols, which allows an agent to choose which piece of cake to cut from a sequence of consecutive pieces, and allows for allocating a sequence of pieces to some agent at once by only specifying the endpoints of the sequence.

The advantage of this more flexible definition is that we can ignore some extraneous cuts in the execution of the protocol, as we will see, for example, in the proof of theorem 4. We will show that, in fact, this extended definition has the same expressive power as the original one.

  • Instead of having some agent cut into a single piece with no other cuts inside it, we allow for cut nodes that ask agent to make a cut between two existing cuts and (which might not be consecutive).

  • At leaves, instead of allocating each interval, we allow for allocating the piece of cake between two (potentially non-consecutive) cuts and to some agent, with the constraint that (so if the ordering of and cannot be determined solely from the structure of the protocol, and depends on the decisions of the agents, this is not a valid allocation). Note this is essentially the same as BC protocol allocation, except the allocation can be written more concisely, ignoring intermediate cuts if consecutive intervals are allocated to the same agent.

    Example.

    If agent makes a cut at and agent then makes a cut at , we cannot have an allocation , , , because it might be the case that . But if instead we restrict the second cut to , the allocation is valid. In both cases, , is also a valid allocation.

We will refer to protocols covered by this definition as extended BC protocols. Note that indeed any protocol covered by the original definition of BC protocols is covered by the modified definition, with no changes needed.

Theorem 2.

For any extended BC protocol, we can construct a strongly envy-equivalent BC protocol. This results in a blowup in the size of the tree representation of the protocol.

Proof.

Construction: We convert the cut nodes in topological order, so when we reach a node, we know that all of its descendants are already “valid” nodes in the original definition. For a cut node “agent cuts between and ”, suppose there are other cuts between and . Note is fixed, because we have already converted all of the current node’s descendants, so we know the ordering of the pre-existing cuts at this stage. We replace our cut node with a choose node with cut node children, corresponding to cutting in , respectively. Each child will have a copy of the initial cut node’s subtree.

We also need to modify the leaf nodes. After modifying the cut nodes, the ordering of the cuts at each leaf node is now fixed, so we can replace an allocation with one that allocates each continuous piece between and to agent .

Complexity analysis: This conversion process terminates, but it results in an blowup in the size of the tree (where n is the initial number of nodes). Consequently, the running time is also .

To see this, consider the worst case, in which we have a chain of cut nodes that are all of the form “agent cuts in at ”, with ).

For the first cut node we don’t have to do anything. For the second cut node, we replace it with a choose node with branches corresponding to cuts in and , respectively.

In each of these two branches, there will be a copy of the third cut node, which needs to be replaced with a choose node with branches, etc.

See figures 2 and 3 for an example.

CUT: agent cuts at

CUT: agent cuts at

CUT: agent cuts at

Figure 2: Worst-case for n=3, before conversion.

CUT: agent cuts into at

CHOOSE: agent chooses a branch

CUT: agent cuts into at

CUT: agent cuts into at

CHOOSE: agent chooses a branch

CHOOSE: agent chooses a branch

CUT:agent cuts into at

CUT:agent cuts into at

CUT:agent cuts into at

CUT:agent cuts into at

CUT:agent cuts into at

CUT:agent cuts into at

Figure 3: Worst-case for n=3, after conversion.

Corollary 3.

BC protocols and extended BC protocols represent the same class of protocols, up to strong envy-equivalence.

3.4 Converting BC Protocols to “Cuts Before Choices” Form

In this section, we will prove that any BC protocol can be converted to a “nice” form in which all the cut nodes come before all the choose nodes, so, intuitively, the agents first cut up the cake, and then they make choices between branches leading to various allocations.

Theorem 4.

Any extended BC protocol can be converted into a strongly envy-equivalent extended BC protocol in which no choose node in the tree representation of the protocol has a cut node descendant. The conversion algorithm runs in polynomial time, and the size (number of nodes) of the original tree is equal to the size of the resulting tree.

Proof.

Let be a cake-cutting protocol. If the protocol already satisfies the required condition, we are done. Otherwise, suppose the extended BC tree representation of contains a choose node with a cut node descendant. In particular, there must be a choose node with a cut node child “agent cuts between and at point ”.

We will describe an algorithm to move the cut node above the choose node (as in figures 4 and 5) without affecting the resulting allocation (each agent will be assigned the same piece of cake as in the initial protocol, except potentially cut up differently). The advantage of this form is that it makes it easier to reason about the protocol.

CHOOSE:agent chooses a branch

CUT:agent cuts between and at point

Figure 4: Choose node with cut node child.

CHOOSE: agent chooses a branch

CUT: agent cuts between and at point

Figure 5: Subtree obtained by moving the cut node above the choose node in 4.

Note the cut node only has one child, call it , which can be any kind of node. Moving the cut node above the choose node will not affect the subprotocol defined by ’s branch. In the other branches, we just ignore the cut at (which extended BC protocols allow) and execute the protocol exactly as before.

We repeat this process until there is no choose node with a cut node child. This protocol will contain no choose node with a cut node descendant. Since the conversion algorithm does not affect the allocation, any simultaneous bounds on an agent’s envy towards other agents in the initial protocol will carry over to the resulting protocol, so the two are strongly envy-equivalent.

Furthermore, the running time of the conversion algorithm is polynomial (we move each cut node up the tree at most times, where is the total number of nodes, and there are at most cut nodes).

Since no nodes are added and deleted, the size of the resulting tree is equal to the size of the original tree. ∎

Lemma 5.

Any BC protocol can be converted into a strongly envy-equivalent BC protocol in which every choose node either has:

  • no cut node descendants, or

  • only cut node children, in which case if the choose node is controlled by agent , the cut node children are guaranteed to be controlled by agent and correspond to cuts in a sequence of consecutive pieces.

The conversion results in a blowup in the size of the tree representation.

Proof.

Let be a BC protocol. In particular, can be viewed as an extended BC protocol, so by theorem 4 we can convert it to a strongly envy-equivalent “cuts before choices” extended BC protocol in which no choose node in the tree representation of the protocol has a cut node descendant, resulting in a tree similar to the one in the figure below.

CUT: agent cuts at

CUT: agent cuts at

CUT: agent cuts at

CHOOSE: agent chooses a branch

We can then convert back to a BC protocol using the algorithm in theorem 2.

In the last conversion, a cut node “agent cuts between and ” in will either be unchanged, if there are no other cuts between and , or it will be split into a choose node “agent chooses a branch” with cut node children “agent cuts between and ” corresponding to each of the intermediate pieces (where are all the existing cuts between and , from left to right).

The choose nodes in will not be changed/moved, so they will still have no cut node descendants after the conversion.

Therefore the resulting protocol has the required form, and is strongly envy-equivalent to the original protocol . The blowup in size comes from the last conversion. ∎

Theorem 6.

Any BC protocol can be converted into a strongly envy-equivalent BC protocol in which no choose node in the tree representation of the protocol has a cut node descendant.

Proof.

Let be a BC protocol.

We start by converting to the form in lemma 5. The resulting tree will look like in figure 6: a chain of cut nodes, followed by a choose node with branches, then a level with cut nodes, one in each branch, then choose nodes each with branches, etc., until the last level of cut nodes (whose choose node parents will each have branches, where is the number of levels of cut nodes). Below that level, the tree only contains choose nodes and allocation nodes.

CUT at

CUT at

CUT at

cut nodes

CHOOSE: agent i chooses a branch ( branches)

. . .

CUT: agent cuts at

CUT: agent cuts at

CHOOSE: agent chooses ( branches)

CHOOSE: agent chooses ( branches)

CUT:agent cuts at

CUT:agent cuts at

CUT:agent cuts at

. . .

CUT:agent cuts at

. . .

CUT:agent cuts at

CUT:agent cuts at

Figure 6: Protocol in the form in lemma 5.

We can assume that we are in the case where we always have the maximum number of branches at each choose node, i.e. all the “” signs above are equalities. In particular, that means that at a choose node with cut node children, we will have one cut node corresponding to each contiguous piece of cake, so if there are cuts when we reach the choose node, it will have cut node children corresponding to cuts into up to .

We can make this assumption because if we want to restrict the cut to the interval , we can just remove the branches corresponding to making a cut outside of that interval at the end of the protocol.

We now aim to convert this protocol to one where no choose node has a cut node descendant, by moving cut node children above their choose node parent one by one, as in figures 4 and 5.

The difficulty here is that unlike with extended BC protocols in theorem 4, when we move a cut node above its choose node parent, we need to modify the other branches of the choose node to account for the extra cut, so that the resulting protocol is still a BC protocol.

Suppose there are levels of cut nodes below the topmost choose node.

If , there are no cut nodes below the topmost choose node, so we are done.

For , we start with the topmost level of cut nodes, which will be the children of the topmost choose node. There are cut nodes “agent cuts at into ”, , where .

We start by moving the leftmost cut node, “agent cuts at ”, above its parent. We do not need to modify the branch that cut node was in, but for the other branches, we need to do the following in each branch:

  • the topmost cut node is unchanged;

  • on the second level of cut nodes, we need to split the cut node “agent cuts at ” into two cut nodes corresponding to cuts in and .

  • on the following level, we need to split exactly one cut node in each of the branches to account for the extra cut at , etc.

In total, this will add cut nodes on the first level, on the second level, on the second level,…, on the -th (last) level. In particular, the process terminates.

We repeat this process for the other cut nodes on the first level. At the end, the tree will look like in figure 7, and there will be levels of cut nodes below the top choose node.

CUT

CUT

CUT

cut nodes

CHOOSE: agent i chooses a branch ( branches)

. . .

CHOOSE: agent chooses ( branches)

CHOOSE: agent chooses ( branches)

CUT:agent cuts …

CUT:agent cuts …

CUT:agent cuts …

. . .

CUT:agent cuts …

. . .

CUT:agent cuts …

CUT:agent cuts …

Figure 7: Protocol after moving first level of cut nodes above choose node.

Now, each of the choose nodes below the top choose node have cut node children. Starting from the leftmost of these choose nodes and its left most cut node child, we move the child above the parent, and then move it above the top choose node. We repeat this process until we have moved all cut nodes on this level above the top choose node.

Now there are levels of cut nodes below the top choose node. Recursively, we can move the cut nodes on each level above the top choose node. Since the number of levels decreases at each step, and the process for a single level terminates, the whole conversion process terminates.

At the end, we also need to “fix” the allocation nodes to account for the extra cuts, by changing an allocation to , where are all the cuts between and . This takes time where is the number of allocation nodes and the number of cut nodes in the final tree.

The resulting protocol will have no cut nodes before the top choose node, so clearly it will contain no choose node with a cut node descendant.

Note that pulling a cut node above its choose node parent and splitting cut nodes in the other branches as above does not affect the allocation, hence the protocols before and after each step are strongly envy-equivalent. Therefore the original protocol and the final protocol are strongly envy-equivalent. ∎

3.5 Equivalence to GCC Protocols

In this section, we will prove that GCC and BC protocols can express the same class of protocols, up to strong envy-equivalence.

Theorem 7.

For any GCC protocol, there is a strongly envy-equivalent BC protocol.

Proof.

We will refer to a tree representation of a GCC protocol as a GCC-tree (with GCC-cut, GCC-choose, and GCC-if-else nodes), and to a tree representation of a BC protocol as BC-tree (with BC-cut and BC-choose nodes, and BC-leaves/allocation nodes).

Consider a protocol that can be represented as a GCC-tree T. We will construct a BC-tree representation of it by replacing each node in T and its subtree with an equivalent BC-subtree, in topological order. Before we start this process, we connect a BC allocation node to each leaf of T (with the actual allocation to be filled in later).

  • If is a GCC-cut node: At node , agent chooses a piece from a set and cuts into it. Since contains disjoint pieces, we can always extend it to a partition of the cake . We replace node with a BC-choose node, with children, so there is one child for each piece . The child corresponding to a piece will be a BC-cut node representing the action “agent cuts into piece ”. The subtree of each child in the BC-tree will be a copy of ’s subtree. In the BC-choose node, the agent can choose which child to proceed to, so they effectively get a choice of which piece from to cut into.

  • If is a GCC-choose node: At node , agent chooses a piece from a set and that piece gets assigned to them. Once again, we replace node with a BC-choose node with children, one for each piece , and make the subtree of each child a copy of ’s subtree. The agent will choose to progress to the child corresponding to the piece they would have chosen in the GCC protocol. We now need to ensure that piece actually gets assigned to agent in the BC protocol. We add “agent gets piece ” to each BC-leaf in the subtree corresponding to piece . At the end of the conversion process, each BC-leaf will contain a valid allocation of the entire cake.

  • If is a GCC-if-else node: By definition, the conditions in the if-else statement at depend on which pieces the agents cut/chose at each of the previous steps of the protocol. But since we have already converted all of ’s ancestors to BC nodes, the decisions the agents made at each step before the current node are already determined, so we know what the result of the if-else statement will be and which branch the protocol will progress to. Hence, we remove all the other branches, then delete the if-else node and connect the single remaining branch to ’s parent.

Note that after we have converted every node in the GCC-tree, the tree will only branch out at BC-choose nodes, and progression to a child will only depend on the choice the agent makes at that node.

The protocol represented by the resulting BC-tree essentially simulates every action in the initial protocol using BC-tree nodes. In particular, every agent will get the same piece of cake they would have gotten in the initial protocol. Therefore, any simultaneous bounds on their envy levels towards other agents in the initial GCC protocol carry over to the BC protocol. Hence the two protocols are strongly envy-equivalent. ∎

Remark 1.

The definition of choose/cut nodes in GCC protocols is ambiguous as to whether the set of pieces of cake an agent is given is restricted to continuous pieces (i.e. pieces such that there is no other cut between and ), or we also allow for pieces that contain previous cuts.

Note that the above proof assumes the former, but the result also holds for the more extensive definition, since, by a similar argument to the one in the proof of theorem 2, if a piece contains cuts we can split it into pieces and add an if-else node below to establish which of these pieces the agent acted on. This way, we can convert a protocol in the more extensive definition to the restricted one, and then convert it to a BC protocol via theorem 7.

Theorem 8.

For any BC protocol, there is a strongly envy-equivalent GCC protocol.

Proof.

We start by putting the BC protocol in the “cuts before choices” form given by theorem 6.

The BC-cut nodes can then be trivially converted to GCC-cut nodes. The BC-leaves can be converted to a chain of GCC-choose nodes (so if agent is allocated some interval in the original node we make them “choose” the piece instead. If agent gets multiple intervals, we will have one GCC-choose node for each).

It remains to simulate the BC-choose nodes (in which an agent chooses which branch of the tree to proceed to) using GCC nodes. We will do this by creating a piece that has value for every agent, and then dividing that piece between all agents. Each agent will then further divide their piece and “choose” between various sub-pieces of it to artificially simulate branch choices.

The actual protocol will be run on the remaining cake, which will be an interval such that for every . We can do this by replacing the endpoint with in every node of the protocol. Clearly any envy bounds in the original protocol will hold in the new protocol, since the piece that we cut off has no value for any of the agents.

Explicitly, we add the following chain of cuts at the beginning of the protocol:

  • agent cuts into at point

  • agent cuts into at point

  • agent cuts into at point

The optimal strategy for agent is to cut at some such that , so the piece will have value for all agents, as required. This is because the agents cannot control how much of the piece they get, so they want it to have as little value for them as possible.

  • agent cuts into at point

  • agent cuts into at point

  • agent cuts into at point

Now, agent will use the piece (where ) to simulate their BC-choose nodes as follows:

If there are BC-choose nodes controlled by agent in the tree, they cut their piece times, dividing it into pieces. Each piece will correspond to a choose node.

If the BC-choose node corresponding to the -th piece has branches, we replace it with the following process:

  • Agent divides the -th piece into sub-pieces, one for each branch.

  • In a GCC-choose node, agent chooses one of the sub-pieces.

  • In a GCC-if-else node, we proceed to one of the branches, depending on which piece the agent chose.

  • The agent gets the other pieces one by one (using a GCC choose node for each one).

Note that not all of agent ’s BC-choose nodes might be reached in a specific run of the protocol, since they might be in different branches. This means that in some branches, the pieces corresponding to those choose nodes will not have been allocated to anyone. To resolve this issue, agent gets the remaining sub-pieces of at the end.

This way, agent always gets the entire interval , so the interval is all allocated to various agents.

Note there are some extra cuts in the cake at that we have ignored in the protocol. This is fine in the more extensive interpretation of GCC protocols, and it can be converted to the more restrictive interpretation by the Remark above.

The resulting protocol will be strongly envy-equivalent to the initial protocol, since, as explained above, none of the steps in the conversion process affect the envy bounds. ∎

Corollary 9.

If we allow for the more extensive interpretation of GCC protocols (as in remark 1), any extended BC protocol can be converted to a strongly-envy equivalent GCC protocol in polynomial time.

Proof.

Consider the conversion algorithm given in the proof of theorem 8. Apart from converting the BC protocol to an equivalent BC protocol in “cuts before choices” form at the start, and converting the resulting GCC protocol to fit the more restrictive interpretation of the definition at the end, the rest of the algorithm runs in polynomial time, since we only add a polynomial number of nodes to the tree.

Therefore, if we use the more extensive interpretation of GCC protocols instead, we can use theorem 4 to convert the original protocol to an extended BC protocol in “cuts before choices” form in polynomial time, then run the conversion algorithm as before. ∎

Note this argument does not work for the reverse conversion (GCC to BC) given by theorem 7, because there we specifically make use of the more restrictive classes of protocols when converting, for example, GCC if-else nodes.

3.6 Proportional Cake-Cutting Protocols

A cake-cutting protocol for agents is said to be proportional if each agent is guaranteed to receive a piece of cake with value at least according to their own valuation function. There are a number of well-known proportional cake-cutting protocols, such as the Dubins-Spanier protocol [8] and the Even-Paz protocol [9].

In this section, we look at how these can be represented as GCC and BC protocols.

The discrete Dubins-Spanier protocol works as follows: each agent makes a cut at a point such that . The agent who made the leftmost cut gets the piece . That agent is then removed and we repeat the protocol on the remaining cake with the other agents. The last agent gets the remaining piece of cake.

Brânzei [6] describes how the Dubins-Spanier protocol can be implemented as a GCC protocol. Each agent is asked to make a cut in at some point . The leftmost cut is then determined using an If-Else node with branches, then, in the -th branch, agent “chooses” a piece from the singleton set , and we repeat the procedure for the other agents on the remaining cake, ignoring the cuts made at previous steps. This protocol clearly respects the proportionality condition, so, in our language, it is value-equivalent to the original protocol. Any bounds on envy from the original protocol would also clearly carry over, so they are strongly envy-equivalent. Note that the size of the resulting GCC tree is , because there are branches on the first if-else node, then branches for each of those, etc. The runtime of the protocol is if we just count the queries/nodes, as in the original protocol, and if we also consider the comparisons inside each if-else node, since to find the leftmost cut we need to compare the position of each cut to the other .

We can implement this as a BC protocol either by converting the GCC implementation using theorem 7, or as an extended BC protocol as follows: agent makes a cut in at , agent chooses between two branches (one for cutting in and the other one for ), the next agent chooses between two branches corresponding to cutting left or right of the current leftmost node. After this, we know who made the leftmost cut in a specific branch. At the end of the protocol agent will get allocated the piece . We repeat the algorithm for the other agents on the remaining cake, ignoring the cuts made at previous steps. There are branches in the first step, then for each of those there are branches in the second step, etc. So the size of the tree is , so the size of the protocol is .


The Even-Paz protocol for agents, is as follows:

  • Each agent makes a cut at such that .

  • The algorithm finds the -th cut, which divides the cake into two “halves”.

  • Each half is divided recursively amongst the agents whose cuts were inside that half (with the agent who made the -th cut going into the first half).

The runtime is .

We can implement the Even-Paz protocol as a GCC protocol as follows: each agent makes a cut at , then in an if-else node with branches, we identify the -th cut. We repeat the procedure for each half for the agents who cut into that half. There are branches in the first step, then in each of those we have branches for dividing the first half, each of which then splits into branches for dividing the second half, etc. Assuming for simplicity, the size of the tree is , so , and the resulting protocol is value-equivalent (so, in particular, proportional) and strongly envy-equivalent to the original one.

For the extended BC protocol implementation, agent makes a cut at in , agent chooses between two branches (for cutting in or respectively), agent chooses between three branches (corresponding to cutting into each of the three existing pieces), etc. After this, we know the ordering of the cuts in a specific branch, so, in particular, the -th cut. We recurse on the two halves of the cake. Assuming , we get branches in the first step, branches in the second step, etc, so the size of the tree is

4 Conclusions and Future Work

4.1 Conclusion

In this paper, we defined a new model for representing cake-cutting protocols as trees, called branch choice (BC) protocols, which differs from other models in that instead of choosing specific pieces of cake, the agents get to choose which branch of the tree to proceed to at a certain point, and then the cake is allocated at the end. We showed that various modifications to the model do not impact its expressive power. We also proved that any BC protocol can be converted to an equivalent protocol in which the cut nodes come before the choose nodes, so that, informally, the agents can first cut up the cake, and then choose between various branches that lead to different allocations.

The main benefit of BC protocols is that they form a rather bare-bones model, so that, for example, if the protocol reaches a given node, we can deduce the execution history of the protocol (the relative order of the cuts, as well as which branches the agents chose) just based on the path from the root to that node, with no ambiguity about what decisions the agents might have made at previous nodes. This makes it easier to reason about the protocols, particularly after putting them into the special “cuts before choices” form mentioned above, since in that case we also know a lot about the structure of the tree.

This comes at no cost to the expressive power of the model, since the class of protocols it covers is the same as generalised cut and choose protocols as described by Brânzei et al. [3], up to strong envy equivalence (which we defined to mean that in both protocols, an agent can guarantee the same simultaneous bounds on their envy against any subset of the other agents).

However, as we have seen both in some of our conversion algorithms and in the case of representing some classic protocols as BC protocols, the simplicity of the model comes with a trade-off in space complexity, and in some cases the conversion seems to result in or even worse blowups in the size of the tree representation compared to the original protocol.

4.2 Future Work

Checking equivalence

Most of our results involve constructing protocols that are equivalent to a given protocol. It would be interesting to look into the computational complexity of checking whether two given BC protocols are equivalent under one of the notions of equivalence we have defined, or the highly related question of computing the value/envy bounds an agent can guarantee for themselves in a given protocol. Note that the former question very easily reduces to the latter.

Simplifying protocols

As we have seen above, explicitly representing a cake-cutting protocol as a tree, whether in the GCC or the BC protocols model, often results in a blowup in the size of the protocol, compared to its original statement. A natural question to ask is whether we can simplify a given protocol, i.e. find a strongly envy-equivalent protocol with a smaller tree representation. A brute-force approach to this would involve finding all protocols whose tree representation is smaller than the given one, and then checking, for each of these protocols, whether it is equivalent to the original protocol (which reduces to the question discussed previously).

Adding extra structure to the model

Another possible direction is to consider whether we can decrease the size of the tree representation by adding some extra structure to the model, as we already did informally in Algorithm 1 for the Selfridge-Conway protocol, where on line 1, for example, we label the piece agent cut and the other two pieces and , instead of explicitly showing the three (virtually identical) branches corresponding to each piece.

We propose two possible types of nodes to add:

  • Piece permutation: agent permutes the order of the existing pieces of cake. If there are currently cuts in the cake, then there are continuous pieces which we can number from left to right, and agent can apply some permutation to reorder them. Note this is functionally equivalent to the labelling used in the Selfridge-Conway protocol, which we mentioned above, since agent could, for example, reorder the pieces in increasing order of their value, and then cut the third piece. This would reduce the size of the BC tree representation of the Selfridge-Conway protocol in figure 1, since we would only need a single branch at the topmost choose node instead of three. This leads us to believe there is a class of protocols for which adding this type of node can be proven to reduce the size of the protocol, possibly exponentially in the case where this kind of node is used multiple times.

    Adding piece permutation nodes to the BC protocols model is straightforward, as long as we refer to the pieces by their position in the cake (e.g. “agent cuts the second piece from the left”), rather than by their endpoints, which in the case of BC protocols does not make any difference.

    We can also add them to GCC protocols, provided we change the model to refer to pieces by their position in the cake, but in this case we have to decide whether we should account for pieces that agents have already taken from the cake, e.g. if the cake is divided into three pieces and some agent chooses piece , should the remaining pieces now be and or can we relabel them and ?

  • Agent permutation: There are two types of action we can consider here: either some agent permutes the order of the other agents, which would allow them to choose, for example, which of the other agents they are envious of in some situation, or we have a referee who can reorder the agents according to some rule. The former option can be added to both GCC and BC protocols, while the latter can more naturally be added to GCC protocols, as an extension to the existing if-else node, and could be used, for example, in the case of the Dubins-Spanier protocol, where we use an if-else node to identify the agent who made the leftmost cut, in which case we can reorder the agents so that agent is now the -th one, and recurse on the first agents.

Converting other protocols to the BC model

We have already shown that some classic protocols (Selfridge-Conway, Dubins-Spanier, Even-Paz) can be converted to BC protocols, but it would be interesting to extend this result to other protocols in the literature. Of particular interest would be the discrete bounded envy-free protocol for agents proposed by Aziz and Mackenzie [1]. We suspect that it is possible to convert this protocol to a BC protocol, since a lot of the additional structure used in the protocol could be encoded into the BC tree representation, or implicitly in the agents’ strategies to achieve envy-freeness, but we have not checked this.

Acknowledgements

We thank Simina Brânzei for helpful comments.

References

  • [1] H. Aziz and S. Mackenzie (2016) A discrete and bounded envy-free cake cutting protocol for any number of agents. In IEEE 57th Annual Symposium on Foundations of Computer Science, FOCS, I. Dinur (Ed.), pp. 416–427. External Links: Document Cited by: §4.2.
  • [2] S. J. Brams and A. D. Taylor (1996) Fair division: from cake-cutting to dispute resolution. Cambridge University Press. External Links: Document Cited by: §1.
  • [3] S. Brânzei, I. Caragiannis, D. Kurokawa, and A. D. Procaccia (2013) Equilibria of generalized cut and choose protocols. CoRR abs/1307.2225. External Links: Link, 1307.2225 Cited by: §1.1, §1.1, §1, §2.2, §2.2, §4.1.
  • [4] S. Brânzei, I. Caragiannis, D. Kurokawa, and A. D. Procaccia (2016) An algorithmic framework for strategic fair division. In

    Procs. of the 30th AAAI Conference on Artificial Intelligence

    , D. Schuurmans and M. P. Wellman (Eds.),
    pp. 418–424. External Links: Link Cited by: Equivalence of Models of Cake-Cutting Protocols111This paper is based on the second author’s final year project., §1.1, §1.1, §1, §2.2.
  • [5] S. Brânzei and P. B. Miltersen (2015) A dictatorship theorem for cake cutting. In Proceedings of the 24th International Conference on Artificial Intelligence, IJCAI’15, pp. 482–488. External Links: ISBN 9781577357384 Cited by: §1.1.
  • [6] S. Brânzei (2015) Computational fair division. Ph.D. Thesis, Department of Computer Science, Aarhus University, Department of Computer Science, Aarhus University, (English). Note: Main Supervisor: Peter Bro Miltersen Cited by: §3.6.
  • [7] Y. Chen, J. K. Lai, D. C. Parkes, and A. D. Procaccia (2013) Truth, justice, and cake cutting. Games and Economic Behavior 77 (1), pp. 284–297. External Links: ISSN 0899-8256, Document, Link Cited by: §1.1.
  • [8] L. E. Dubins and E. H. Spanier (1961) How to cut a cake fairly. The American Mathematical Monthly 68 (1P1), pp. 1–17. External Links: Document, Link, https://doi.org/10.1080/00029890.1961.11989615 Cited by: §1, §3.6.
  • [9] S. Even and A. Paz (1984) A note on cake cutting. Discrete Applied Mathematics 7 (3), pp. 285–296. External Links: ISSN 0166-218X, Document, Link Cited by: §3.6.
  • [10] A. D. Procaccia (2013) Cake cutting: not just child’s play. Commun. ACM 56 (7), pp. 78–87. External Links: Link, Document Cited by: §1.1.
  • [11] J. Robertson and W. Webb (1998) Cake-cutting algorithms: be fair if you can. A K Peters. External Links: ISBN 9781568810768, LCCN 97041258, Link Cited by: §1.1, §1, §1, §2.2.
  • [12] H. Steinhaus (1949) Sur la division pragmatique. Econometrica 17, pp. 315–319. External Links: ISSN 00129682, 14680262, Link Cited by: §1.
  • [13] B. Tao (2021) On existence of truthful fair cake cutting mechanisms. CoRR abs/2104.07387. External Links: Link, 2104.07387 Cited by: §1.1.
  • [14] G. J. Woeginger and J. Sgall (2007) On the complexity of cake cutting. Discrete Optimization 4 (2), pp. 213–220. External Links: ISSN 1572-5286, Document, Link Cited by: §1.1.