COMSOC 05 Cake 2

The Robertson-Webb Model
What counts as a “protocol”? — A reasonable protocol should be implementable in

terms of just two types of queries:
Robert Bredereck Computational Social Choice

16

cuti (x, α) 7→ y : Ask agent i to cut off a piece of value α, starting from point x (she
cuts at point y ).
[J. Robertson and W. Webb. Cake-Cutting Algorithms. A.K. Peters, 1998.]

16

cuts at point y ).
evali (x, y ) 7→ α: Ask agent i to indicate her value for the piece between points x
and y (she answers α).

16

cuts at point y ).
evali (x, y ) 7→ α: Ask agent i to indicate her value for the piece between points x
and y (she answers α).
Now we can count queries and compare the complexity of protocols.

16
Simulating the Moving-Knife Protocol
Can we “discretise” the moving-knife protocol to solve our problem?

PAUSE now to think four yourself

17
1. Ask each agent to mark the cake where she would shout “stop”. Then cut the cake
at the leftmost mark and give the resulting piece to the agent who made that mark.

17
2. When a piece has been cut off, we continue with the remaining agents, until just
one agent is left (who takes the rest).

17
Formally, the marks are cut-queries. No evaluation-queries needed.

17
Formally, the marks are cut-queries. No evaluation-queries needed.
Task
How complex (#queries) is this?
PAUSE now to think four yourself

17
Complexity Analysis: Number of Marks
In each round, each participating agent makes one mark. The number of participating
agents goes down from n to 2. Thus:

18
n · (n − 1)
n + (n − 1) + (n − 2) + · · · + 3 + 2 = − 1 = O(n2 )
2

18
n · (n − 1)
n + (n − 1) + (n − 2) + · · · + 3 + 2 = − 1 = O(n2 )
2
| | | | | |
(Illustration on the whiteboard) | | | | | Can we do better?
| | | |
| | |
| |
|
18
The Even-Paz Divide-and-Conquer Protocol
Even and Paz (1984) introduced the divide-and-conquer protocol:
1. Ask each agent to put a mark on the cake.

19
2. Cut the cake at the ⌊ n2 ⌋th mark (from the left). Associate the agents who made the
leftmost ⌊ n2 ⌋ marks with the lefthand part, and the remaining agents with the
righthand part.

19
righthand part.
3. Repeat for each group, until only one agent is left.

19
righthand part.
[S. Even and A. Paz. A Note on Cake Cutting. Discrete Applied Mathematics, 7(3):285–296, 1984.]
Intuitively, each agents marks the point where the cake

is split into two pieces of equal value.

19
righthand part.
Belle Chris
David Edgar
1 2 3 4 5 6 7 1 2 3 4 5 6 7 1 2 3 4 5 6 7 1 2 3 4 5 6 7

19
righthand part.
Belle Edgar
Chris David
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
��
1 2 3 4 5 6 7 1 2 3 4 5 6 7
��
��
1 2 3 4 5 6 7 1 2 3 4 5 6 7
(a) Belle cuts, Edgar chooses
Robert Bredereck (b) Chris cuts, Computational
David choosesSocial Choice
19
righthand part.
Which kind of queries do we need?

19
righthand part.
Again, we only require cut-queries.

19
righthand part.

Proportionally fair?

19
righthand part.

Homework
Strategy-proof?

19
righthand part.

Strategy-proof?
Task
How complex (#queries) is this?
19
In each round, every agent makes one mark.
⇒ n marks per round

20
But how many rounds?

20

20
rounds = number of times you can divide n by 2 before reaching 1

⇒ log2 n

20
rounds = number of times you can divide n by 2 before reaching 1

⇒ log2 n
=⇒ number of marks required = O(n · log n)
20
Comparison and Limitations
Recall: simulated moving-knife requires O(n2 ) marks and divide-and-conquer requires
O(n · log n) marks.
n log n
1,500
n2
1,000
500
0
0 10 20 30 40

21
n log n
1,500
n2
1,000
500
0
0 10 20 30 40
Can we do better?

21
n log n
1,500
n2
1,000
500
0
0 10 20 30 40
Can we do better?
Theorem (Edmonds and Pruhs, 2006)
Any proportionally fair protocol requires Ω(n log n) Robertson-Webb queries. [J.
Edmonds and K. Pruhs. Cake cutting really is not a piece of cake. SODA-2006.]
Proof : Next slides.
21
A Lower Bound on the Number of Queries I
Any proportionally fair protocol requires Ω(n log n) Robertson-Webb queries.

22
Basic Idea: To compute a proportional allocation, one has to solve a much simpler
problem for many agents (individually):

22
The Thin-Rich Problem
Given an agent i, we say a piece X is thin, if ℓ(X ) ≤ 2/n and rich if vi (X ) ≥ 1/n,
where ℓ(X ) is the total length of the piece. Given an agent’s valuation function, the
Thin-Rich problem is to find a piece that is both, thin and rich.

22
The Thin-Rich Problem
Given an agent i, we say a piece X is thin, if ℓ(X ) ≤ 2/n and rich if vi (X ) ≥ 1/n,
where ℓ(X ) is the total length of the piece. Given an agent’s valuation function, the
Thin-Rich problem is to find a piece that is both, thin and rich.
Lemma
If the complexity (in the Robertson-Webb model) of the Thin-Rich problem is T (n),
then the complexity of finding a proportional allocation is Ω(n · T (n)).
Proof : (Whiteboard)
22
A Lower Bound on the Number of Queries II
Further simplification:
without loss of generality: n/2 is a power of 3

23
divide the cake into n/2 disjoint intervals of length 2/n each

23
restrict on valuation function represented by so-called value trees

23
Value Tree
A rooted complete ternary tree (exactly three children per non-leaf):

23
Value Tree
a leaf corresponds to one of the n/2 disjoint intervals (see above)

23
Value Tree
internal node corresponds to the union of the intervals at the leaves of the subtree
rooted at that node (edge labels tell us how the value is split between its children)

23
Value Tree
for each internal node two of the edges to its children are labeled by 1/4 (light
edges), and the third is labeled by 1/2 (heavy edge)

23
Value Tree
for each internal node two of the edges to its children are labeled by 1/4 (light
edges), and the third is labeled by 1/2 (heavy edge)
=⇒ the value of the interval (uniformly distributed on the interval) that corresponds
to a node u is the product of the weights on the path from the root to u.
23
A Lower Bound on the Number of Queries III 1 1 1
2 4 4
Idea
Use value-tree based valuation functions as 1
4
1
2
1
4
1
4
1
4
1
2
1
4
1
4
1
2
lower-bound adversary for the Thin-Rich

problem. 1 2 3 4 5 6 7 8
0 9 9 9 9 9 9 9 9 1

24
2 4 4
Idea
4
1
2
1
4
1
4
1
4
1
2
1
4
1
4
1
2

problem. 1 2 3 4 5 6 7 8
0 1
Problem 9 9 9 9 9 9 9 9
In general an algorithm can return a piece of cake that does not correspond to a leaf
of the value tree, or even a union of such leaves. However,...

24
2 4 4
Idea
4
1
2
1
4
1
4
1
4
1
2
1
4
1
4
1
2

problem. 1 2 3 4 5 6 7 8
0 1
Problem 9 9 9 9 9 9 9 9
In general an algorithm can return a piece of cake that does not correspond to a leaf
of the value tree, or even a union of such leaves. However,...
Lemma
When the valuation function is derived from a value tree, if there exists a
T (n)-complexity algorithm for the Thin-Rich problem in the Robertson-Webb model,
then there exists an O(T (n))-complexity algorithm that returns a Thin-Rich leaf of
the value tree.
24
2 4 4
Idea
4
1
2
1
4
1
4
1
4
1
2
1
4
1
4
1
2

problem. 1 2 3 4 5 6 7 8
0 1
Lemma 9 9 9 9 9 9 9 9
When the valuation function is derived from a value tree, if there exists a
T (n)-complexity algorithm for the Thin-Rich problem in the Robertson-Webb model,
then there exists an O(T (n))-complexity algorithm that returns a Thin-Rich leaf of
the value tree.
=⇒ show that any algorithm for the Thin-Rich problem that is constrained to return a
(rich) leaf of the value tree requires Ω(log n) queries

24
A Lower Bound on the Number of Queries IV
Intuitively, the path from the root to a rich leaf has “many” heavy edges.

25
To find out exactly how many, note that the height of the tree is
H = log3 (n/2) = Θ(log(n)). Denoting the number of heavy edges on the path from
the root to a leaf u by q(u), we have

25
q(u) H−q(u) H−q(u)/2
1 1 1 1
= v (u) = · =
n 2 4 4

25
1 1 1 1
= v (u) = · =
n 2 4 4
It follows that 4H−q(u)/2 ≤ n, and hence 2(H − q(u)/2) ≤ log n. Using the fact that
2H − log n = Ω(log n) we conclude that q(u) = Ω(log n). In other words, a constant
fraction of the edges on the path to u must be heavy.

25
1 1 1 1
= v (u) = · =
n 2 4 4
Remark
If the algorithm was only allowed to directly query edge lables, then a lower bound of
Ω(log n) follows immediately.
25
1 1 1 1
= v (u) = · =
n 2 4 4
Remark
If the algorithm was only allowed to directly query edge lables, then a lower bound of
Ω(log n) follows immediately.
However, we use the Robertson-Webb model, ... 25
A Lower Bound on the Number of Queries V
We say that a node u is revealed if the weights of all edges of every node on the path
from the root to u are known to the algorithm.

26
For any revealed node u, the value v (u) of the interval of cake under it can be
computed.

26
computed.
Let u be a revealed node, let x be the leftmost point in u, and y the rightmost
point in u. Then, v (0, x) and v (0, y ) can be computed.

26
computed.
Let x be a point in a revealed leaf u, and let y ≥ x be a point in a revealed leaf v .
Then, v (0, x) and v (x, y ) can be computed.

26
computed.
Let u be a revealed leaf, let x1 be a point in u, and let α be a cake value. From this
information, the least common ancestor of u and the node v that contains the
point x2 satisfying v (x1 , x2 ) = α can be computed.

26
computed.
Let u be a revealed leaf, let x1 be a point in u, and let α be a cake value. From this
information, the least common ancestor of u and the node v that contains the
point x2 satisfying v (x1 , x2 ) = α can be computed.
Idea: Simulate Robertson-Webb queries by “revealing” sufficient nodes from the value
tree.
26
A Lower Bound on the Number of Queries VI
Lemma
Any algorithm for the Thin-Rich problem that is constrained to return a (rich) leaf of
the value tree requires Ω(log n) queries.

27
Lemma
Proof Idea : After k queries, there are at most 2k edges that are known to be heavy on any
path from the root to a leaf. Because we have shown that Ω(log n) edges on the path must be
known to be heavy, the theorem will directly follow. Initially the invariant trivially holds. In
each step, at most two heavy edges are revealed.

27
Lemma
Proof Idea : After k queries, there are at most 2k edges that are known to be heavy on any
path from the root to a leaf. Because we have shown that Ω(log n) edges on the path must be
known to be heavy, the theorem will directly follow. Initially the invariant trivially holds. In
each step, at most two heavy edges are revealed.
Homework: What about cut?
eval(x,y)
u v
Robert Bredereck
x y Computational Social Choice
27

COMSOC 05 Cake 2

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

COMSOC 05 Cake 2

Uploaded by

Copyright:

Available Formats

The Robertson-Webb Model

What counts as a “protocol”? — A reasonable protocol should be implementable in

Robert Bredereck Computational Social Choice

What counts as a “protocol”? — A reasonable protocol should be implementable in

[J. Robertson and W. Webb. Cake-Cutting Algorithms. A.K. Peters, 1998.]

Robert Bredereck Computational Social Choice

What counts as a “protocol”? — A reasonable protocol should be implementable in

Robert Bredereck Computational Social Choice

What counts as a “protocol”? — A reasonable protocol should be implementable in

Now we can count queries and compare the complexity of protocols.

Robert Bredereck Computational Social Choice

Can we “discretise” the moving-knife protocol to solve our problem?

Robert Bredereck Computational Social Choice

Can we “discretise” the moving-knife protocol to solve our problem?

Robert Bredereck Computational Social Choice

Can we “discretise” the moving-knife protocol to solve our problem?

Robert Bredereck Computational Social Choice

Can we “discretise” the moving-knife protocol to solve our problem?

Formally, the marks are cut-queries. No evaluation-queries needed.

Robert Bredereck Computational Social Choice

Can we “discretise” the moving-knife protocol to solve our problem?

Formally, the marks are cut-queries. No evaluation-queries needed.

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Intuitively, each agents marks the point where the cake

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Which kind of queries do we need?

Robert Bredereck Computational Social Choice

Again, we only require cut-queries.

Robert Bredereck Computational Social Choice

Again, we only require cut-queries.

Robert Bredereck Computational Social Choice

Again, we only require cut-queries.

Robert Bredereck Computational Social Choice

Again, we only require cut-queries.

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

rounds = number of times you can divide n by 2 before reaching 1

Robert Bredereck Computational Social Choice

rounds = number of times you can divide n by 2 before reaching 1

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

Robert Bredereck Computational Social Choice

lower-bound adversary for the Thin-Rich

Robert Bredereck Computational Social Choice

lower-bound adversary for the Thin-Rich

Robert Bredereck Computational Social Choice