Cake Cutting on Graphs: A Discrete and Bounded Proportional Protocol

TL;DR

This paper introduces a simple, discrete, and bounded protocol for achieving locally proportional cake allocations on any graph, significantly improving efficiency over previous envy-free protocols.

Contribution

It presents the first efficient, single-exponential query complexity protocol for locally proportional cake cutting on general graphs.

Findings

Protocol works for any graph structure.

Query complexity is single exponential, much lower than previous methods.

Guarantees locally proportional allocations in polynomial time.

Abstract

The classical cake cutting problem studies how to find fair allocations of a heterogeneous and divisible resource among multiple agents. Two of the most commonly studied fairness concepts in cake cutting are proportionality and envy-freeness. It is well known that a proportional allocation among $n$ agents can be found efficiently via simple protocols [16]. For envy-freeness, in a recent breakthrough, Aziz and Mackenzie [5] proposed a discrete and bounded envy-free protocol for any number of players. However, the protocol suffers from high multiple-exponential query complexity and it remains open to find simpler and more efficient envy-free protocols. In this paper we consider a variation of the cake cutting problem by assuming an underlying graph over the agents whose edges describe their acquaintance relationships, and agents evaluate their shares relatively to those of their neighbors. An allocation is called locally proportional if each agent thinks she receives at least the average value over her neighbors. Local proportionality generalizes proportionality and is in an interesting middle ground between proportionality and envy-freeness: its existence is guaranteed by that of an envy-free allocation, but no simple protocol is known to produce such a locally proportional allocation for general graphs. Previous works showed locally proportional protocols for special classes of graphs, and it is listed in both [1] and [8] as an open question to design simple locally proportional protocols for more general classes of graphs. In this paper we completely resolved this open question by presenting a discrete and bounded locally proportional protocol for any given graphs. Our protocol has a query complexity of only single exponential, which is significantly smaller than the six towers of $n$ query complexity of the envy-free protocol given in [5].

Equations

$$f_r(X_u)\le \frac{f_r(R)-\frac{2}{m}{f}_r(R)-f_r(R^{\prime })}{m-2}=\frac{f_r(R)}{m}-\frac{f_r(R^{\prime })}{m-2}=f_r(X_r)-\frac{f_r(R^{\prime })}{m-2}.$$

$$C=|{\mathcal{S}}_1|\ge \prod _{i=1}^{k-1}(d_{u_i}+d_{u_{i+1}}+1).$$

$$d_{u_i}+d_{u_{i+3}}+\cdots +d_{u_{3(k_i-1)+i}}+k_i\le n.$$

$$\sum _{i=1}^k{d}_{u_i}+k\le 3n.$$

$$\prod _{i=1}^{k-1}(d_{u_i}+d_{u_{i+1}}+1)\le {\left(\frac{2{\sum }_{i=1}^k{d}_{u_i}+k}{k}\right)}^k\le {\left(\frac{6n}{k}\right)}^k.$$

$$\sum _{k=1}^{K_v}{f}_v(X_v^k)$$

$$\sum _{i=1}^{m-1}T(m-1,i)+\sum _{i=1}^{m-2}(i+1)+n^{\prime \prime }+n^{\prime }{n}^{\prime \prime }.$$

$$T(n^{\prime \prime },n^{\prime })$$

$$\left(\genfrac{}{}{0ex}{}{n^{\prime }}{3}\right)+\frac{n^{\prime }(n^{\prime }-3)}{2}+n^{\prime }{n}^{\prime \prime }+n^{\prime 2}{n}^{\prime \prime }\le \left(1-\frac{1}{(\tilde{c}-1{)}^2}\right){\tilde{c}}^{n^{\prime }+n^{\prime \prime }}.$$

$$T(n^{\prime \prime },n^{\prime })$$

$$W\leftarrow W\cup \{i\}.$$

Full text

In this paper we consider a variation of the cake cutting problem by assuming an underlying graph over the agents whose edges describe their acquaintance relationships, and agents evaluate their shares relatively to those of their neighbors. An allocation is called locally proportional if each agent thinks she receives at least the average value over her neighbors. Local proportionality generalizes proportionality and is in an interesting middle ground between proportionality and envy-freeness: its existence is guaranteed by that of an envy-free allocation, but no simple protocol is known to produce such a locally proportional allocation for general graphs. Previous works showed locally proportional protocols for special classes of graphs, and it is listed in both [1] and [8] as an open question to design simple locally proportional protocols for more general classes of graphs. In this paper we completely resolved this open question by presenting a discrete and bounded locally proportional protocol for any given graph. Our protocol has a query complexity of only single exponential, which is significantly smaller than the six towers of $n$ query complexity of the envy-free protocol given in [5].

**Keywords: cake cutting, proportionality, envy-freeness, local fairness, discrete and bounded protocol **

1 Introduction

The problem of fair division studies how to allocate a set of scarce resources to a set of interested agents in a fair manner. When the resource is heterogeneous and divisible, the problem is known as “cake cutting” and has a long and intriguing history in multiple disciplines such as economics, social science, political science, and computer science [11, 20, 19]. In the standard model, a single heterogeneous resource, also known as a cake, is represented by the interval $[0,1]$. Each agent has a valuation function which defines her preference over different parts of the resource. The goal is to distribute the resource to the agents using standard queries [20], such that everyone feels she is treated “fairly”. Two of the most prominent concepts to measure fairness in cake cutting are proportionality and envy-freeness. Informally, proportionality means that each agent, in her own view, gets at least an average share of the cake; and envy-freeness means that each agent weakly prefers her own piece to any other agent’s. It is not hard to see that envy-freeness implies proportionality but not vice versa.

