- 236 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about 'Cake Cutting is and is not a Piece of Cake' - Renfred

Download Now**An Image/Link below is provided (as is) to download presentation**

Download Now

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

### Cake Cutting is and is not a Piece of Cake

Jeff Edmonds, York University

Kirk Pruhs, University of Pittsburgh

Jaisingh Solanki, York University

Informal Problem Statement

Resource allocation between n self possibly deceitful players

I like

0

1

Classic Problem Definition= [0, 1]

- n players wish to divide a cake
- Each player p has an unknown value function Vp

I like

x

y

0

1

Classic Problem Definition= [0, 1]

- n players wish to divide a cake
- Each player p has an unknown value function Vp
- Allowed Operations :
- Eval[p, x, y]: returns how much player p values piece/interval [x, y]

I like

x

y

0

1

Classic Problem Definition= [0, 1]

- n players wish to divide a cake
- Each player p has an unknown value function Vp
- Allowed Operations :
- Eval[p, x, y]: returns how much player p values piece/interval [x, y]
- Cut[p, x, v]: returns a y such Eval[p,x, y] = v

I like

0

1

Classic Problem Definition= [0, 1]

- n players wish to divide a cake
- Each player p has an unknown value function Vp
- Goal: Fair cut

Each honest player p is guaranteed a piece of value at least 1/n.

I like

0

1

Classic Problem Definition= [0, 1]

- n players wish to divide a cake
- Each player p has an unknown value function Vp
- Goal: Fair cut

Each honest player p is guaranteed a piece of value at least 1/n.

History

- Originated in 1940’s school of Polish mathematics
- Picked up by social scientists interested in fair allocation of resources
- The subject of a handful of books (e.g Brams and Taylor, and Robertson and Webb) and many papers
- A quick Google search reveals cake cutting is used as a teaching example in many algorithms courses, e.g CMU CS 15-451 and CMU CS 15-750

We did not likethat piece anyway.

StopI’ll take it.

Continuous Moving Knife Algorithm- Protocol moves the knife continuously across the cake until the some player say stop.
- This player gets this piece.
- The rest of the players continue

- Moving knife considered cheating by discrete alg.
- We do not consider them here.

I like

I’ll take the right.

Classic Alg: Cut and Choose (n=2)- Person A cuts the cake into two pieces
- Person B selects one of the two pieces, and person A gets the other piece

Careful.

My half cut is here.

I am a little jealous

but I am happywith the left.

I like

O(n log n) Divide and Conquer Algorithm: Even and Paz- Yp = cut(p, 0, 1/2) for p = 1 … n

My half cut is here.

My half cut is here.

O(n log n) Divide and Conquer Algorithm: Even and Paz

- Yp = cut(p, 0, 1/2) for p = 1 … n

My half cut is here.

O(n log n) Divide and Conquer Algorithm: Even and Paz

- Yp = cut(p, 0, 1/2) for p = 1 … n
- m = median(y1, … , yn)

I like

so am happy with the left.

so am happy with the right.

O(n log n) Divide and Conquer Algorithm: Even and Paz- Yp = cut(p, 0, 1/2) for p = 1 … n
- m = median(y1, … , yn)
- Recurse on [0, m] with those n/2 players p for which yp < m
- Recurse on [m, 1] with those n/2 players p for which yp > m
- Time O(nlogn)

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 Vp[x, y]/(1+ε) ≤ v ≤ (1+ ε) Vp[x, y]
- ACut[p, ε, x, v]: returns a y such Vp[x, y]/(1+ε) ≤ v ≤ (1+ ε) Vp[x, y]

Problem Variations

(Approximate)

failure prob O(1) vs 1/nO(1)

Open: Remove contiguous requirement for randomized alg

Outline

- Deterministic Ω(n log n) Lower Bound
- Definition of Thin-Rich Problem
- Ω(log n) lower bound for Thin-Rich
- Randomized with Approximate Cuts Ω(n log n) Lower Bound
- Randomized with Exact Cuts O(n) Upper Bound

At least n/2 players require thin rich piece

Thin-Rich Game- Game Definition: Single player must find a thin rich piece.
- A piece is thin if it has width ≤ 2/n
- A piece is rich if it has value ≥ 1/2n
- Theorem: The deterministic complexity of Thin-Rich is Ω(log n).
- Theorem: The deterministic complexity of cake cutting is Ω(nlog n).

