Cake Cutting is and is not a Piece of Cake Jeff Edmonds, York University Kirk Pruhs, University of Pittsburgh Jaisingh Solanki, York University

Toronto Star

Informal Problem Statement Resource 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 V p 01 I like = [0, 1]

Classic Problem Definition n players wish to divide a cake Each player p has an unknown value function V p Allowed Operations : –Eval[p, x, y]: returns how much player p values piece/interval [x, y] 01 I like = [0, 1] xy v

Classic Problem Definition n players wish to divide a cake Each player p has an unknown value function V p 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 01 I like = [0, 1] y x v

Classic Problem Definition n players wish to divide a cake Each player p has an unknown value function V p Goal: Fair cut Each honest player p is guaranteed a piece of value at least 1 / n. 01 I like = [0, 1] 1/n1/n

Classic Problem Definition n players wish to divide a cake Each player p has an unknown value function V p Goal: Fair cut Each honest player p is guaranteed a piece of value at least 1 / n. 01 = [0, 1] I like 1/n1/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 and CMU CS

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 Stop I’ll take it. We did not like that 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 happy with the left. I like I’ll take the right.

O(n log n) Divide and Conquer Algorithm: Even and Paz Y p = 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 Y p = 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 Y p = cut(p, 0, 1 / 2 ) for p = 1 … n m = median(y 1, …, y n )