It is well known that a proportional allocation among $n$ agents can be efficiently found using $O(n\log{n})$ queries [16]. In the meanwhile, since the 1940s, the envy-free cake cutting problem has baffled the great minds from multiple disciplines. It was not until 2016 that discrete and bounded envy-free protocols for four and more players were finally proposed by Aziz and Mackenzie [6, 5]. Despite these groundbreaking advances, the main drawback of the new protocols is their high query complexity in the form of six towers of $n$. The unrealistic number of evaluations and cuts required by the protocols prevents them from being put into practical use.

A common assumption made by all previous works is that each agent is aware of which parts every other agent gets, and is comparing her own piece to everyone else’s. This is not necessarily the case in many contexts where each agent’s knowledge and focus are local. In light of this, two independent works [1, 8] considered a notion of local fairness 111This notion is termed local fairness in [1] and networked fairness in [8]. We adopt the former terminology in this paper. For better clarification, we will sometimes also call the original definitions of these two fairness notions global proportionality and global envy-freeness.. Their model assumes an underlying social network over the agents, and defines proportionality and envy-freeness locally in relation to their neighbors: given an underlying graph of the agents, an allocation is locally envy-free if no agents envies any of her neighbor’s share, and is locally proportional if every agent values her own share no less than the average among her neighbors. Both local proportionality and local envy-freeness are weaker than the global envy-freeness. Yet from a practical point of view they capture many situations in which global knowledge is unavailable or unrealistic. It is also hopeful that by considering only local comparisons, there could exist simpler and more intuitive protocols that produce locally fair allocations.

For local envy-freeness, a nontrivial continuous protocol for trees was proposed in [8] when the protocol is allowed to perform the so-called Austin Cut Procedure [3]. However, this protocol is hard to generalize. What’s worse, it seems a far-fetched task to have a simple but general locally envy-free protocol for any given graph. If we have such a protocol, then by applying the result to the complete graph, it would imply a simple globally envy-free protocol. From previous works and attempts, this seems to be a very difficult task.

On the other hand, local proportionality poses an intriguing case. First of all, a simple globally proportional protocol can be easily found [16]. However, unlike local envy-freeness, local proportionality is not a monotone property. That is, a globally proportional allocation is not necessarily locally proportional for a particular graph. In the meanwhile, for any graph, the existence of a locally proportional allocation is guaranteed from that of a globally envy-free allocation. In [8], the authors gave a simple locally proportional protocol for a special class of graphs known as the descendant graph. It is listed both in [1] and [8] as an open question to design simple and locally proportional protocols for more classes of graphs.

Our Contribution.

In this paper, we completely resolve the aforementioned open question by presenting a protocol that is able to produce a locally proportional allocation for any given graph. The protocol only has a single exponential query complexity, which is a significant improvement over the six towers of $n$ query complexity of the globally envy-free protocol from [5]. It is a discrete protocol in that it only requires standard queries [20] and does not require any continuous operations such as the moving-knife procedure. It also shows that proportionality can indeed be algorithmically generalized to incorporate graphical structures in a simple and efficient way.

Similar to most envy-free cake cutting protocols [2, 5, 6, 10], our protocol maintains a locally proportional partial allocation and an unallocated residue of the cake. It repeatedly updates both parts throughout its execution, until the unallocated residue is allocated completely. We rely on the concept of dominant agents to help eliminate the residue. Intuitively speaking, an agent is dominant if she remains proportional even if the residue were to be allocated among her neighbors. This, as a result, allows us to allocate the residue only among non-dominant agents. Surprisingly, in doing so, the remaining non-dominant agents can be made dominant as well in an efficient way, based on the observation that the neighbors of a dominant agent are able to collect enough bonuses over her and finally dominate her by excluding her from the remaining allocation.

Despite its useful corollaries, the argument above does not tell us how the first dominant agent can be created. Indeed, this issue is the most difficult part of the problem. We manage to resolve it by adopting the idea of exchanging pieces allocated to agents. In doing so, we hope that for a specific agent, the pieces of insignificant values in her own view will be transferred to her neighbors’ hands. However, in general, exchanging pieces may incur large losses in agents’ shares. As a result, the new allocation after exchange may not maintain the desired fairness any more. Previously, Aziz and Mackenzie [5] managed to overcome this difficulty by reserving an enough fraction of the residue and allocating it carefully to cover any possible losses. Their method is extremely complicated, resulting in the towers of $n$ query complexity. In contrast, we always split the allocation into two parts, and restrict the exchange to take place within one of the two parts, such that the losses incurred are covered by the bonuses reserved in the other part. We note that our method is possible since we merely need to achieve the weaker proportionality constraint.

Related Work.