Adv

- I dynamically choose how to answer
- and the value function
- so after O(logn) operationsAlg cant find a thin rich piece.

- I give sequence of Eval[x,y] & Cut[x,v]operations.
- Oh!

Adv

- I can choose any non-continuous thin piece,
- but W.L.G.I choose one of these.

- I cut the cake in to n thin pieces.

Adv

½

¼

½

¼

¼

¼

¼

¼

½

...

...

¼

¼

...

...

...

½

...

1/1024 = ¼×¼×½×¼×¼×½

- Value of each piece isproduct of edge labelsin path.

Adv

½

¼

½

¼

¼

½

¼

¼

½

...

...

¼

¼

...

...

...

½

...

1/256 = ½×¼×½×¼×¼×½

To get a rich pieceI need at least 40% of the edge labels in path be ½.

Good luck

Adv

¼

½

¼

0.4398

0.4398

- I do binary search to find0.4398
- I fix some edge labels

- Cut[0,0.4398]?

1/4

2/4

6/16

7/16

4/16

8/16

Adv

¼

¼

¼

½

½

½

½

¼

¼

¼

¼

¼

0.4398

112/256

113/256

- I do binary search to find0.4398
- I fix some edge labels

- Cut[0,0.4398]?

Adv

¼

¼

¼

½

½

½

½

½

¼

¼

¼

¼

¼

¼

¼

0.4398

450/1024

451/1024

- I do binary search to find0.4398
- I fix some edge labels

- Cut[0,0.4398]?

Adv

¼

¼

¼

½

½

½

½

½

¼

¼

¼

¼

¼

¼

¼

0.4398

1800/4096

1801/4096

¼

¼

½

- I do binary search to find0.4398
- I fix some edge labels

- Cut[0,0.4398]?

Adv

¼

¼

¼

½

½

½

½

½

¼

¼

¼

¼

¼

¼

¼

¼

¼

½

- YesAfter t operationsevery path has only t known ½ labels.

- Every path has oneknown ½ label.

Adv

¼

¼

¼

½

½

½

½

½

¼

¼

¼

¼

¼

¼

¼

¼

¼

¼

¼

¼

¼

¼

¼

½

y

x

- I fix labels in path to x & y to ¼.
- and give
- Eval[x,y] = 0.00928

- Eval[x,y]

0.00928

Adv

¼

¼

¼

½

½

½

½

½

¼

¼

¼

¼

¼

¼

¼

¼

¼

¼

¼

½

¼

¼

¼

¼

½

That is bad.To get a rich pieceI need at least 40% of the edge labels in path be ½.

- YesAfter t operationsevery path has only t½ known labels.

Deterministic Ω(log n) Lower Bound

- Theorem: To win at Thin-Rich, the alg has to get a rich piece with at least 40% of the edge labels in path be ½.
- Theorem: After t operations, every path has only t ½ labels.
- Theorem: The deterministic complexity of Thin-Rich is Ω(depth) =Ω(log n)

At least n/2 players require thin rich piece

Deterministic Ω(nlog n) Lower Bound- Theorem: The deterministic complexity of Thin-Rich is Ω(log n).
- Theorem: The deterministic complexity of cake cutting is Ω(n log n).

Outline

Done

- Deterministic Ω(n log n) Lower Bound
- Randomized with Approximate Cuts Ω(n log n) Lower Bound
- Randomized with Exact Cuts O(n) Upper Bound

Randomized

Approximate Cuts

- I define a randomized algorithm

- I must choose the value functions
- Show after O(nlogn) operations Alg fails whp.

- I flip coins to give sequence of Eval[x,y] & Cut[x,v]operations.

Rand Alg

- i.e. not dynamically

Yao

Alg

RandAdv

- I define a randomized algorithm

- I must choose the value functions
- Show after O(nlogn) operations Alg fails whp.

- I flip coins to give sequence of Eval[x,y] & Cut[x,v]operations.

Rand Alg

- I specify a distribution on value functions.
- I flip coins.
- Show after O(nlogn) operations Alg fails whp.

- I deterministically give sequence of Eval[x,y] & Cut[x,v]operations.

AdvRand

½

¼

¼

¼

½

¼

¼

