Cake Cutting is and is not a Piece of Cake

Cake Cutting is and is not a Piece of Cake

Jeff Edmonds, York UniversityKirk Pruhs, University of

Pittsburgh

Informal Problem StatementResource allocation between

n possibly deceitful players

Classic Problem Definition• n players wish to divide a cake • Each player p has an unknown value function

Vp

0 1

I like I like

= [0, 1]

Classic Problem Definition• n players wish to divide a cake • Each player p has an unknown value function

Vp

• Allowed Operations :– Eval[p, x, y]: returns how much player p

values piece/interval [x, y]

0 1

I like

= [0, 1]

x y

v

Classic Problem Definition• n players wish to divide a cake • Each player p has an unknown value function

Vp

• Allowed Operations :– Eval[p, x, y]: returns how much player p

values piece/interval [x, y] – Cut[p, x, v]: returns a y such Eval[p,x, y] = v

0 1

I like

= [0, 1]

yx

v

Classic Problem Definition• n players wish to divide a cake • Each player p has an unknown value function

Vp

• Goal: Fair cut Each honest player p is guaranteed a piece

of value at least 1/n.

0 1

I like

= [0, 1]

1/n

Classic Problem Definition• n players wish to divide a cake • Each player p has an unknown value function

Vp

• Goal: Fair cut Each honest player p is guaranteed a piece

of value at least 1/n.

0 1

= [0, 1]

I like

1/n

History

• Originated in 1940’s school of Polish mathematics

• Picked up by social scientists interested in fair allocation of resources

• Texts by Brams and Taylor, and Robertson and Webb

• A quick Google search reveals cake cutting is used as a teaching example in many algorithms courses

O(n log n) Divide and Conquer Algorithm: Evan and Paz

• Yp = cut(p, 0, 1/2) for p = 1 … n

I like

My half cut is here.

I like

My half cut is here.

O(n log n) Divide and Conquer Algorithm: Evan and Paz

• Yp = cut(p, 0, 1/2) for p = 1 … n

My half cut is here.

I like

O(n log n) Divide and Conquer Algorithm: Evan and Paz

• Yp = cut(p, 0, 1/2) for p = 1 … n

• m = median(y1, … , yn)

O(n log n) Divide and Conquer Algorithm: Evan and Paz

• Yp = cut(p, 0, 1/2) for p = 1 … n

• m = median(y1, … , yn)

• Recurse on [0, m] with those n/2 players p for which yp < m

• Recurse on [m, 1] with those n/2 players p for which yp > m

• Time O(nlogn)

so am happy with the left.

I like I like

so am happy with the right.

Problem Variations

• Contiguousness: Assigned pieces must be subintervals

• Approximate fairness: A protocol is c-fair if each player is a assured a piece that he gives a value of at least c/n

• Approximate queries (introduced by us?):– AEval[p, ε, x, y]: returns a value v such that

Vp[x, y]/(1+ε) ≤ v ≤ (1+ ε) Vp[x, y]– ACut[p, ε, x, v]: returns a y such

Vp[x, y]/(1+ε) ≤ v ≤ (1+ ε) Vp[x, y]

Problem Variations

Deterministic vs. Randomized

Exact vs. Approximate Queries

Exact vs. O(1) Fairness

Contiguous vs. General Pieces

Complexity = number of queries

Reference

* Exact * * O(n log n) Even and Paz 1984

* * Exact Contiguous Ω(n log n) Sgall and Woeginger 2003

Deterministic * * * Ω(n log n) Edmonds and Pruhs

* Approximate * * Ω(n log n) Edmonds and Pruhs

Randomized Exact Approximate General O(n) Edmonds and Pruhs*

* Submitted to STOC

(Approximate)

Outline

• Deterministic Ω(n log n) Lower Bound

• Randomized with Approximate Cuts Ω(n log n) Lower Bound

• Randomized with Exact Cuts O(n) Upper Bound

Thin-Rich Game• Game Definition:

Single player must find a thin rich piece.– A piece is thin if it has width ≤ 2/n

– A piece is rich if it has value ≥ 1/2n

• Theorem: The deterministic complexity of Thin-Rich is Ω(log n).

• Theorem: The deterministic complexity of cake cutting is Ω(nlog n).

–At least n/2 players require thin rich piece

Adv

I give sequence of Eval[x,y] & Cut[x,v]

operations.

I dynamically choose how to answer Alg

AdvAlg

I can choose any non-continuous

thin piece,but W.L.G.

I choose one of these.

I cut the cake in to n thin pieces.

AdvAlg

I build a complete 3-ary treewith the n pieces

as leaves

... ... ... ...

......

AdvAlg

For each node,I label edges

<½,¼,¼> or <¼,¼,½>

½¼ ¼½ ¼¼

... ... ... ...

......

AdvAlg

Value of each piece isproduct of edge labels

in path.

½¼ ¼½ ¼¼

... ... ... ...

......

½

¼

¼

¼¼

½1/1024 = ¼×¼×½×¼×¼×½

AdvAlg

½¼ ¼½ ¼¼

... ... ... ...

......

½

½

¼

¼¼

½

To get a rich pieceI need at least 40% of the edge labels

in path be ½.

Good luck

1/256 = ½×¼×½×¼×¼×½

AdvAlgCut[0,0.4398]?

I need to find a yso that

V[0,y] = 0.4398.

y0

0.4398

AdvAlgCut[0,0.4398]?

1/40 1/2 1

I do binary search to find0.4398

0.43980.4398

AdvAlgCut[0,0.4398]?

½¼ ¼1/42/4

0.4398

I do binary search to find0.4398

