cake cutting is and is not a piece of cake jeff edmonds, york university kirk pruhs, university of...

Cake Cutting is and is not a Piece of Cake

Jeff Edmonds, York UniversityKirk Pruhs, University of Pittsburgh

Jaisingh Solanki, York University

Toronto Star

Informal Problem StatementResource allocation between n self 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

• The subject of a handful of books (e.g Brams and Taylor, and Robertson and Webb) and many papers

• A quick Google search reveals cake cutting is used as a teaching example in many algorithms courses, e.g CMU CS 15-451 and CMU CS 15-750

Continuous Moving Knife Algorithm

• Protocol moves the knife continuously across the cake until the some player say stop.

• This player gets this piece.• The rest of the players continue

StopI’ll take it.

We did not likethat piece anyway.•Moving knife

considered cheating by discrete alg.We do not consider them here.

Classic Alg: Cut and Choose (n=2)

• Person A cuts the cake into two pieces• Person B selects one of the two pieces,

and person A gets the other piece Careful.

I like

My half cut is here.I am a little jealous

but I am happywith the left.

I like

I’ll take the right.

O(n log n) Divide and Conquer Algorithm: Even 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: Even 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: Even and Paz

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

• m = median(y1, … , yn)

O(n log n) Divide and Conquer Algorithm: Even 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

Edmonds and Solanki

(Approximate)

Open: Remove contiguous requirement for randomized alg

failure prob O(1) vs 1/nO(1)

Outline

• Deterministic Ω(n log n) Lower Bound– Definition of Thin-Rich Problem– Ω(log n) lower bound for Thin-Rich

• 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.

Oh!

I dynamically choose how to answer

and the value functionso after O(logn) operations

Alg cant find a thin rich piece.

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]?

½¼ ¼¼½ ¼

7/16

0.4398

8/16

I do binary search to find0.4398

I fix some edge labels

AdvAlgCut[0,0.4398]?

½¼ ¼¼½ ¼

½¼ ¼28/6429/64

0.4398

I do binary search to find0.4398

I fix some edge labels

AdvAlgCut[0,0.4398]?

½¼ ¼¼½ ¼

½¼ ¼½¼ ¼

0.4398

112/256113/256

I do binary search to find0.4398

I fix some edge labels

AdvAlgCut[0,0.4398]?

½¼ ¼¼½ ¼

½¼ ¼½¼ ¼

¼½ ¼450/1024

451/1024

0.4398

I do binary search to find0.4398

I fix some edge labels

AdvAlgCut[0,0.4398]?

½¼ ¼¼½ ¼

½¼ ¼½¼ ¼

¼½ ¼

¼ ½¼

0.4398

1800/40961801/4096

I do binary search to find0.4398

I fix some edge labels

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.

That is bad.To get a rich pieceI need at least 40% of the edge labels

in path be ½.

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

Show after O(nlogn) operations Alg fails whp.

I flip coins to give sequence of

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

i.e. not dynamically

AdvRand Alg

I define a randomized algorithm

I flip coins to give sequence of

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

I deterministically give sequence of

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

I specify a distribution on value functions.

I flip coins.Show after O(nlogn)

operations Alg fails whp.

RandAdv

Alg

Yao

I must choose the value functions

Show after O(nlogn) operations Alg fails whp.

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)

Outline

• Randomized with O(n) Upper Bound– As intuition for the power of randomness, give

a randomized algorithm for Thin-Rich with O(1) complexity

– Describe “Balls and Bins” special case of cake cutting

– Give “random graph” proof of “Balls and Bins” case

– Give the flavor of the “random graph” proof for Cake Cutting

– Decrease failure probability

Thin-Rich Game• Game Definition:

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

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

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

• Theorem: The randomized complexity of Thin-Rich is O(1).

• Must make sure the player’s thin pieces don’t over lap too much.

1. Pick an i uniformly at random from 1 … 3n

2. x = Cut[0,(i-1)/3n]

3. y = Cut[ 0, i/3n]

4. Return [x,y]value = 1/3n (ie rich)

Exp(width) = 1/3n << 3/n (ie thin)

O(1) Complexity Randomized Protocol for Thin-Rich

i

x=(i-1)/3n y=i/3n

3n Candidate Pieces

Randomized Protocol for Cake Cutting

Protocol Description:• Each player randomly selects 8 candidate

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

Randomized Protocol for Cake Cutting

Protocol Description:• Each player randomly selects 8 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.Fails with probability 0(1).1/nO(1).

O(1)

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

balls.

Balls and Bins

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

balls.

O(loglogn) balls per bin

Balls and Bins

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

balls.Offline: Whp no bin has more than O(1) balls.

O(1) balls per bin

Balls and Bins

• Consider a graph G– Vertices = bins– One edge for each ball connecting the

corresponding vertices– Important: Edges are independent

• Lemma: If G is acyclic then the maximum load is 1

Proof on Offline: O(1)-Balls

