Cake Malik Magdon-Ismail Costas Busch M. S. Krishnamoorthy - PowerPoint PPT Presentation

Cake Cutting is Not a Piece of Cake Malik Magdon-Ismail Costas Busch M. S. Krishnamoorthy Rensselaer Polytechnic Institute

users wish to share a cake N 1 th of cake Fair portion : N

The problem is interesting when people have different preferences Example: Meg Prefers Tom Prefers Yellow Fish Cat Fish

Happy Happy CUT Meg’s Piece Tom’s Piece Meg Prefers Tom Prefers Yellow Fish Cat Fish

Unhappy Unhappy CUT Tom’s Piece Meg’s Piece Meg Prefers Tom Prefers Yellow Fish Cat Fish

The cake represents some resource: • Property which will be shared or divided • The Bandwidth of a communication line • Time sharing of a multiprocessor

Fair Cake-Cutting Algorithms: • Each user gets what she considers to be th of the cake 1 / N • Specify how each user cuts the cake •The algorithm doesn’t need to know the user’s preferences

For users it is known how to divide N the cake fairly with cuts O ( N log N ) Steinhaus 1948: “The problem of fair division” It is not known if we can do better than cuts O ( N log N )

Our contribution:  We show that cuts are required ( N log N ) for the following classes of algorithms: • Phased Algorithms (many algorithms) • Labeled Algorithms (all known algorithms)

Our contribution: 2 We show that cuts are required  ( N ) for special cases of envy-free algorithms: Each user feels she gets more than the other users

Talk Outline Cake Cutting Algorithms Lower Bound for Phased Algorithms Lower Bound for Labeled Algorithms Lower Bound for Envy-Free Algorithms Conclusions

Cake knife

Cake cut knife

Cake 1 f ( x ) x 0 1 Utility Function for user i u

Cake 1 f ( 1 x ) x 0 1 1 Value of piece: f ( 1 x )

Cake 1 f ( 2 x ) f ( 1 x ) x x 0 1 1 2 Value of piece:  f ( x ) f ( x ) 2 1

Cake f  ( x ) x 0 1 Utility Density Function for user i u

“I cut you choose” Step 1: User 1 cuts at 1 / 2 Step 2: User 2 chooses a piece

“I cut you choose” Step 1: User 1 cuts at 1 / 2 f  ( ) 1 x

“I cut you choose” User 2 Step 2: User 2 chooses a piece f  ( ) 2 x

“I cut you choose” User 1 User 2 Both users get at least of the cake 1 / 2 Both are happy

Algorithm A N users 1 Each user cuts at Phase 1: N

Algorithm A N users 1 Each user cuts at Phase 1: N

Algorithm A u i N users Phase 1: Give the leftmost piece to the respective user

Algorithm A u i  users N 1 1 Each user cuts at Phase 2:  N 1

Algorithm A u i  users N 1 1 Each user cuts at Phase 2:  N 1

Algorithm A u u i j  users N 1 Phase 2: Give the leftmost piece to the respective user

Algorithm A u u i j  users N 2 1 Each user cuts at Phase 3:  N 2 And so on…

Algorithm A u u u i j k Total number of phases:  N 1 Total number of cuts: 2         N ( N 1 ) ( N 2 ) 1 O ( N )

Algorithm B N users 1 Each user cuts at Phase 1: 2

Algorithm B N users 1 Each user cuts at Phase 1: 2

Algorithm B N N users users 2 2 Find middle cut Phase 1:

Algorithm B N users 2 1 Each user cuts at Phase 2: 2

Algorithm B N users 2 1 Each user cuts at Phase 2: 2

Algorithm B N N users 4 4 Phase 2: Find middle cut

Algorithm B N users 4 1 Each user cuts at Phase 3: 2 And so on…

Algorithm B u i 1 user The user is assigned the piece Phase log N:

Algorithm B u u u i j k Total number of phases: log N Total number of cuts:       N N N N O ( N log N )          log N

Talk Outline Cake Cutting Algorithms Lower Bound for Phased Algorithms Lower Bound for Labeled Algorithms Lower Bound for Envy-Free Algorithms Conclusions

Phased algorithm: consists of a sequence of phases At each phase: Each user cuts a piece which is defined in previous phases A user may be assigned a piece in any phase

Observation: Algorithms and are A B phased

We show:  cuts are required ( N log N ) to assign positive valued pieces

1 1 1 1 u u u u i j k l r r r r i j k l Phase 1: Each user cuts according to some ratio

1 u u u u i j k l r r r r j k i l There exist utility functions such that the cuts overlap

2 2 1 2 2 u u u u i j k l r ' r ' r ' r ' i j k l Phase 2: Each user cuts according to some ratio