O(n log n) Divide and Conquer Algorithm: Even and Paz Y p = cut(p, 0, 1 / 2 ) for p = 1 … n m = median(y 1, …, y n ) Recurse on [0, m] with those n / 2 players p for which y p < m Recurse on [m, 1] with those n / 2 players p for which y p > m Time O(nlogn) so am happy with the left. 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 V p [x, y]/(1+ε) ≤ v ≤ (1+ ε) V p [x, y] –ACut[p, ε, x, v]: returns a y such V p [x, y]/(1+ε) ≤ v ≤ (1+ ε) V p [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 **ExactContiguousΩ(n log n) Sgall and Woeginger 2003 Deterministic***Ω(n log n) Edmonds and Pruhs *Approximate**Ω(n log n) Edmonds and Pruhs RandomizedExactApproximateGeneralO(n) Edmonds and Pruhs Edmonds and Solanki (Approximate) Open: Remove contiguous requirement for randomized alg failure prob O(1) vs 1/n O(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 function so after O(logn) operations Alg cant find a thin rich piece. Alg

Adv Alg 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.

Adv Alg I build a complete 3-ary tree with the n pieces as leaves...

Adv Alg For each node, I label edges or ½ ¼ ¼ ½ ¼ ¼...

Adv Alg Value of each piece is product of edge labels in path. ½ ¼ ¼ ½ ¼ ¼... ½ ¼ ¼ ¼ ¼ ½ 1 / 1024 = ¼×¼×½×¼×¼×½

Adv Alg ½ ¼ ¼ ½ ¼ ¼... ½ ½ ¼ ¼ ¼ ½ To get a rich piece I need at least 40% of the edge labels in path be ½. Good luck 1 / 256 = ½×¼×½×¼×¼×½

Adv Alg Cut[0,0.4398]? I need to find a y so that V[0,y] = y

Adv Alg Cut[0,0.4398]? 1/41/4 0 1/21/2 1 I do binary search to find

Adv Alg Cut[0,0.4398]? ½ ¼ ¼ 1/41/4 2/42/ I do binary search to find I fix some edge labels

Adv Alg Cut[0,0.4398]? ½ ¼ ¼ 1/41/4 2/42/4 4 / 16 6 / 16 7 / 16 8 / I do binary search to find I fix some edge labels

Adv Alg Cut[0,0.4398]? ½ ¼ ¼ ¼ ½ ¼ 7 / / 16 I do binary search to find I fix some edge labels

Adv Alg Cut[0,0.4398]? ½ ¼ ¼ ¼ ½ ¼ ½ ¼ ¼ 28 / / I do binary search to find I fix some edge labels

Adv Alg Cut[0,0.4398]? ½ ¼ ¼ ¼ ½ ¼ ½ ¼ ¼ ½ ¼ ¼ / / 256 I do binary search to find I fix some edge labels

Adv Alg Cut[0,0.4398]? ½ ¼ ¼ ¼ ½ ¼ ½ ¼ ¼ ½ ¼ ¼ ¼ ½ ¼ 450 / / I do binary search to find I fix some edge labels

Adv Alg Cut[0,0.4398]? ½ ¼ ¼ ¼ ½ ¼ ½ ¼ ¼ ½ ¼ ¼ ¼ ½ ¼ ¼ ½ ¼ / / 4096 I do binary search to find I fix some edge labels

Adv Alg Cut[0,0.4398]? ½ ¼ ¼ ¼ ½ ¼ ½ ¼ ¼ ½ ¼ ¼ ¼ ½ ¼ ¼ ½ ¼ I find a y so that V[0,y] = y

Adv Alg I learned a path, but all its labels are ¼ ½ ¼ ¼ ¼ ½ ¼ ½ ¼ ¼ ½ ¼ ¼ ¼ ½ ¼ ¼ ½ ¼ Hee

Adv Alg ½ ¼ ¼ ¼ ½ ¼ ½ ¼ ¼ ½ ¼ ¼ ¼ ½ ¼ ¼ ½ ¼ Every path has  one known ½ label. Yes After t operations every path has only  t known ½ labels.

Adv Alg ½ ¼ ¼ ¼ ½ ¼ ½ ¼ ¼ ½ ¼ ¼ ¼ ½ ¼ ¼ ½ ¼ Eval[x,y] ¼ ¼ ¼ ¼ ¼ ¼ x y I fix labels in path to x & y to ¼. and give Eval[x,y] =

Adv Alg ½ ¼ ¼ ¼ ½ ¼ ½ ¼ ¼ ½ ¼ ¼ ¼ ½ ¼ ¼ ½ ¼ ¼ ¼ ¼ ¼ ¼ ¼ ½ Yes After t operations every path has only  t ½ known labels. That is bad. To get a rich piece I 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 RandomizedApproximate Cuts

Adv Rand 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

Adv Rand 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. Rand Adv Alg Yao I must choose the value functions Show after O(nlogn) operations Alg fails whp.

Adv Rand Alg ½ ¼ ¼ ½ ¼ ¼... For each node, I randomly label edges,, or ¼ ¼ ½

Adv Alg Consider path to x and y. Flip coins for labels. 33% of labels will be ½. ¼ ¼ ¼ ¼ ¼ ½ ¼ ¼ ¼ ¼ ¼ ½ ½ ¼ ½ ½ Eval[x,y] But I need 40%! x y ½ ¼

Adv Alg I flip coins for path to x’ and get 33% ½. ¼ ¼ ¼ ¼ ¼ ½ ¼ ¼ ¼ ¼ ¼ ½ ½ ¼ ½ ½ x y ½ ¼ Cut[x’,0.4398]? x’ ¼ ¼ ¼ ¼ ¼ ½ ½ ½

Adv Alg I do binary search for , but for some odd reason it finds 40% ½ labels. ¼ ¼ ¼ ¼ ¼ ½ ¼ ¼ ¼ ¼ ¼ ½ ½ ¼ ½ ½ x y ½ ¼ Cut[x’,0.4398]? x’ ¼ ¼ ¼ ¼ ¼ ½ ½ ½ ½ ½ ½ ¼ ¼

Adv Alg 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 RandomizedExact Cuts Upper O(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/n O(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

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) 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

Another Difficulty: Edges May Not be Independent 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) = n 3 × 1 / n × 1 / n =  (n) Choose 2 candidate pieces Exp(# of Vees) = n 3 × 1 / n × 1 =  (n 2 ) Vee

Example: Too many Vees Choose 2 candidate pieces Exp(# of Vees) = n 3 × 1 / n × 1 =  (n 2 ) n/2n/2 n/2n/2 Vee

Example: Too many Vees Choose 2 candidate pieces Exp(# of Vees) = n 3 × 1 / n × 1 =  (n 2 ) Choose 8 candidate pieces Exp(# of Vees) = … =  (n) n/2n/2 n/2n/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 **ExactContiguousΩ(n log n) Sgall and Woeginger 2003 Deterministic***Ω(n log n) Edmonds and Pruhs *Approximate**Ω(n log n) Edmonds and Pruhs RandomizedExactApproximateGeneralO(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 P i. If so P i is “bad”. Conclusions Run the algorithm twice, independently. Each player stays in one run in which it is “good”. Pr[P i is bad in both runs] = O(1/n 2 ) Pr[Some player is bad in both runs] = n × O(1/n 2 )

Conclusions For each run, each of its good players can 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.

Conclusions Theorem: Alg fails with prob O(1/n). Theorem: Alg fails k times with prob O(1/n k ). 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 Statement Resource allocation between n self-interested players

Adv Rand 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) operations Alg fails whp.

Adv Rand 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) operations Alg fails whp. Rand Adv 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) operations Alg fails whp.

O(1) Complexity Randomized Protocol for Thin-Rich For i=0…n, x i = 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) = n 3 × 1 / n × 1/n =  (n) n/2n/2 Exp(# of Vees) =  (1) ×  (n 2 ) n/2n/2

Example: Too many Vees If independent, Exp(# of Vees) = n 3 × 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.