It is well known that a globally proportional allocation among $n$ agents can be efficiently found using $O(n\log n)$ queries [16]. On the other hand, after a series of attempts [17, 25], a matching lower bound was finally proved in [15]. In contrast, although a globally envy-free allocation is guaranteed to exist [22, 23], finding such an allocation seems to be extremely hard. In 1995, Brams and Taylor proposed a discrete but unbounded protocol [10]. However, their protocol suffers from a significant drawback that the number of queries can be made arbitrarily large by choosing certain agents’ valuation functions. Later, by resorting to the moving-knife procedure, several continuous protocols were proposed for four agents [9, 7] and five agents [21]. It was not until 2016 that discrete and bounded protocols for four and more agents were finally proposed by Aziz and Mackenzie [6, 5]. The only known nontrivial lower bound is $\Omega(n^{2})$ [18].

The notion of local fairness with respect to social networks was first introduced to the cake cutting problem independently in [1] and [8]. Previously known algorithmic results are mainly from [8], which gave a locally envy-free continuous protocol for trees as well as a locally proportional protocol for a special class of graphs known as the descendant graph.

The idea of restricted comparison has also been considered in the allocation of indivisible resources. For instance, both Chevaleyre et al. [14] and Brederect et al. [12] considered the graph envy-freeness where envy can only arise between adjacent agents. Todo et al. [24] studied envy-freeness between two groups of agents. Aziz et al. [4] proposed a family of epistemic notions of fairness based on a social graph, establishing a hierarchy among various notions of fairness. Chen and Shah [13] defined the so-called Bayesian envy-freeness under a Bayesian scenario.

Structure.

In Section 2, we give a formal description of the problem and introduce some central concepts as well as the Core Protocol in [5] used in our protocol. In section 3, we present a locally proportional protocol for any given graph as well as its analysis. As a supplement, in section 4, we discretize the continuous protocol in [8] to obtain a locally envy-free partial allocation on trees. We conclude our paper by proposing several open problems in Section 5.

2 Preliminaries

A cake is to be allocated among a set of $n$ agents on an undirected social graph $G=(V,E)$, with each vertex $v\in V$ identified with an agent. The cake is represented by the interval $[0,1]$. A piece of cake refers to a finite union of disjoint subintervals of $[0,1]$. The collection $\{A_{v}\}_{v\in V}$ of disjoint pieces is called an allocation if piece $A_{v}$ is allocated to agent $v$. An allocation is partial if the union of the allocated pieces is not the whole cake; otherwise it is complete. The unallocated part with respect to a partial allocation is called a residue, often denoted by $R$. In a standard setting, the cake is required to be allocated completely.

Each agent $v\in V$ has a valuation function $f_{v}$ over different pieces of the cake, which is defined on subintervals of $[0,1]$ and assumes the following properties.

• •

Normalized and nonnegative. $f_{v}([0,1])=1$ and $f_{v}(I)\geq 0$ for interval $I\subseteq[0,1]$.

• •

Additive. $f_{v}(I\cup I^{\prime})=f_{v}(I)+f_{v}(I^{\prime})$ for disjoint intervals $I,I^{\prime}$.

• •

Divisible. For any interval $I$ and $0\leq\lambda\leq 1$, there exists an interval $I^{\prime}\subseteq I$ such that $f_{v}(I^{\prime})=\lambda\cdot f_{v}(I)$.

We adopt the standard Robertson-Webb query model [20] to access agents’ valuations, in which two kinds of queries are allowed.

• •

Evaluation queries. Given an interval $[x,y]$ and an agent $v$, the query returns $f_{v}([x,y])$.

• •

Cut queries. Given a point $x\in[0,1]$, a value $\alpha$ and an agent $v$, the query returns a point $y$ such that $f_{v}([x,y])=\alpha$.

The complexity of a cake cutting protocol is measured by the total number of queries it uses.

Let $N(v)$ denote the set of agent $v$’s neighbors and $d_{v}=|N(v)|$ denote its degree. Below are two concepts used to measure the fairness of an allocation on a graph. By their definitions, we may assume w.l.o.g that the graph is connected, since otherwise we can allocate the cake within a particular component of the graph.

Definition 1** (Local proportionality).**

An allocation $\{A_{v}\}_{v\in V}$ is locally proportional on a graph $G=(V,E)$ if for each $v\in V$, $f_{v}(A_{v})\geq\frac{1}{d_{v}}\sum_{u\in N(v)}f_{v}(A_{u})$.

Definition 2** (Local envy-freeness).**

An allocation $\{A_{v}\}_{v\in V}$ is locally envy-free on a graph $G=(V,E)$ if for each $v\in V$ and $u\in N(v)$, $f_{v}(A_{v})\geq f_{v}(A_{u})$.

2.1 Central Concepts Used in Our Protocol

Similar to most cake cutting protocols [2, 5, 6, 10], our protocol maintains a locally proportional partial allocation and a residue of the cake. It repeatedly invokes the Core Protocol in [5] to diminish the residue throughout its execution, until the residue is allocated completely. We introduce several concepts below to further identify the quality of an allocation. They play central roles in our protocol for eliminating the unallocated residue.

Definition 3** (Dominant agents).**

Given an allocation $\{A_{v}\}_{v\in V}$ and the residue $R$, an agent $v$ is dominant if $f_{v}(A_{v})\geq\frac{1}{d_{v}}(\sum_{u\in N(v)}f_{v}(A_{u})+f_{v}(R))$.