I fix some edge labels

AdvAlgCut[0,0.4398]?

½¼ ¼1/42/4

4/166/16

7/168/16

0.43980.4398

I do binary search to find0.4398

I fix some edge labels

AdvAlgCut[0,0.4398]?

½¼ ¼

I fix some edge labels

¼½ ¼7/16

0.4398

8/16

AdvAlgCut[0,0.4398]?

½¼ ¼¼½ ¼

½¼ ¼½¼ ¼

¼½ ¼

¼ ½¼

0.4398

I find a yso that

V[0,y] = 0.4398.

y

AdvAlgI learned a path,

but all its labels are ¼

½¼ ¼¼½ ¼

½¼ ¼½¼ ¼

¼½ ¼

¼ ½¼

Hee Hee

AdvAlg

½¼ ¼¼½ ¼

½¼ ¼½¼ ¼

¼½ ¼

¼ ½¼

Every path has one

known ½ label.

YesAfter t operations

every path has only t known ½ labels.

AdvAlg

½¼ ¼¼½ ¼

½¼ ¼½¼ ¼

¼½ ¼

¼ ½¼

Eval[x,y]

¼ ¼¼

¼¼

¼

x y

I fix labels in path to x & y to ¼.

and giveEval[x,y] = 0.00928

0.00928

AdvAlg

½¼ ¼¼½ ¼

½¼ ¼½¼ ¼

¼½ ¼

¼ ½¼

¼ ¼¼

¼¼

¼ ½

YesAfter t operations

every path has only t ½ known labels.

Deterministic Ω(log n) Lower Bound

• Theorem: To win at Thin-Rich, the alg has to get a rich piece with at least 40% of the edge labels in path be ½.

• Theorem: After t operations, every path has only t ½ labels.

• Theorem: The deterministic complexity of Thin-Rich is Ω(depth) =Ω(log n)

• Theorem: The deterministic complexity of Thin-Rich is Ω(log n).

• Theorem: The deterministic complexity of cake cutting is Ω(n log n).

–At least n/2 players require thin rich piece

Deterministic Ω(nlog n) Lower Bound

Outline

• Deterministic Ω(n log n) Lower Bound

• Randomized with Approximate Cuts Ω(n log n) Lower Bound

• Randomized with Exact Cuts O(n) Upper Bound

Done

Randomized Approximate Cuts

AdvRand Alg

I define a randomized algorithm

I must choose the value functions without knowing

coin flips

AdvRand Alg

I deterministically give sequence of

Eval[x,y] & Cut[x,v]operations.

I flip coins to choose value function.

I dynamically choose error in answers

RandAdv

Alg

Yau

I define a randomized algorithm

I must choose the value functions without knowing

coin flips

AdvRand

Alg

½¼ ¼½ ¼¼

... ... ... ...

......

For each node,I randomly label edges

<½,¼,¼>, <¼,½,¼>, or <¼,¼,½>

¼¼ ½

AdvAlg

Consider path to x and y.

Flip coins for labels.

33% of labels will be ½.

¼

¼

¼

¼

¼

½¼

¼

¼

¼

¼

½

½

¼

½

½

Eval[x,y]

But I need 40%!

x y

½ ¼

AdvAlgI flip coins for path to x’

and get 33% ½.

¼

¼

¼

¼

¼

½¼

¼

¼

¼

¼

½

½

¼

½

½

x y

½ ¼

Cut[x’,0.4398]?

x’

¼

¼

¼¼

¼

½

½

½

AdvAlg

I do binary search for 0.4398,

but for some odd reasonit finds 40% ½ labels.

¼

¼

¼

¼

¼

½¼

¼

¼

¼

¼

½

½

¼

½

½

x y

½ ¼

Cut[x’,0.4398]?

x’

¼

¼

¼¼

¼

½

½

½

½½

½¼

¼

AdvAlg

Luckily I can give error

and this hides most of the labels.

¼

¼

¼

¼

¼

½¼

¼

¼

¼

¼

½

½

¼

½

½

x y

½ ¼

Cut[x’,0.4398]?

x’

¼

¼

¼¼

¼

½

½

½

½½

½¼

¼

Outline

• Deterministic Ω(n log n) Lower Bound

• Randomized with Approximate Cuts Ω(n log n) Lower Bound

• Randomized with Exact Cuts O(n) Upper Bound

Done

Done

Randomized Exact CutsUpperO(n)

O(1) Complexity Randomized Protocol for Thin-Rich

Protocol Description:

• “Cuts” cake into n “candidate” pieces of value 1/n

• Randomly chooses one.• It is likely thin and rich.

Randomized Protocol for Cake Cutting

Protocol Description:• Each player randomly selects 2d candidate

pieces.• For each player, we carefully pick one of these

Randomized Protocol for Cake Cutting

Protocol Description:• Each player randomly selects O(1) candidate

pieces.• For each player, we carefully pick one of these

– so that every point of cake is covered by at most O(1) pieces.

• Where there is overlap, recurs.Works with O(1) probability.

Two Random Choices: n balls, n bins each ball randomly chooses two bins.Choice: Select one of two bins for each ball. Whp no bin has more than O(1) balls.

Balls and Bins

Two Random Choices: n balls, n bins each ball randomly chooses two bins.Choice: Select one of two bins for each ball. Whp no bin has more than O(1) balls.

Balls and Bins

Outline

• Deterministic Ω(n log n) Lower Bound

• Randomized with Approximate Cuts Ω(n log n) Lower Bound

• Randomized with Exact Cuts O(n) Upper Bound

Done

Done

More at STOC

A piece of cake.