½

¼

...

...

...

...

...

...

- For each node,
- I randomly label edges
- <½,¼,¼>, <¼,½,¼>, or <¼,¼,½>

Adv

¼

½

¼

¼

¼

½

¼

½

¼

¼

½

½

¼

¼

¼

½

¼

¼

y

x

- Consider path to x and y.
- Flip coins for labels.
- 33% of labels will be ½.

- Eval[x,y]
- But I need 40%!

Adv

¼

¼

½

¼

¼

½

¼

½

¼

¼

½

¼

½

¼

¼

½

¼

½

¼

¼

¼

¼

¼

½

¼

½

¼

¼

y

x

- I do binary search for 0.4398,
- but for some odd reasonit finds 40%½ labels.

- Cut[x’,0.4398]?

½

½

½

x’

Adv

¼

¼

½

¼

¼

½

½

¼

½

¼

½

¼

½

¼

½

¼

¼

½

½

¼

½

¼

¼

¼

¼

¼

½

¼

½

¼

¼

y

x

- Luckily I can give error and this hides most of the labels.

- Cut[x’,0.4398]?

x’

Outline

Done

- Deterministic Ω(n log n) Lower Bound
- Randomized with Approximate Cuts Ω(n log n) Lower Bound
- Randomized with Exact Cuts O(n) Upper Bound

Done

Randomized

Exact Cuts

O(n)

Upper

Outline

- Randomized with O(n) Upper Bound
- As intuition for the power of randomness, give a randomized algorithm for Thin-Rich with O(1) complexity
- Describe “Balls and Bins” special case of cake cutting
- Give “random graph” proof of “Balls and Bins” case
- Give the flavor of the “random graph” proof for Cake Cutting
- Decrease failure probability

Thin-Rich Game

- Game Definition: Single player must find a thin rich piece.
- A piece is thin if it has width ≤ 3/n
- A piece is rich if it has value ≥ 1/3n
- Theorem: The deterministic complexity of Thin-Rich is Ω(log n).
- Theorem: The randomized complexity of Thin-Rich is O(1).
- Must make sure the player’s thin pieces don’t over lap too much.

O(1) Complexity Randomized Protocol for Thin-Rich

- Pick an i uniformly at random from 1 … 3n
- x = Cut[0,(i-1)/3n]
- y = Cut[ 0, i/3n]
- Return [x,y]

value = 1/3n (ie rich)

Exp(width) = 1/3n <<3/n (ie thin)

3n Candidate Pieces

i

x=(i-1)/3n

y=i/3n

Randomized Protocol for Cake Cutting

Protocol Description:

- Each player randomly selects 8 candidate pieces.
- For each player, we carefully pick one of these

1/nO(1).

Randomized Protocol for Cake CuttingProtocol Description:

- Each player randomly selects 8 candidate pieces.
- For each player, we carefully pick one of these
- so that every point of cake is covered by at most O(1) pieces.
- Where there is overlap, recurs.

Fails with probability 0(1).

Balls and Bins

Two Random Choices: n balls, 3n bins

each ball randomly chooses two bins.

# Hits: Whp no bin has more than O(logn) balls.

Choice: Select one of two bins for each ball.

Online: Whp no bin has more than O(loglogn) balls.

Balls and Bins

Two Random Choices: n balls, 3n bins

each ball randomly chooses two bins.

# Hits: Whp no bin has more than O(logn) balls.

Choice: Select one of two bins for each ball.

Online: Whp no bin has more than O(loglogn) balls.

O(loglogn) balls per bin

Balls and Bins

Two Random Choices: n balls, 3n bins

each ball randomly chooses two bins.

# Hits: Whp no bin has more than O(logn) balls.

Choice: Select one of two bins for each ball.

Online: Whp no bin has more than O(loglogn) balls.

Offline: Whp no bin has more than O(1) balls.

O(1) balls per bin

- 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 with (1) prob.
- Proof:

Prob[G contains a cycle C] ≤ ΣC Prob[C is in the graph] ~ Σi (n choose i) * (1/3n)i=(1).

Cake Protocol Ball & Bin Game

Same if

- Each player has uniform value on cake,

so all candidate pieces are the same.

- Each player randomly selects 2 (or 8) candidate pieces.
- For each player, pick one of these.
- O(1) over lap = O(1) balls per bin