Intuitively, a dominant agent will remain proportional even if the residue were to be allocated among her neighbors. As a result, a dominant agent can be safely excluded from the allocation of the residue, reducing the problem to a smaller scale. In essence, our protocol is all about how agents can be made dominant. We rely on the following concept and observation to create a dominant agent.

Definition 4** (Dominance between a pair of agents).**

Given an allocation $\{A_{v}\}_{v\in V}$ and the residue $R$, we say agent $v$ dominates agent $u$ if $f_{v}(A_{v})\geq f_{v}(A_{u})+f_{v}(R)$.

Observation 1**.**

Given an allocation $\{A_{v}\}_{v\in V}$ and the residue $R$, if agent $v$ is envy-free and additionally she dominates at least one of her neighbors, then she is dominant.

Proof.

Assume that agent $v$ dominates her neighbor $w$, then $f_{v}(A_{v})\geq f_{v}(A_{w})+f_{v}(R)$. Since agent $v$ is also envy-free, $f_{v}(A_{v})\geq f_{v}(A_{u})$ for $u\in N(v)$. Hence $f_{v}(A_{v})\geq\frac{1}{d_{v}}(\sum_{u\in N(v)}f_{v}(A_{u})+f_{v}(R))$, i.e agent $v$ is dominant. ∎

The next concept is heavily used in our protocol as well as its analysis. It also provides an alternative perspective of the concepts above, as discussed in the following paragraph.

Definition 5** (Bonus).**

Given an allocation $\{A_{v}\}_{v\in V}$, the difference $f_{v}(A_{v})-f_{v}(A_{u})$ is called agent $v$’s bonus over agent $u$; the summation $\sum_{u\in N(v)}(f_{v}(A_{v})-f_{v}(A_{u}))$ is called agent $v$’s bonus over her neighbors.

It is easy to see that agent $v$ does not envy agent $u$ if her bonus over agent $u$ is nonnegative. Agent $v$ is proportional if her bonus over her neighbors is nonnegative. Besides, agent $v$ is dominant if her bonus over her neighbors is at least the value of the residue. Agent $v$ dominates agent $u$ if her bonus over agent $u$ is at least the value of the residue.

2.2 The Core Protocol

Our protocol repeatedly invokes the Core Protocol, which was proposed by Aziz and Mackenzie in their celebrated paper [5] to deal with the canonical case where the underlying graph is a complete graph. We denote this protocol by Core$(r,N,R)$, where $R$ is the residue to be allocated among agents in $N\subseteq V$, and agent $r\in N$ serves as a cutter, who will cut the residue $R$ into $m=|N|$ equally preferable pieces at the very beginning of the protocol. The protocol returns a (possibly partial) allocation $\{X_{v}\}_{v\in V}$ of $R$ and an updated residue $R^{\prime}=R\backslash(\cup_{v\in V}X_{v})$ with the following properties.

• •

Each agent $v\in N$ obtains (possibly a part of) exactly one out of the $m$ pieces cut by the cutter $r$. Besides, the cutter $r$ and one more agent $u\neq r$ each obtains a complete piece.

• •

The allocation $\{X_{v}\}_{v\in V}$ is globally envy-free. That is, for any $v,u\in N$, $f_{v}(X_{v})\geq f_{v}(X_{u})$, despite whether or not $v$ and $u$ are adjacent.

It was shown in [5] that the Core Protocol is bounded by $n^{2n+3}$ queries. In Subsection 3.3, we give a tighter analysis and improve the bound to $O(c^{n})$ queries for any constant $c>4$. For completeness and readability, we also present the overall description of the Core Protocol in that subsection.

Definition 6** (Snapshot).**

The allocation $\{X_{v}\}_{v\in V}$ returned by an execution of the Core Protocol is called a snapshot.

The Core Protocol reduces to the famous Cut and Choose Protocol when $|N|=2$ and therefore will allocate the residue $R$ completely among agents in $N$. When $|N|\geq 3$, the updated residue $R^{\prime}$ is possibly non-empty. Fortunately, as described below, it is guaranteed that in a snapshot the cutter $r$ has a large bonus over some agent $u\in N$, which makes it possible to make the cutter $r$ dominant.

Definition 7** (Insignificant piece).**

Given a snapshot $\{X_{v}\}_{v\in V}$ and the updated residue $R^{\prime}$ returned by Core$(r,N,R)$ with $m=|N|\geq 3$, a piece $X_{u}$ is called an insignificant piece if $f_{r}(X_{r})-f_{r}(X_{u})\geq f_{r}(R^{\prime})/(m-2)$. We say the cutter $r$ has a significant bonus over the agent who is allocated an insignificant piece in the snapshot.

Observation 2**.**

Given a snapshot $\{X_{v}\}_{v\in V}$ and the updated residue $R^{\prime}$ returned by Core$(r,N,R)$ with $m=|N|\geq 3$, there exists at least one insignificant piece.

Proof.

By the properties of the Core Protocol, in the snapshot the cutter $r$ and some other agent each obtains a piece of value $f_{r}(R)/m$. Hence the remaining $m-2$ agents are allocated pieces of value $f_{r}(R)-\frac{2}{m}f_{r}(R)-f_{r}(R^{\prime})$. By an averaging argument, there exists an agent $u$ who obtains a piece $X_{u}$ such that

