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 Fair portion :

th of cake

N

N 1

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

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

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

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:

• Specify how each user cuts the cake
• Each user gets what she considers

to be th of the cake N / 1

• The algorithm doesn’t need to know

the user’s preferences

For users it is known how to divide the cake fairly with cuts

N ) log ( N N O

It is not known if we can do better than cuts

) log ( N N O

Steinhaus 1948: “The problem of fair division”

We show that cuts are required for the following classes of algorithms:

) log ( N N 

• Phased Algorithms
• Labeled Algorithms

(many algorithms) (all known algorithms)

Our contribution:

We show that cuts are required for special cases of envy-free algorithms:

) (

2

N 

Each user feels she gets more than the other users

Our contribution:

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

Talk Outline

Cake knife

Cake knife cut

Utility Function for user i

u

1 1

x ) (x f

Cake

1 1

1

x ) ( 1 x f

Cake Value of piece:

) ( 1 x f

Cake

1 1

1

x

2

x

) ( 1 x f ) ( 2 x f

Value of piece:

) ( ) (

1 2

x f x f 

Cake

1

x ) (x f 

Utility Density Function for user i

u

“I cut you choose” Step 1: User 1 cuts at

2 / 1

Step 2: User 2 chooses a piece

“I cut you choose” Step 1: User 1 cuts at

2 / 1 ) (

1 x

f 

“I cut you choose”

) (

2 x

f 

Step 2: User 2 chooses a piece User 2

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

2 / 1

Both are happy

Algorithm A

N users

Phase 1: Each user cuts at

N 1

Algorithm A

N users

Phase 1: Each user cuts at

N 1

Algorithm A

N users

Phase 1: Give the leftmost piece to the respective user

i

u

Algorithm A

1  N

users Phase 2: Each user cuts at

1 1  N

i

u

Algorithm A

1  N

users Phase 2: Each user cuts at

1 1  N

i

u

Algorithm A

1  N

users Phase 2:

i

u

Give the leftmost piece to the respective user

j

u

Algorithm A

2  N

users Phase 3: Each user cuts at

2 1  N

i

u

j

u

And so on…

Algorithm A Total number of phases:

i

u

j

u

k

u 1  N

Total number of cuts:

) ( 1 ) 2 ( ) 1 (

2

N O N N N        

Algorithm B

N users

Phase 1: Each user cuts at

2 1

Algorithm B

N users

Phase 1: Each user cuts at

2 1

Algorithm B users Phase 1: Find middle cut

2 N

users

2 N

Algorithm B

2 N users

Phase 2: Each user cuts at

2 1

Algorithm B

2 N users

Phase 2: Each user cuts at

2 1

Algorithm B

4 N

Phase 2: Find middle cut

4 N

users

Algorithm B

4 N users

Phase 3: Each user cuts at

2 1

And so on…

Algorithm B Phase log N:

i

u

1 user

The user is assigned the piece

Algorithm B Total number of phases:

i

u

j

u

k

u N log

Total number of cuts:

) log (

log

N N O N N N N

N

              

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

Talk Outline

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 phased

A B

We show:

) log ( N N 

cuts are required to assign positive valued pieces

Phase 1: Each user cuts according to some ratio

i

u

i

r

j

u

j

r

k

u

k

r

1 1 1 1

l

u

l

r

i

u

i

r

j

u

j

r

k

u

k

r

There exist utility functions such that the cuts overlap

l

u

l

r

1

Phase 2: Each user cuts according to some ratio

i

u '

i

r

j

u '

j

r

k

u '

k

r

2 2 2 2

l

u '

l

r

1

i

u

j

u

k

u

There exist utility functions such that the cuts in each piece overlap

l

u

1 2 2

'

i

r '

j

r '

k

r '

l

r

1 2 2 Phase 3: 3 3 3 3 number of pieces 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

N log

Phase Users

1

N

Pieces Cuts

2

N

2

2  N

4

2  N

(min) (max) (min)

3

4  N

8

4  N 1 log  N N 2 …… …… …… ……

Total Cuts:

) log ( N N 

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

Talk Outline

1

c

2

c

3

c

4

c

11 10 011 010 00 Labels: each piece has a label Labeled algorithms:

1

c

2

c

3

c

4

c

11 10 011 010 00 Labels:

1

c

2

c

3

c

4

c

1 1 1 1

00 010 011 10 11 Labeling Tree:

{} {}

1

c

1

c

1

1 1

1

c

1

c

1

00 1 00 1 01

2

c

1

01

2

c

1

c

1

c

1

00 1 00 1

2

c

1

2

c

011 010

3

c

1

010 011

3

c

1

c

2

c

3

c

4

c

11 10 011 010 00

1

c

2

c

1 1 1 1

00 010 011 10 11

4

c

3

c

11 10 011 010 00 Sorting Labels Users receive pieces in arbitrary order:

1

p

2

p

3

p

4

p

5

p

1

p

2

p

3

p

4

p

5

p

We would like to sort the pieces:

1

p

2

p

3

p

4

p

5

p

11 10 011 010 00 Sorting Labels

1

p

2

p

3

p

4

p

5

p

Labels will help to sort the pieces

1

p

2

p

3

p

4

p

5

p

110 100 011 010 000 Sorting Labels

1

p

2

p

3

p

4

p

5

p

1

p

2

p

3

p

4

p

5

p

Normalize the labels

110 100 011 010 000 Sorting Labels

1

p

2

p

3

p

4

p

5

p

1 2 3 4 5 6 7

1

p

2

p

3

p

4

p

5

p

cuts #

2

110 100 011 010 000 Sorting Labels

1

p

2

p

3

p

4

p

5

p

1 2 3 4 5 6 7

1

p

2

p

3

p

4

p

5

p

011

110 100 011 010 000 Sorting Labels

1

p

2

p

3

p

4

p

5

p

1 2 3 4 5 6 7

1

p

2

p

3

p

4

p

5

p

011 010

110 100 011 010 000 Sorting Labels

1

p

2

p

3

p

4

p

5

p

1 2 3 4 5 6 7

1

p

2

p

3

p

4

p

5

p

011 010 110

110 100 011 010 000 Sorting Labels

1

p

2

p

3

p

4

p

5

p

1 2 3 4 5 6 7

1

p

2

p

3

p

4

p

5

p

011 010 110 000

110 100 011 010 000 Sorting Labels

1

p

2

p

3

p

4

p

5

p

1 2 3 4 5 6 7

1

p

2

p

3

p

4

p

5

p

011 010 110 000 100 Labels and pieces are ordered!

110 100 011 010 000 Sorting Labels

1

p

2

p

3

p

4

p

5

p

1 2 3 4 5 6 7

1

p

2

p

3

p

4

p

5

p

011 010 110 000 100 Time needed:

) (#cuts O

linearly-labeled & comparison-bounded algorithms:

) (#cuts O

Require comparisons (including handling and sorting labels)

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

A B

We will show that cuts are needed for linearly-labeled & comparison-bounded algorithms

) log ( N N 

N distinct positive integers:

N

x x x , , ,

2 1



i j k

x x x    

Sorted order: Reduction of Sorting to Cake Cutting Input: Output: Using a cake-cutting algorithm

1

f

2

f

N

f N distinct positive integers:

N

x x x , , ,

2 1



utility functions: users:

1

u

2

u

N

u

 

N N

1

i

f 

i

x

N 1

i

u

Cake

) , 1 min( ) ( z N z f

i

x i



1

i

u

i

f 

j

u

k

u

i j k

x x x  

i

x

N 1

j

x

N 1

k

x

N 1

j

f 

j

f 

Cake

1

i k

x x 

i

u

k

u

Cake

Cake

1

i

u

i

u

N 1

k

u

cannot be satisfied!

k

u

i k

x x 

1

i

u

k

u

can be satisfied!

i

u

k

u

k

u

i k

x x 

i

p

k

p

i k

p p 

Cake

i

u

j

u

k

u

k

p

j

p

i

p

Rightmost positive valued pieces

i j k

x x x    

i j k

p p p    

Piece:

i

u

j

u

k

u

k

p

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

Fair cake-cutting Sorting

Sorting integers:

) log ( N N 

comparisons Cake Cutting:

) log ( N N 

comparisons

Linearly-labeled & comparison-bounded algorithms:

) (#cuts O

Require comparisons

) log ( N N 

comparisons

) log ( N N 

cuts require

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

Talk Outline

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

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

Lower Bounds Strong Envy-free: Super Envy-free:

) 086 . (

2

N  

cuts

) 25 . (

2

N  

cuts

1

i

u

i

f 

Strong Envy-Free, Lower Bound

1

k

u

k

f 

Strong Envy-Free, Lower Bound

1

k

u

Strong Envy-Free, Lower Bound

i

u

j

u

1

k

u

Strong Envy-Free, Lower Bound

i

u

k

u

k

u

is upset!

1

k

u

Strong Envy-Free, Lower Bound

i

u

k

u

k

u

is happy!

Strong Envy-Free, Lower Bound must get a piece from each

• f the other user’s gap

1

k

u

i

u

j

u

k

u

k

u

Strong Envy-Free, Lower Bound A user needs distinct pieces

) (N 

Total number of cuts:

) (

2

N 

Total number of pieces:

) (

2

N 

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

Talk Outline

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

Open problems:

• Prove or disprove that every algorithm

is linearly-labeled and comp.-bounded

• An improved lower bound for

envy-free algorithms