2 1 2 u u u u i j k l r ' r ' r ' r ' i j k l There exist utility functions such that the cuts in each piece overlap

3 2 3 1 3 2 3 number of pieces Phase 3: at most are doubled And so on…

Phase k: Number of pieces at most k 2

For users: N we need at least pieces N we need at least phases log N

Phase Users Pieces Cuts (min) (min) (max) N N 2 1   2 N 2 4 N 2   3 8 N 4 N 4 …… …… …… ……  log N 1 2 0 N 0 Total Cuts:  ( N log N )

Talk Outline Cake Cutting Algorithms Lower Bound for Phased Algorithms Lower Bound for Labeled Algorithms Lower Bound for Envy-Free Algorithms Conclusions

Labels: 00 010 011 10 11 c c c c 2 3 1 4 Labeled algorithms: each piece has a label

Labels: 00 010 011 10 11 c c c c 2 3 1 4 Labeling Tree: c 1 1 0 c c 4 1 2 0 0 1 00 10 11 c 3 0 1 010 011

{} {}

0 1 c 1 c 1 1 0 1 0

00 01 1 c c 2 1 c 1 1 0 1 c 2 0 1 00 01

00 010 011 1 c c c 2 3 1 c 1 1 0 1 c 2 0 1 00 c 3 0 1 010 011

00 010 011 10 11 c c c c 2 3 1 4 c 1 1 0 c c 4 1 2 0 0 1 10 11 00 c 3 0 1 010 011

Sorting Labels 00 010 011 10 11 p p p p p 1 2 3 4 5 Users receive pieces in arbitrary order: p p p p p 3 2 5 1 4 We would like to sort the pieces: p p p p p 1 2 3 4 5

Sorting Labels 00 010 011 10 11 p p p p p 1 2 3 4 5 p p p p p 3 2 5 1 4 Labels will help to sort the pieces

Sorting Labels 000 010 011 100 110 p p p p p 1 2 3 4 5 p p p p p 3 2 5 1 4 Normalize the labels

Sorting Labels 000 010 011 100 110 p p p p p 1 2 3 4 5 p p p p p 3 2 5 1 4 0 1 2 3 4 5 6 7 # cuts 2

Sorting Labels 000 010 011 100 110 p p p p p 1 2 3 4 5 p p p p 2 5 1 4 p 3 011 0 1 2 3 4 5 6 7

Sorting Labels 000 010 011 100 110 p p p p p 1 2 3 4 5 p p p 5 1 4 p p 2 3 010 011 0 1 2 3 4 5 6 7

Sorting Labels 000 010 011 100 110 p p p p p 1 2 3 4 5 p p 1 4 p p p 2 3 5 010 011 110 0 1 2 3 4 5 6 7

Sorting Labels 000 010 011 100 110 p p p p p 1 2 3 4 5 p 4 p p p p 2 3 1 5 000 010 011 110 0 1 2 3 4 5 6 7

Sorting Labels 000 010 011 100 110 p p p p p 1 2 3 4 5 Labels and pieces are ordered! p p p p p 2 3 4 1 5 000 010 011 100 110 0 1 2 3 4 5 6 7

Sorting Labels 000 010 011 100 110 p p p p p 1 2 3 4 5 Time needed: O (# cuts ) p p p p p 2 3 4 1 5 000 010 011 100 110 0 1 2 3 4 5 6 7

linearly-labeled & comparison-bounded algorithms: Require comparisons O (# cuts ) (including handling and sorting labels)

Observation: Algorithms and are A B linearly-labeled & comparison-bounded Conjecture: All known algorithms are linearly-labeled & comparison-bounded

 We will show that cuts ( N log N ) are needed for linearly-labeled & comparison-bounded algorithms

Reduction of Sorting to Cake Cutting Input: N distinct positive integers:  x , x , , x 1 2 N Output:    Sorted order:  x x x k j i Using a cake-cutting algorithm

N distinct positive integers:  x , x , , x 1 2 N utility functions:  f f f N 1 2 N  users: u u u N 1 2 N

Cake x  i f ( z ) min( 1 , N z ) i f  i u i 0 1 1 x i N

Cake f  j u k   x x x k j i f  j u j f  i u i 1 1 0 1 1 x x x k j N N i N

Cake u k x  x k i u i 0 1

1 Cake N u i cannot be satisfied! u k u k x  x k i u i 0 1

p p k i u u k i can be satisfied! u k u k p  p k i x  x k i u i 0 1

Cake u u u k j i Piece: p p p k j i Rightmost positive valued pieces     p p p k j i     x x x k j i