[TABLE]

Therefore, $X_{u}$ is an insignificant piece. ∎

It turns out that the cutter $r$ can finally dominate the agent $u$ who holds an insignificant piece by the following procedure: starting from $R^{\prime}$, run the Core Protocol another $k\geq m\ln(m-2)/2$ times on the continually updated residue with agent $r$ as the cutter. On the one hand, the cutter $r$’s bonus over agent $u$ in the final allocation is at least $f_{r}(R^{\prime})/(m-2)$, since the snapshots generated by the following executions of the Core Protocol is envy-free. On the other hand, since one execution of the Core Protocol reduces the residue to at most an $(m-2)/m$ fraction in the cutter’s valuation, the final residue is of value at most $(\frac{m-2}{m})^{k}f_{r}(R^{\prime})$, which is smaller than $f_{r}(R^{\prime})/(m-2)$. As a result, the cutter $r$ dominates agent $u$ at the moment.

3 The Proportional Protocol

Our protocol runs in two stages. In the first stage, the protocol specifies an agent $r$ that is from the center222The center of a graph is the set of vertices whose eccentricities equal to the radius of the graph. Recall that the eccentricity of a vertex is the greatest distance between other vertices and it. of $G$. Then the CreateDominance Protocol in Subsection 3.1 will guarantee that agent $r$ is dominant. In the second stage, starting from agent $r$, we manage to make every other agent dominant by invoking the DiffuseDominance Protocol designed in Subsection 3.2. The remaining residue will also be allocated in this stage, resulting in a proportional allocation of the whole cake. We summarize these two stages as the Main Protocol (Algorithm 1).

3.1 Create the First Dominant Agent

The CreateDominance Protocol (Algorithm 2) depicts how a specified agent $r$ can be made dominant. By Observation 1, it suffices for the task if we are able to find an allocation in which agent $r$ is envy-free and additionally she dominates one of her neighbors. To this end, we resort to the Core Protocol and manipulate the snapshots returned by running it multiple times on the continuously updated residue. By the definition of insignificant pieces (Definition 7), agent $r$ will finally dominate one of her neighbors if this neighbor is allocated an insignificant piece in some snapshot. Unfortunately, however, it could be the case that the insignificant pieces are always allocated to agent $r$’s non-neighbors. Consequently, the most difficult part of the task lies in how it is guaranteed that an insignificant piece is allocated to some neighbor of agent $r$. We manage to overcome this difficulty by exchanging agents’ pieces allocated in the same snapshot, in the meanwhile maintaining the proportionality of the overall allocation. Our key observation is that a pair of adjacent agents is able to safely exchange their pieces in one of at most $2n$ snapshots. Specifically, two adjacent agents will exchange their pieces allocated in the snapshot where their bonuses over each other are both smaller than those in the remaining snapshots. In doing so, the loss incurred by exchanging pieces in the selected snapshot will be bounded by the bonuses reserved in the other snapshots, leading the overall allocation to remain proportional. As an immediate application of the observation, our protocol manages to transfer the insignificant pieces held by an agent $u$ to some neighbor of agent $r$ along a shortest path from agent $u$ to agent $r$. The parameter $C^{\prime}$ at the beginning of the protocol denotes the number of snapshots required to ensure that some agent $u$ holds an enough number of insignificant pieces such that at least one of them can be successfully transferred to some neighbor of agent $r$. The value of $C^{\prime}$ will be determined in Lemma 2.

Lemma 1**.**

Algorithm 2 returns a (possibly partial) locally proportional allocation on graph $G$ where agent $r$ is dominant.

Proof.

We assume w.l.o.g. that the insignificant pieces in the $C^{\prime}$ snapshots are always allocated to agent $r$’s non-neighbors, since otherwise by Observation 1, agent $r$ will be dominant after step 4. Under this assumption, some non-neighbor $u$ of agent $r$ is guaranteed to obtain the insignificant pieces in at least $C=C^{\prime}/(n-1)$ snapshots by an averaging argument. Below we show that every agent remains proportional in the overall allocation throughout the remaining part of the protocol.

First observe that agents not in the path $P^{\prime}=u_{1}u_{2}\cdots u_{k}$ remain envy-free and thus proportional throughout the protocol, since they never have their pieces exchanged, and a snapshot is globally envy-free, implying that they always hold the best piece in a snapshot.

Next we show by induction that each agent in $P^{\prime}$ remains proportional after agent $u_{i}$ and agent $u_{i+1}$ exchanged their pieces in snapshots from $\mathcal{S}_{i+1}$, assuming that each agent is proportional before the exchange. First observe that for any $j>i+1$, agent $u_{j}$ will remain envy-free and thus proportional, since she has not yet had her pieces exchanged. Next, we consider agent $u_{i+1}$ and agent $u_{i}$. Below we use $b_{j}(u,v)$ to denote agent $u$’s bonus over agent $v$ in a given snapshot $S^{j}$ before the exchange and $b^{\prime}_{j}(u,v)$ to denote the corresponding bonus after the exchange.