• Classic Theorem: If a graph G has n/3 independent edges, then G is acyclic with prob.

• Proof: Prob[G contains a cycle C]

≤ ΣC Prob[C is in the graph] ~ Σi (n choose i) * (1/3n)i

= (1).

Proof on Offline: O(1)-Balls

Cake Protocol Ball & Bin Game Same if• Each player has uniform value on cake, so all candidate pieces are the same.• Each player randomly selects 2 (or 8)

candidate pieces.• For each player, pick one of these.• O(1) over lap = O(1) balls per bin

Cake Protocol Ball & Bin Game Different if• Different cake values can make strangely overlapping candidate

pieces.

I like I like I like

Cake Protocol Ball & Bin Game Different if• Different cake values can make strangely overlapping candidate

pieces.

Cake Protocol Ball & Bin Game Different if• Different cake values can make strangely overlapping candidate

pieces.

Directed Graph for Cake Cutting (choose 2 not 8 candidate peices)

VertexVertex

Vertex Vertex

If take

Can’t take Must take

One Difficulty

Theorem: Sufficient Condition • If there is not directed path between

the two pieces of the same person• then maximum load is at most 1

If take

Must take

Must take

Must take

Another Difficulty:

Edges May Not be Independent

VertexVertex

Vertex Vertex

Vertex Vertex

Theorem: If we select 8 candidate pieces

and narrow these down to 2,

then likely, there are not many dependent edges.

Example: Too many Vees

•If independent,

•Exp(# of Vees) = n3 × 1/n × 1/n = (n)

•Choose 2 candidate pieces

•Exp(# of Vees) = n3 × 1/n × 1 = (n2)

Vee

Example: Too many Vees

•Choose 2 candidate pieces

•Exp(# of Vees) = n3 × 1/n × 1 = (n2)

n/2

n/2

Vee

Example: Too many Vees

•Choose 2 candidate pieces

•Exp(# of Vees) = n3 × 1/n × 1 = (n2)

•Choose 8 candidate pieces•Exp(# of Vees) = … = (n)

n/2

n/2

and narrow these down to 2

Vee

Too many Self Paths

Independent

•If independent, •Exp(# of self paths) = like in balls & bins = (1)

•Choose 2 candidate pieces •Exp(# of self paths) = (n)

•Choose 8 candidate pieces and narrow these down to 2•Exp(# of self paths) = … = (1)

Vee

Prob(none) (1)

Theorem: With O(1) probability,there is not directed path between the two pieces of the same person

Conclusions

For each player, can pick one of these 8.• so that every point of cake

is covered by at most O(1) pieces. Where there is overlap, recurs.

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

Edmonds and Solanki

(Approximate)

failure prob (1) vs 1/n(1)

A piece of cake.

Theorem: With O(1/n) probability,there is not directed path between the two pieces of player Pi. If so Pi is “bad”.

Conclusions

Run the algorithm twice, independently. Each player stays in one run in which it is

“good”.Pr[Pi is bad in both runs] = O(1/n2)

Pr[Some player is bad in both runs] = n × O(1/n2)

Conclusions

For each run, each of its good playerscan pick one of these 8 so that every point of cake is covered by at most O(1) pieces.

Run 1

Run 2

Theorem: With O(1/n) probability,each run has no bad directed paths.

Where there is overlap, recurs.

ConclusionsTheorem: Alg fails with prob O(1/n).

Theorem: Alg fails k times with prob O(1/nk).

Repeat k times.

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

Skipped

Done

A piece of cake.

Future Directions

• Determine whether randomization makes sense with cheaters

• The complexity of several variations of fair division is still not completely nailed down

• Complexity of envy free division is quite wide open– Exponential difference in upper and

lower bounds– Current project

End

Informal Problem StatementResource allocation between

n self-interested players

AdvRand Alg

I flip coins to give sequence of

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

I dynamically choose error in answers

so after O(nlogn) operationsAlg fails whp.

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

so after O(nlogn) operationsAlg fails whp.

RandAdv

Alg

Yao

I flip coins to give sequence of

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

I dynamically choose error in answers

so after O(nlogn) operationsAlg fails whp.

O(1) Complexity Randomized Protocol for Thin-Rich

For i=0…n, xi = Cut[0,i/n], Cuts cake into n “candidate” pieces.

Each piece has value 1/n for player.

Different widths, but average is 1/n.

We will choose a random one for player. It is likely has width 2/n.

i.e. thin and rich. Constant time?

Example: Too many Vees

Exp(# of Vees) = n3 × 1/n × 1/n = (n)

n/2

Exp(# of Vees) = (1) × (n2)

n/2

Example: Too many Vees

If independent,

Exp(# of Vees) = n3 × 1/n × 1/n = (n)

Another Difficulty:

Forks

Fork of depth 3

Theorem: If we select 2d candidate pieces

and narrow these down to 2,

then likely, there are none of these.