Cake Cutting is Not a Piece of Cake

Transcription

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

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

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

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

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

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

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

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

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

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

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

12 knife Cake

13 Cake knife cut

14 Cake f (x) 1 0 x 1 Utility Function for user ui

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

16 Cake f f ( x 2 ) ( x 1 ) 1 0 x 1 x2 1 Value of piece: f x ) f ( ) ( 2 x1

17 Cake f (x) 0 x 1 Utility Density Function for user ui

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

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

20 I cut you choose User 2 Step 2: User 2 chooses a piece f 2 ( x )

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

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

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

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

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

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

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

28 Algorithm A ui u j N 2 users Phase 3: Each user cuts at 1 N 2 And so on

29 Algorithm A ui u j uk Total number of phases: N 1 Total number of cuts: N ( N 1) ( N 2) 1 O( N 2 )

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

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

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

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

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

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

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

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

38 Algorithm B ui u j uk Total number of phases: log N Total number of cuts: N N N N log N O( N log N )

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

40 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

41 Observation: Algorithms A and B are phased

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

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

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

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

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

47 Phase 3: number of pieces at most are doubled And so on

48 Phase k: Number of pieces at most k 2

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

50 Phase Users Pieces Cuts (min) (max) (min) 1 N 2 N 2 N 2 4 N 2 3 N 4 8 N 4 log N 1 0 2N 0 Total Cuts: ( N log N)

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

52 Labels: c2 3 c c4 c 1 Labeled algorithms: each piece has a label

53 Labels: Labeling Tree: 00 c2 3 c c4 c 1 c c 2 c c

54 {} {}

55 0 1 c 1 c

56 c 2 c 1 c c

57 c 2 c 3 c 1 00 c c c

58 c2 3 c c4 c 1 c c 2 c c

59 Sorting Labels p1 p2 p3 p4 p5 Users receive pieces in arbitrary order: p3 p 2 p 5 p 1 p4 We would like to sort the pieces: p1 p2 p3 p4 p5

60 Sorting Labels p1 p2 p3 p4 p5 p3 p 2 p 5 p 1 p4 Labels will help to sort the pieces

61 Sorting Labels p1 p2 p3 p4 p5 p3 p 2 p 5 p 1 p4 Normalize the labels

62 Sorting Labels p1 p2 p3 p4 p5 p3 p 2 p 5 p 1 p #cuts 2

63 Sorting Labels p1 p2 p3 p4 p5 p 2 p 5 p 1 p 4 p

64 Sorting Labels p1 p2 p3 p4 p5 p 5 p 1 p 4 p2 p

65 Sorting Labels p1 p2 p3 p4 p5 p 1 p 4 p2 p3 p

66 Sorting Labels p1 p2 p3 p4 p5 p 4 p1 p2 p3 000 p

67 Sorting Labels p1 p2 p3 p4 p5 Labels and pieces are ordered! p1 p2 p3 p4 p

68 Sorting Labels p1 p2 p3 p4 p5 Time needed: O(#cuts) p1 p2 p3 p4 p

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

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

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

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

73 N distinct positive integers: x 1, x 2,, x N N utility functions: f1 f 2 f N N users: u1 u2 u N

74 Cake f i x ( z) min(1, N z) i fi u i 0 1 N x i 1

75 Cake f j u k x k x j x i f j u j fi u i 0 1 N x k N 1 x j 1 N x i 1

76 Cake u k xk x i 0 u i 1

77 1 N u i Cake u k uk cannot be satisfied! xk x i 0 u i 1

78 p k u k p i u i u k uk p p k i xk x i can be satisfied! 0 u i 1

79 Cake u k u j u i Piece: pk p j pi Rightmost positive valued pieces p k p j p i x k x j x i

80 u i u j u k p k i j k x x x Labels: k l j l i l i j k l l l Sorted labels: Sorted pieces: Sorted integers: i j k p p p j p i p

81 Fair cake-cutting Sorting

82 Sorting integers: ( N log N) comparisons Cake Cutting: ( N log N) comparisons

83 Linearly-labeled & comparison-bounded algorithms: Require O(#cuts) comparisons ( N log N ) comparisons require ( N log N ) cuts

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

85 Variations of Fair Cake-Division Envy-free: Each user feels she gets at least as much as the other users Strong Envy-free: Each user feels she gets strictly more Than the other users

86 Super Envy-free: A user feels she gets a fair portion, and every other user gets less than fair

87 Lower Bounds Strong Envy-free: (0.086 N 2 ) cuts Super Envy-free: (0.25 N 2 ) cuts

88 Strong Envy-Free, Lower Bound fi u i 0 1

89 Strong Envy-Free, Lower Bound fk u k 0 1

90 Strong Envy-Free, Lower Bound u k ui u j 0 1

91 Strong Envy-Free, Lower Bound u k u k u i 0 1 uk is upset!

92 Strong Envy-Free, Lower Bound u k u k u i 0 1 uk is happy!

93 Strong Envy-Free, Lower Bound u k u k ui u j 0 1 u k must get a piece from each of the other user s gap

94 Strong Envy-Free, Lower Bound A user needs (N) distinct pieces Total number of pieces: 2 ( N ) 2 Total number of cuts: ( N )

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

96 We presented new lower bounds for several classes of fair cake-cutting algorithms

97 Open problems: Prove or disprove that every algorithm is linearly-labeled and comp.-bounded An improved lower bound for envy-free algorithms