For agent $u_{i+1}$, we show that her loss incurred by exchanging pieces in snapshots from $\mathcal{S}_{i+1}$ is covered by her bonuses over agent $u_{i}$ in snapshots from $\mathcal{S}^{\prime\prime}_{i}$, thus remaining proportional. Given a snapshot $S^{j}$ from $\mathcal{S}_{i+1}$, the bonuses $b_{j}(u_{i+1},v)$ before the exchange are non-negative, since agent $u_{i+1}$ has not had her piece exchanged. After the exchange, the updated bonuses $b^{\prime}_{j}$ satisfy that $b^{\prime}_{j}(u_{i+1},u_{i})=-b_{j}(u_{i+1},u_{i})$ and $b^{\prime}_{j}(u_{i+1},v)=b_{j}(u_{i+1},v)-b_{j}(u_{i+1},u_{i})$ for agent $v\neq u_{i}$. Consequently, the loss in agent $u_{i+1}$’s bonus over her neighbors incurred by exchanging pieces in $S^{j}$ is $d_{u_{i+1}}\cdot b_{j}(u_{i+1},u_{i})$. The total loss incurred by exchanging pieces in snapshots from $\mathcal{S}_{i+1}$ is therefore $d_{u_{i+1}}\cdot\sum_{S^{j}\in\mathcal{S}_{i+1}}b_{j}(u_{i+1},u_{i})$. By the choice of $\mathcal{S}^{\prime\prime}_{i}$, however, $|\mathcal{S}^{\prime\prime}_{i}|=d_{u_{i+1}}\cdot|\mathcal{S}_{i+1}|$ and agent $u_{i+1}$’s bonus over agent $u_{i}$ in any snapshot from $\mathcal{S}^{\prime\prime}_{i}$ is at least that in any snapshot from $\mathcal{S}_{i+1}$. Therefore, the loss has been totally covered.

The same conclusion holds for agent $u_{i}$, but it deserves to illustrate some additional details. Note that the bonuses $b_{j}(u_{i},v)$ in a given snapshot $S_{j}$ before the exchange could be negative. They are indeed the losses incurred when agent $u_{i-1}$ and agent $u_{i}$ exchanged their pieces and have already been covered at that time. Hence there is no need to worry about the first part of the bonuses $b^{\prime}_{j}(u_{i},v)=b_{j}(u_{i},v)-b_{j}(u_{i},u_{i+1})$ after the exchange. The second part is bounded by the same argument as that for agent $u_{i+1}$.

For any $j<i$, the proportionality of agent $u_{j}$ follows immediately from the argument below. By the analysis above, the reason why an agent remains proportional is that whenever she is reallocated an inferior piece in a snapshot, the loss is covered as if she is reallocated a piece of the same value as the best piece in this snapshot. As a result, this agent will still remain proportional as long as she is not reallocated another inferior piece in the future.

Agent $r$ remains envy-free throughout the protocol. Let $C^{\prime}$ be the value determined in Lemma 2 such that $\mathcal{S}_{k}$ is non-empty, the neighbor $u_{k}$ of agent $r$ is guaranteed to obtain the insignificant pieces in the snapshots from $\mathcal{S}_{k}$. By Observation 1, agent $r$ will be dominant after step 16.

∎

Lemma 2**.**

Algorithm 2 uses $O(n\cdot\left(\frac{6n}{k}\right)^{k}T(n))$ queries by setting $C=\left(\frac{6n}{k}\right)^{k}$, where $k$ is the length of the shortest path $P$ found by Algorithm 2 and $T(n)$ is the number of queries used in the Core Protocol.

Proof.

We bound the complexity of the protocol by determining an appropriate value of $C$ such that $\mathcal{S}_{k}$ is non-empty. Since $|\mathcal{S}_{i}|=(d_{u_{i}}+d_{u_{i+1}}+1)\cdot|\mathcal{S}_{i+1}|$, a lower bound of $C$ is

[TABLE]

For $i=1,2,3$, let $k_{i}=|\{u_{j}\in P\mid j\equiv i\pmod{3}\}|$. Thus $k_{1}+k_{2}+k_{3}=k$. Since $P$ is a shortest path, agent $u_{i}$ and agent $u_{j}$ have no common neighbors if $|i-j|>2$. Therefore, for $i=1,2,3$,

[TABLE]

Summing up these inequalities yields

[TABLE]

By the fundamental inequality,

[TABLE]

Hence it suffices to set $C=\left(\frac{6n}{k}\right)^{k}$. The lemma follows since the complexity of the Core Protocol is dominant in Algorithm 2 and it is invoked $O(nC)$ times. ∎

We summarize the above results as Theorem 1.

Theorem 1**.**

Algorithm 2 returns a (possibly partial) locally proportional allocation on graph $G$ where agent $r$ is dominant and uses $O(n\cdot\left(\frac{6n}{k}\right)^{k}T(n))$ queries, where $k$ is the length of the shortest path $P$ found by Algorithm 2 and $T(n)$ is the number of queries used in the Core Protocol.

3.2 Make Every Agent Dominant

In principle, each agent can be made dominant by running the CreateDominance Protocol with it as an input. However, the DiffuseDominance Protocol (Algorithm 3) shows that it is possible to fulfill the task by only using additional $O(n^{2})$ calls of the Core Protocol once the first dominant agent $r$ was created. The key observation is that a dominant agent will remain proportional even if she is excluded from the allocation of the residue. Thus by invoking the Core Protocol to allocate the residue among the remaining agents, the neighbors of a dominant agent are able to collect enough bonuses over her and finally dominate her.

