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

2. Informal Problem Statement n self interested players wish to divide items of value such that each player believes that they received at least 1/n of the value Players may not agree on the values of items Players may be deceitful, cunning, dishonest, etc.

3. An Instance of Cake Cutting From History

4. A Politically Incorrect Reference to Cake Cutting

5. Classic Problem Definition n players wish to divide a cake = [0, 1] Each player p has an unknown value function V p V p [x, y] = how much player p values piece/interval [x, y] The protocol’s goal is Fairness: Each honest player p is guaranteed a piece of cake of value at least V p [0,1]/n = 1/n

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

7. Classic Two Person Discrete Algorithm (n=2): Cut and Choose Person A cuts the cake into two pieces Person B selects one of the two pieces, and person A gets the other piece

8. Two Person Continuous Algorithm (n=2): Moving Knife Protocol moves the knife continuously across the cake until the first player say stop This player gets this piece, and the rest of the players continue Moving knife algorithms are considered cheating by discrete algorithmic researchers and we do not consider them here

9. Formalizing Allowed Operations Queries the protocol can make to each player: Eval[p, x, y]: returns V p [x, y] Cut[p, x, v]: returns a y such V p [x, y] = v All know algorithms can be implemented with these operations

10. Two Person Algorithm (n=2): Cut and Choose y = cut(A, 0, ½) If eval(B, 0, y) ≤ ½ then Player A gets [0, y] and player B gets [y, 1] Else Player B gets [0, y] and player A gets [y, 1]

11. Three Person Algorithm (n=3): Steinhaus Y A = cut(A, 0, 1/3) Y B = cut(B, 0, 1/3) Y C = cut(C, 0, 1/3) Assume wlog Y A ≤ Y B ≤ Y C Player A gets [0, y A ], and players B and C “cut and choose” on [y A, 1]

12. O(n log n) Divide and Conquer Algorithm: Evan and Paz Y i = cut(i, 0, 1/2) for i = 1 … n m = median(y 1, …, y n ) Recurse on [0, m] with those n/2 players i for which y i < m Recurse on [m, 1] with those n/2 players i for which y i > m

13. 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]

14. 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* * The proof is currently only roughly written up at this point

15. Outline Deterministic Ω(n log n) Lower Bound Definition of Thin-Rich game Sufficiency to lower bound Thin-Rich Definition of value tree cakes Lower bound for Thin-Rich Hint at Randomized Ω(n log n) Lower Bound with Approximate Cuts Randomized O(n) Upper Bound

16. Thin-Rich Game Game Definition: Find a thin rich piece for a particular player A piece is thin if it has width ≤ 2/n A piece is rich if it has value ≥ 1/2n Theorem: The complexity of cake cutting is at least n/2 times the complexity of thin-rich Proof: In cake cutting, at least n/2 players have to end up with a thin rich piece

17. Value Tree ½*¼ ½*½¼*¼¼*½¼*¼ ¼*½¼*¼ 1/2 1/4 1/2 1/4 1/2 1/4 1/2 1/4 0 1/9 2/9 3/9 4/9 5/9 6/9 7/9 8/9 1 Value = Product of edge labels

18. Deterministic Ω(log n) Lower Bound for Thin-Rich Theorem: To win at Thin-Rich, when the input is derived from a value tree, the protocol has to find a leaf where at least 40% of the edge labels on root to leaf path are ½ Theorem: From each query, the protocol learns the edge labels on at most two root to leaf paths Theorem: The deterministic complexity of Thin-Rich is Ω(log n) Proof: Reveal edges with label ¼ on the two paths learned by the protocol

19. Randomized Lower Bound Theorem: From each approximate query, the protocol learns the edge labels on at most two root to leaf paths, and at most one constant depth triangle Theorem: The randomized complexity of thin-rich with approximate queries is Ω(log n) Proof: Use Yao’s technique. For each vertex in the value tree, uniformly at random pick the edge to label ½. The expected number of labels of ½ on all known labeled paths after k queries is O( (log 3 n)/3 + k)

20. Outline Deterministic Ω(n log n) Lower Bound Hint at Randomized Ω(n log n) Lower Bound with Approximate Cuts Randomized O(n) Upper Bound O(1) complexity randomized protocol for Thin-Rich Cake cutting algorithm Generalized offline power of two choices lemma Non-independent random graph model

21. O(1) Complexity Randomized Protocol for for Thin-Rich 1. Pick an i uniformly at random from 0 … n-1 2. x = Cut[0, i/n] 3. y = Cut[ 0, (i+1)/n] 4. If (y-x) ≤ 2/n then return piece [x, y] 5. Else goto step 1

22. Randomized Protocol for Cake Cutting Protocol Description: Each player repeatedly applies randomized thin-rich protocol to get 2d pieces For each player, pick one of the two tentative pieces in such a way that every point of cake is covered by at most O(1) pieces. If this is not possible, then start over again. Theorem: This protocol is approximately fair We need to show that the second step of the protocol is successful with probability Ω(1)

23. Digression(1) Power of Two Choices Setting: n balls, each of which can be put into two of n bins that are selected independently uniformly at random Online Theorem: The online greedy assignment guarantees maximum load of O(log log n) whp Offline Theorem: There is an assignment with maximum load O(1) whp

24. Digression(2): Proof of Offline Power of Two Choices Theorem 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 Classic Theorem: If a graph G has n/3 independent edges, then G is acyclic whp Proof: Union Bound. Prob[G contains a cycle C] ≤ Σ C Prob[C is in the graph] ~ Σ i (n choose i) * (1/3n) i

25. Key Theorem for O(n) Bound: Generalized Offline Balls and Bins Each of n players arbitrarily partition [0, 1] into n pieces Each player picks uniformly at random 2*d pieces Then with probability Ω(1), we can assign to each player one of its 2*d pieces so that every point is covered by at most O(1) pieces This is equivalent to offline balls and bins if the partition is into equal sized pieces, except that: We may need d > 1, and We don’t get high probability bound

26. Why a High Probability result is Not Achievable...... Probability of overlap of k ~ (n choose k) / n k

27. Problem Case: Forks Theorem: With probability Ω(1) there is no fork of depth ω(1) Therefore we throw out forked paths, and proceed Fork of depth 3

28. Directed Graph for Cake Cutting (d=1) picked Vertex

29. Sufficiency Condition Theorem: The maximum load is at most 1 if there is not directed path between the two pieces of the same person

30. One Difficulty: Edges May Not be Independent

31. Dealing with Dependent Edges Lemma: There are not many dependent edges Lemma: Each possible path, between two pieces of the same player, can have at most two dependent edges Lemma: With probability Ω(1) there is no path between two pieces of the same player

32. Conclusions Generalized offline balls and bins theorem may be useful elsewhere The model of random graphs, where there are some dependencies on the edges, and our analysis may be useful elsewhere Is dependent random graph model novel ?