cake cutting is not a piece of cake - lsucsc.lsu.edu/~busch/slides/2003-stacs-cake.pdfcake cutting...

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

CUTMeg’s Piece Tom’s Piece

Happy Happy

Meg Prefers

Yellow Fish

Tom Prefers

Cat Fish

CUTTom’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 cakeN/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( NNO

It is not known if we can do better

than cuts)log( NNO

Steinhaus 1948: “The problem of fair division”

We show that cuts are required

for the following classes of algorithms:

)log( NN

•Phased Algorithms

•Labeled Algorithms

(many algorithms)

(all known algorithms)

Our contribution:

We show that cuts are required

for special cases of envy-free algorithms:

)( 2N

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 iu

1

1

x

)(xf

Cake

0

1

1

1x

)( 1xf

Cake

0

Value of piece: )( 1xf

Cake

1

1

0 1x 2x

)( 1xf

)( 2xf

Value of piece: )()( 12 xfxf

Cake

10 x

)(xf

Utility Density Function for user iu

“I cut you choose”

Step 1: User 1 cuts at 2/1

Step 2: User 2 chooses a piece


Step 1: User 1 cuts at 2/1

)(1 xf


)(2 xf

Step 2: User 2 chooses a piece

User 2


User 2User 1

Both users get at least of the cake 2/1

Both are happy

Algorithm A

N users

Phase 1: Each user cuts atN

1

Algorithm A

N users

Phase 1: Give the leftmost piece to the

respective user

iu

Algorithm A

1N users

Phase 2: Each user cuts at1

1

N

iu

Algorithm A

1N users

Phase 2:

iu

Give the leftmost piece to the

respective user

ju

Algorithm A

2N users


1

N

iu ju

And so on…

Algorithm A

Total number of phases:

iu ju ku

1N

Total number of cuts:

)(1)2()1( 2NONNN

Algorithm B

N users


1

Algorithm B

users

Phase 1: Find middle cut

2

Nusers

2

N

Algorithm B

2

Nusers


1

Algorithm B

4

N

Phase 2: Find middle cut

4

Nusers

Algorithm B

4

Nusers


1

And so on…

Algorithm B

Phase log N:

iu

1 user

The user is assigned the piece

Algorithm B

Total number of phases:

iu ju ku

Nlog

Total number of cuts:

)log(

log

NNONNNN

N





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( NN cuts are required

to assign positive valued pieces

Phase 1: Each user cuts according

to some ratio

iu

irju

jrku

kr

1 1 1 1

lu

lr

iu

irju

jrku

kr

There exist utility functions

such that the cuts overlap

lu

lr

1

Phase 2: Each user cuts according

to some ratio

iu

'irju

'jrku

'kr

2 2 2 2

lu

'lr

1

iu ju ku

There exist utility functions

such that the cuts in each piece overlap

lu

12 2

'ir 'jr 'kr 'lr

12 2

Phase 3:

3 3 3 3

number of pieces

at most are doubled

And so on…

Phase k: Number of pieces at most k2

For users:N

we need at least piecesN

we need at least phasesNlog

Phase Users

1 N

Pieces Cuts

2 N

2 2N 4 2N

(min) (max) (min)

3 4N 8 4N

1log N 0 N2 0

…… …… …… ……

Total Cuts: )log( NN





Conclusions

Talk Outline

1c2c 3c 4c

111001101000Labels:

each piece has a labelLabeled algorithms:

1c2c 3c 4c

111001101000Labels:

1c

2c

3c

4c

0 1

0 1 0 1

0 100

010 011

10 11

Labeling Tree:

{}

{}

1c

1c0 1

0 1

0 1

1c

1c0 1

00

1

00 101

2c0 1

01

2c

1c

1c0 1

00

1

00 1

2c0 1

2c

011010

3c

0 1

010 011

3c

1c2c 3c 4c

111001101000

1c

2c

0 1

0 1 0 1

0 100

010 011

10 11

4c

3c

111001101000

Sorting Labels

Users receive pieces in arbitrary order:

1p 2p 3p 4p 5p

1p2p3p 4p5p

We would like to sort the pieces:

1p 2p 3p 4p 5p

111001101000

Sorting Labels

1p 2p 3p 4p 5p

Labels will help to sort the pieces

1p2p3p 4p5p

110100011010000

Sorting Labels

1p 2p 3p 4p 5p

1p2p3p 4p5p

Normalize the labels

110100011010000

Sorting Labels

1p 2p 3p 4p 5p

0 1 2 3 4 5 6 7

1p2p3p 4p5p

cuts#2

110100011010000

Sorting Labels

1p 2p 3p 4p 5p

0 1 2 3 4 5 6 7

1p2p

3p

4p5p

011

110100011010000

Sorting Labels

1p 2p 3p 4p 5p

0 1 2 3 4 5 6 7

1p

2p 3p

4p5p

011010

110100011010000

Sorting Labels

1p 2p 3p 4p 5p

0 1 2 3 4 5 6 7

1p

2p 3p

4p

5p

011010 110

110100011010000

Sorting Labels

1p 2p 3p 4p 5p

0 1 2 3 4 5 6 7

1p 2p 3p

4p

5p

011010 110000

110100011010000

Sorting Labels

1p 2p 3p 4p 5p

0 1 2 3 4 5 6 7

1p 2p 3p 4p 5p

011010 110000 100

Labels and pieces are ordered!

110100011010000

Sorting Labels

1p 2p 3p 4p 5p

0 1 2 3 4 5 6 7

1p 2p 3p 4p 5p

011010 110000 100

Time needed: )(#cutsO

linearly-labeled &

comparison-bounded algorithms:

)(#cutsORequire 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( NN

N distinct positive integers: Nxxx ,,, 21

ijk xxx Sorted order:

Reduction of Sorting to Cake Cutting

Input:

Output:

Using a cake-cutting algorithm

1f 2f Nf

N distinct positive integers: Nxxx ,,, 21

utility functions:

users: 1u 2u Nu

N

N

10

if

ixN

1

iu

Cake

),1min()( zNzf ix

i

10iu

if

ju

kuijk xxx

ixN

1jxN

1

kxN

1

jf

jf

Cake

10

ik xx

iu

ku

Cake

Cake

10

iu

iu

N

1

ku cannot be satisfied!ku

ik xx

10iu

ku can be satisfied!

iuku

ku

ik xx

ipkp

ik pp

Cake

iujuku

kp jp ip

Rightmost positive valued pieces

ijk xxx

ijk ppp

Piece:

iujuku

kp

ijk xxx

Labels: kl jl il

ijk lll Sorted labels:

Sorted pieces:

Sorted integers:

ijk ppp

jp ip

Fair cake-cutting

Sorting

Sorting integers: )log( NN comparisons

Cake Cutting: )log( NN comparisons

Linearly-labeled &

comparison-bounded algorithms:

)(#cutsORequire comparisons

)log( NN comparisons

)log( NN cuts

require





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.0( 2N cuts

)25.0( 2N cuts

10

iu

if

Strong Envy-Free, Lower Bound

10

ku

kf


10

ku


iu ju

10

ku


iu

ku

ku is upset!

10

ku


iu

ku

ku is happy!


must get a piece from each

of the other user’s gap

10

ku iu ju

ku

ku


A user needs distinct pieces )(N

Total number of cuts: )( 2N

Total number of pieces: )( 2N





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

cake cutting is not a piece of cake - lsucsc.lsu.edu/~busch/slides/2003-stacs-cake.pdfcake cutting...

Documents