Theorem 2**.**

Algorithm 3 returns a locally proportional complete allocation of the cake $R$ on graph $G$ with $O(n^{2})$ calls of the Core Protocol.

Proof.

We first fix some notations for a particular ‘while’ loop where a neighbor $v$ of $D$ serves as a cutter of the Core Protocol. Let $\{A_{u}^{0}\}_{u\in V}$ be the partial allocation and $R^{0}$ be the residue just before this loop. For $k=1,\cdots,K_{v}$, let $\{X_{u}^{k}\}_{u\in V}$ be the snapshot and $R^{k}=R^{k-1}\backslash(\cup_{u\in V}X_{u}^{k})$ be the updated residue returned by Core$(v,V\backslash D,R^{k-1})$. Then $A_{u}^{K_{v}}=A_{u}^{0}\cup(\cup_{i=1}^{K_{v}}X_{u}^{i})$ denotes the pieces allocated to agent $u\in V$ and $R^{K_{v}}$ denotes the residue when the ‘while’ loop terminates. Assume by induction that the allocation $\{A_{u}^{0}\}_{u\in V}$ is locally proportional and agents in $D$ are dominant, we prove that a) the allocation $\{A_{u}^{K_{v}}\}_{u\in V}$ is still locally proportional, and b) agent $v$ becomes dominant by setting an appropriate value for $K_{v}$. Note that the base case holds due to Theorem 1, by running Algorithm 2 before Algorithm 3.

During the ‘while’ loop, the residue is allocated among agents in $V\backslash D$ by the Core Protocol in an envy-free manner, thus agents in $V\backslash D$ remain proportional. Besides, since agents in $D$ are already dominant, they will remain proportional despite how the residue is allocated. As a result, the allocation $\{A_{u}^{K_{v}}\}_{u\in V}$ is still locally proportional.

Let $|V\backslash D|=m$. We show that agent $v$ will be dominant by setting $K_{v}=(m-2)\cdot\ln 3$ if $m\geq 3$ and $1$ otherwise. When $m=2$, the Core Protocol reduces to the famous Cut and Choose Protocol where the residue is allocated completely among agents in $V\backslash D$. Since at this point the whole cake has been allocated, the protocol terminates with the desired properties. When $m\geq 3$, we first claim that agent $v$’s bonus over her neighbors is at least $\sum_{k=1}^{K_{v}}f_{v}(X_{v}^{k})$. Since agent $v$ is a neighbor of $D$, there exists an agent $r^{\prime}\in D$ such that they are adjacent. For each snapshot $\{X_{u}^{k}\}_{u\in V}$, the piece $X_{r^{\prime}}^{k}$ is empty since agent $r^{\prime}$ was excluded from the allocation of $R^{k-1}$. Hence agent $v$’s bonus over agent $r^{\prime}$ in this snapshot is $f_{v}(X_{v}^{k})$. The claim follows by the assumption that $\{A_{u}^{0}\}_{u\in V}$ is locally proportional. Next we show that the value $\sum_{k=1}^{K_{v}}f_{v}(X_{v}^{k})$ is larger than the value $f_{v}(R^{K_{v}})$, which implies that agent $v$ is dominant. By the properties of the Core Protocol, we have $f_{v}(X_{v}^{k})=\frac{1}{m}f_{v}(R^{k-1})$ and $f_{v}(R^{k})\leq\frac{m-2}{m}f_{v}(R^{k-1})$. Therefore,

[TABLE]

The last inequality holds since we choose $K_{v}=(m-2)\cdot\ln 3$.

Finally, since there are $n$ agents and each agent invokes the Core Protocol $K_{v}=O(n)$ times, the protocol only needs $O(n^{2})$ calls of the Core Protocol. ∎

3.3 The Complexity of Core Protocol

To further reduce the overall complexity of our protocol, we give a tighter upper bound of the Core Protocol in this subsection. Previously, Aziz and Mackenzie [5] showed that the Core Protocol is bounded by $n^{2n+3}$ queries. They did not optimize their analysis since the main focus of their paper is to obtain a bounded protocol. For readability of our analysis, we present the Core Protocol (Algorithm 4) as well as the SubCore Protocol (Algorithm 5) it invokes in this subsection.

Lemma 3**.**

The Core Protocol uses $O(c^{n})$ queries for any constant $c>4$.

Proof.

We directly analyze the complexity of the SubCore Protocol, since the Core Protcol needs only $n-1$ additional queries. Denote by $T(n^{\prime\prime},n^{\prime})$ the number of queries that the SubCore Protocol needs to allocate $n^{\prime\prime}$ pieces among $n^{\prime}$ agents ($n^{\prime\prime}\geq n^{\prime}$). The ‘for’ loop iterates for $m=1,\cdots,n^{\prime}$. In the $m$-th iteration, agent $m$ needs $n^{\prime\prime}$ evaluations in step 2. In step 5, each agent needs $n^{\prime\prime}-(m-1)$ evaluations on uncontested pieces and $m-1$ cuts on contested pieces. Thus this step costs at most $n^{\prime}n^{\prime\prime}$ queries in total. The ‘while’ loop may iterate for $|W|=1,\cdots,m-2$ in the worst case. In each iteration, the SubCore Protocol is invoked in step 9 on the $m-1$ contested pieces among agents in $W$ and therefore requires $T(m-1,|W|)$ queries. Step 11 costs $|W|+1$ evaluations. Step 13 costs another $T(m-1,m-1)$ queries. To summarize, the number of queries used in the $m$-th iteration of the ‘for’ loop is at most