I like

I like

Cake Protocol Ball & Bin GameDifferent if

- Different cake values

can make strangely overlapping candidate pieces.

Cake Protocol Ball & Bin Game

Different if

- Different cake values

can make strangely overlapping candidate pieces.

Cake Protocol Ball & Bin Game

Different if

- Different cake values

can make strangely overlapping candidate pieces.

Vertex

Vertex

Vertex

Directed Graph for Cake Cutting (choose 2 not 8 candidate peices)If take

Must take

Can’t take

If take

Must take

Must take

One DifficultyTheorem: Sufficient Condition

- If there is not directed path between the two pieces of the same person
- then maximum load is at most 1

Another Difficulty: Edges May Not be Independent

Vertex

Vertex

Vertex

Vertex

Vertex

Vertex

Theorem: If we select 8 candidate pieces

and narrow these down to 2,

then likely, there are not many dependent edges.

Example: Too many Vees

Vee

- If independent,
- Exp(# of Vees) = n3 × 1/n × 1/n = (n)
- Choose 2 candidate pieces
- Exp(# of Vees) = n3 × 1/n × 1 = (n2)

Example: Too many Vees

n/2

n/2

- Choose 2 candidate pieces
- Exp(# of Vees) = n3 × 1/n × 1 = (n2)
- Choose 8 candidate pieces
- Exp(# of Vees) = … = (n)

and narrow these down to 2

Too many Self Paths

Independent

- If independent,
- Exp(# of self paths) = like in balls & bins = (1)
- Choose 2 candidate pieces
- Exp(# of self paths) = (n)
- Choose 8 candidate pieces and narrow these down to 2
- Exp(# of self paths) = … = (1)

Prob(none) (1)

Theorem: With O(1) probability,there is not directed path between the two pieces of the same person

For each player, can pick one of these 8.

- so that every point of cake is covered by at most O(1) pieces.

Where there is overlap, recurs.

Theorem: With O(1/n) probability,there is not directed path between the two pieces of player Pi. If so Pi is “bad”.

Run the algorithm twice, independently.

Each player stays in one run in which it is “good”.

Pr[Pi is bad in both runs] = O(1/n2)

Pr[Some player is bad in both runs] = n × O(1/n2)

Theorem: With O(1/n) probability,each run has no bad directed paths.

For each run, each of its good playerscan pick one of these 8 so that every point of cake is covered by at most O(1) pieces.

Run 1

Run 2

Where there is overlap, recurs.

Theorem: Alg fails with prob O(1/n).

Repeat k times.

Theorem: Alg fails k times with prob O(1/nk).

Outline

Done

- Deterministic Ω(n log n) Lower Bound
- Randomized with Approximate Cuts Ω(n log n) Lower Bound
- Randomized with Exact Cuts O(n) Upper Bound

Skipped

Done

Future Directions

- Determine whether randomization makes sense with cheaters
- The complexity of several variations of fair division is still not completely nailed down
- Complexity of envy free division is quite wide open
- Exponential difference in upper and lower bounds
- Current project

Informal Problem Statement

Resource allocation between n self-interested players

- I dynamically choose error in answers
- so after O(nlogn) operationsAlg fails whp.

- I flip coins to give sequence of Eval[x,y] & Cut[x,v]operations.

Rand Alg

Yao

Alg

RandAdv

- I dynamically choose error in answers
- so after O(nlogn) operationsAlg fails whp.

- I flip coins to give sequence of Eval[x,y] & Cut[x,v]operations.

Rand Alg

- I flip coins to choose value function.
- I dynamically choose error in answers
- so after O(nlogn) operationsAlg fails whp.

- I deterministically give sequence of Eval[x,y] & Cut[x,v]operations.

O(1) Complexity Randomized Protocol for Thin-Rich

- For i=0…n, xi = Cut[0,i/n],
- Cuts cake into n “candidate” pieces.
- Each piece has value 1/n for player.
- Different widths, but average is 1/n.
- We will choose a random one for player.
- It is likely has width 2/n.
- i.e. thin and rich.

Constant time?

Another Difficulty: Forks

Fork of depth 3

Theorem: If we select 2d candidate pieces

and narrow these down to 2,

then likely, there are none of these.

Download Presentation

Connecting to Server..