[TABLE]

Therefore, $T(n^{\prime\prime},n^{\prime})$ satisfies the recurrence

[TABLE]

We then prove by induction on $n^{\prime}+n^{\prime\prime}$ that $T(n^{\prime\prime},n^{\prime})\leq\tilde{c}^{n^{\prime}+n^{\prime\prime}}$ for any constant $\tilde{c}>2$ and sufficiently large $n^{\prime}+n^{\prime\prime}$ such that

[TABLE]

Under the above assumptions and the fact that $n^{\prime\prime}\geq n^{\prime}$, we have

[TABLE]

Therefore, the Core Protocol is bounded by $n-1+T(n,n-1)=O(\tilde{c}^{2n})$ queries. ∎

3.4 Analysis of Main Protocol

Combining all the results from previous subsections, we have

Theorem 3**.**

Algorithm 1 returns a locally proportional allocation on graph $G$ with $O(14^{n})$ queries.

Proof.

By Theorem 1 and 2, the allocation returned by the Main Protocol is locally proportional. The CreateDominance Protocol is dominant in the overall complexity and uses $O(n\cdot\left(\frac{6n}{k}\right)^{k}T(n))$ queries by Theorem 1, where $k$ is the length of the shortest path $P$ found in it and $T(n)$ is the number of queries of the Core Protocol. Since the Main Protocol selects an agent $r$ from the center of $G$, we have $k\leq n/2$. By setting $c=7/\sqrt{3}>4$ in Lemma 3, $nT(n)=O((7/\sqrt{3})^{n})$. Hence the overall complexity of the Main Protocol is bounded by $O((2\sqrt{3})^{n}\cdot(7/\sqrt{3})^{n})=O(14^{n})$. ∎

We remark that when the underlying graph $G$ is a path, the CreateDominance Protocol may invoke the Core Protocol roughly $n\cdot 5^{n/2}$ times in the worst case. Thus even if the Core Protocol used polynomial queries, Algorithm 1 is still exponential.

4 Towards Envy-freeness on Trees

This section briefly discusses locally envy-free allocations on trees. Previously, a continuous locally envy-free protocol on trees was already known [8]. However, despite of the globally envy-free protocol designed in [5], a simple discrete and bounded one on trees is still unknown. As we have seen, the Core Protocol in [5] which obtains an envy-free partial allocation is the cornerstone of several cake cutting protocols. In light of this, we present in this section a slightly weaker “Core Protocol” (Algorithm 6) which specializes on trees, but with a significantly improved complexity of $O(n^{2})$ queries.

Theorem 4**.**

Algorithm 6 returns a locally envy-free partial allocation on tree $T$ with $2n^{2}$ queries. Indeed, an agent never envies her descendants on $T$. Besides, root $r$ of $T$ obtains $1/n$ of the cake.

Proof.

Step 5 to 8 are well-defined since $|T(v)|=\sum_{u:\mbox{ }child\mbox{ }of\mbox{ }v}|T(u)|+1$. It follows that each agent gets possibly a part of exactly one piece cut by root $r$ after the protocol terminates. Then root $r$ obtains $1/n$ of the cake since she cuts the cake into $n$ equal pieces and reserves one of them. Next, we show that no envy happens when agent $v$’s children take pieces from him. For a child $u$ of agent $v$, she takes $|T(u)|$ pieces which she values the highest from the remaining pieces that agent $v$ holds when it is agent $u$’s turn. Agent $u$ will finally obtain a piece that is of the same value as the least valuable one among those $|T(u)|$ pieces. Despite that, it is still better than the piece allocated to agent $v$, which guarantees agent $u$ will not envy agent $v$. As for agent $v$, since she cuts all $|T(v)|$ pieces she holds into an equal value before her children take pieces from him, she will not envy her children despite whichever piece she is finally allocated. In addition, $v$ will not envy her descendants since the pieces only gets smaller as the protocol proceeds.

The root needs $(n-1)$ cut queries to obtain $n$ equal pieces. Each non-root agent $u$ needs to evaluate at most $|T(v)|$ pieces held by her parent $v$ and selects $|T(u)|$ pieces from them. She will make $|T(u)|-1$ cuts on her selected pieces. As a result, each agent needs $|T(v)|+|T(u)|-1\leq 2n$ queries and hence the protocol is bounded by $2n^{2}$. ∎

5 Conclusion

There remains several open problems on the cake cutting problem under social graphs. First of all, it remains unknown whether or not a locally proportional allocation on any undirected graph can be found using polynomial queries. Next, does there exist a simple locally proportional protocol for any given directed graph? The DiffuseDominance Protocol still works for directed graphs. However, the exchange operation in the CreateDominance Protocol fails, since it requires that agents who are prepared to exchange their pieces are able to see each other. Finally, a simple and discrete locally envy-free protocol still lacks even for special classes of graphs.