Cake Cutting is and is not a Piece of Cake Jeff Edmonds, York University Kirk Pruhs, University of...
Transcript of Cake Cutting is and is not a Piece of Cake Jeff Edmonds, York University Kirk Pruhs, University of...
Cake Cutting is and is not a Piece of Cake
Jeff Edmonds, York UniversityKirk Pruhs, University of Pittsburgh
Jaisingh Solanki, York University
Toronto Star
Informal Problem StatementResource allocation between n self possibly deceitful players
Classic Problem Definition• n players wish to divide a cake • Each player p has an unknown value function
Vp
0 1
I like I like
= [0, 1]
Classic Problem Definition• 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]
0 1
I like
= [0, 1]
x y
v
Classic Problem Definition• 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
0 1
I like
= [0, 1]
yx
v
Classic Problem Definition• 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.
0 1
I like
= [0, 1]
1/n
Classic Problem Definition• 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.
0 1
= [0, 1]
I like
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
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
StopI’ll take it.
We did not likethat piece anyway.•Moving knife
considered cheating by discrete alg.We do not consider them here.
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.
I like
My half cut is here.I am a little jealous
but I am happywith the left.
I like
I’ll take the right.
O(n log n) Divide and Conquer Algorithm: Even and Paz
• Yp = cut(p, 0, 1/2) for p = 1 … n
I like
My half cut is here.
I like
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.
I like
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)
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)
so am happy with the left.
I like I like
so am happy with the right.
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
Deterministic vs. Randomized
Exact vs. Approximate Queries
Exact vs. O(1) Fairness
Contiguous vs. General Pieces
Complexity = number of queries
Reference
* Exact * * O(n log n) Even and Paz 1984
* * Exact Contiguous Ω(n log n) Sgall and Woeginger 2003
Deterministic * * * Ω(n log n) Edmonds and Pruhs
* Approximate * * Ω(n log n) Edmonds and Pruhs
Randomized Exact Approximate General O(n) Edmonds and Pruhs
Edmonds and Solanki
(Approximate)
Open: Remove contiguous requirement for randomized alg
failure prob O(1) vs 1/nO(1)
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
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).
–At least n/2 players require thin rich piece
Adv
I give sequence of Eval[x,y] & Cut[x,v]
operations.
Oh!
I dynamically choose how to answer
and the value functionso after O(logn) operations
Alg cant find a thin rich piece.
Alg
AdvAlg
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.
AdvAlg
I build a complete 3-ary treewith the n pieces
as leaves
... ... ... ...
......
AdvAlg
For each node,I label edges
<½,¼,¼> or <¼,¼,½>
½¼ ¼½ ¼¼
... ... ... ...
......
AdvAlg
Value of each piece isproduct of edge labels
in path.
½¼ ¼½ ¼¼
... ... ... ...
......
½
¼
¼
¼¼
½1/1024 = ¼×¼×½×¼×¼×½
AdvAlg
½¼ ¼½ ¼¼
... ... ... ...
......
½
½
¼
¼¼
½
To get a rich pieceI need at least 40% of the edge labels
in path be ½.
Good luck
1/256 = ½×¼×½×¼×¼×½
AdvAlgCut[0,0.4398]?
I need to find a yso that
V[0,y] = 0.4398.
y0
0.4398
AdvAlgCut[0,0.4398]?
1/40 1/2 1
I do binary search to find0.4398
0.43980.4398
AdvAlgCut[0,0.4398]?
½¼ ¼1/42/4
0.4398
I do binary search to find0.4398
I fix some edge labels
AdvAlgCut[0,0.4398]?
½¼ ¼1/42/4
4/166/16
7/168/16
0.43980.4398
I do binary search to find0.4398
I fix some edge labels
AdvAlgCut[0,0.4398]?
½¼ ¼¼½ ¼
7/16
0.4398
8/16
I do binary search to find0.4398
I fix some edge labels
AdvAlgCut[0,0.4398]?
½¼ ¼¼½ ¼
½¼ ¼28/6429/64
0.4398
I do binary search to find0.4398
I fix some edge labels
AdvAlgCut[0,0.4398]?
½¼ ¼¼½ ¼
½¼ ¼½¼ ¼
0.4398
112/256113/256
I do binary search to find0.4398
I fix some edge labels
AdvAlgCut[0,0.4398]?
½¼ ¼¼½ ¼
½¼ ¼½¼ ¼
¼½ ¼450/1024
451/1024
0.4398
I do binary search to find0.4398
I fix some edge labels
AdvAlgCut[0,0.4398]?
½¼ ¼¼½ ¼
½¼ ¼½¼ ¼
¼½ ¼
¼ ½¼
0.4398
1800/40961801/4096
I do binary search to find0.4398
I fix some edge labels
AdvAlgCut[0,0.4398]?
½¼ ¼¼½ ¼
½¼ ¼½¼ ¼
¼½ ¼
¼ ½¼
0.4398
I find a yso that
V[0,y] = 0.4398.
y
AdvAlgI learned a path,
but all its labels are ¼
½¼ ¼¼½ ¼
½¼ ¼½¼ ¼
¼½ ¼
¼ ½¼
Hee Hee
AdvAlg
½¼ ¼¼½ ¼
½¼ ¼½¼ ¼
¼½ ¼
¼ ½¼
Every path has one
known ½ label.
YesAfter t operations
every path has only t known ½ labels.
AdvAlg
½¼ ¼¼½ ¼
½¼ ¼½¼ ¼
¼½ ¼
¼ ½¼
Eval[x,y]
¼ ¼¼
¼¼
¼
x y
I fix labels in path to x & y to ¼.
and giveEval[x,y] = 0.00928
0.00928
AdvAlg
½¼ ¼¼½ ¼
½¼ ¼½¼ ¼
¼½ ¼
¼ ½¼
¼ ¼¼
¼¼
¼ ½
YesAfter t operations
every path has only t ½ known labels.
That is bad.To get a rich pieceI need at least 40% of the edge labels
in path be ½.
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)
• Theorem: The deterministic complexity of Thin-Rich is Ω(log n).
• Theorem: The deterministic complexity of cake cutting is Ω(n log n).
–At least n/2 players require thin rich piece
Deterministic Ω(nlog n) Lower Bound
Outline
• 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 Approximate Cuts
AdvRand Alg
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.
i.e. not dynamically
AdvRand Alg
I define a randomized algorithm
I flip coins to give sequence of
Eval[x,y] & Cut[x,v]operations.
I deterministically give sequence of
Eval[x,y] & Cut[x,v]operations.
I specify a distribution on value functions.
I flip coins.Show after O(nlogn)
operations Alg fails whp.
RandAdv
Alg
Yao
I must choose the value functions
Show after O(nlogn) operations Alg fails whp.
AdvRand
Alg
½¼ ¼½ ¼¼
... ... ... ...
......
For each node,I randomly label edges
<½,¼,¼>, <¼,½,¼>, or <¼,¼,½>
¼¼ ½
AdvAlg
Consider path to x and y.
Flip coins for labels.
33% of labels will be ½.
¼
¼
¼
¼
¼
½¼
¼
¼
¼
¼
½
½
¼
½
½
Eval[x,y]
But I need 40%!
x y
½ ¼
AdvAlgI flip coins for path to x’
and get 33% ½.
¼
¼
¼
¼
¼
½¼
¼
¼
¼
¼
½
½
¼
½
½
x y
½ ¼
Cut[x’,0.4398]?
x’
¼
¼
¼¼
¼
½
½
½
AdvAlg
I do binary search for 0.4398,
but for some odd reasonit finds 40% ½ labels.
¼
¼
¼
¼
¼
½¼
¼
¼
¼
¼
½
½
¼
½
½
x y
½ ¼
Cut[x’,0.4398]?
x’
¼
¼
¼¼
¼
½
½
½
½½
½¼
¼
AdvAlg
Luckily I can give error
and this hides most of the labels.
¼
¼
¼
¼
¼
½¼
¼
¼
¼
¼
½
½
¼
½
½
x y
½ ¼
Cut[x’,0.4398]?
x’
¼
¼
¼¼
¼
½
½
½
½½
½¼
¼
Outline
• Deterministic Ω(n log n) Lower Bound
• Randomized with Approximate Cuts Ω(n log n) Lower Bound
• Randomized with Exact Cuts O(n) Upper Bound
Done
Done
Randomized Exact CutsUpperO(n)
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.
1. Pick an i uniformly at random from 1 … 3n
2. x = Cut[0,(i-1)/3n]
3. y = Cut[ 0, i/3n]
4. Return [x,y]value = 1/3n (ie rich)
Exp(width) = 1/3n << 3/n (ie thin)
O(1) Complexity Randomized Protocol for Thin-Rich
i
x=(i-1)/3n y=i/3n
3n Candidate Pieces
Randomized Protocol for Cake Cutting
Protocol Description:• Each player randomly selects 8 candidate
pieces.• For each player, we carefully pick one of these
Randomized Protocol for Cake Cutting
Protocol 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).1/nO(1).
O(1)
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
Balls and Bins
• 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
Proof on Offline: O(1)-Balls
• Classic Theorem: If a graph G has n/3 independent edges, then G is acyclic with prob.
• Proof: Prob[G contains a cycle C]
≤ ΣC Prob[C is in the graph] ~ Σi (n choose i) * (1/3n)i
= (1).
Proof on Offline: O(1)-Balls
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
Cake Protocol Ball & Bin Game Different if• Different cake values can make strangely overlapping candidate
pieces.
I like I like I like
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.
Directed Graph for Cake Cutting (choose 2 not 8 candidate peices)
VertexVertex
Vertex Vertex
If take
Can’t take Must take
One Difficulty
Theorem: Sufficient Condition • If there is not directed path between
the two pieces of the same person• then maximum load is at most 1
If take
Must take
Must take
Must take
Another Difficulty:
Edges May Not be Independent
VertexVertex
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
•If independent,
•Exp(# of Vees) = n3 × 1/n × 1/n = (n)
•Choose 2 candidate pieces
•Exp(# of Vees) = n3 × 1/n × 1 = (n2)
Vee
Example: Too many Vees
•Choose 2 candidate pieces
•Exp(# of Vees) = n3 × 1/n × 1 = (n2)
n/2
n/2
Vee
Example: Too many Vees
•Choose 2 candidate pieces
•Exp(# of Vees) = n3 × 1/n × 1 = (n2)
•Choose 8 candidate pieces•Exp(# of Vees) = … = (n)
n/2
n/2
and narrow these down to 2
Vee
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)
Vee
Prob(none) (1)
Theorem: With O(1) probability,there is not directed path between the two pieces of the same person
Conclusions
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.
Problem Variations
Deterministic vs. Randomized
Exact vs. Approximate Queries
Exact vs. O(1) Fairness
Contiguous vs. General Pieces
Complexity = number of queries
Reference
* Exact * * O(n log n) Even and Paz 1984
* * Exact Contiguous Ω(n log n) Sgall and Woeginger 2003
Deterministic * * * Ω(n log n) Edmonds and Pruhs
* Approximate * * Ω(n log n) Edmonds and Pruhs
Randomized Exact Approximate General O(n) Edmonds and Pruhs
Edmonds and Solanki
(Approximate)
failure prob (1) vs 1/n(1)
A piece of cake.
Theorem: With O(1/n) probability,there is not directed path between the two pieces of player Pi. If so Pi is “bad”.
Conclusions
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)
Conclusions
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
Theorem: With O(1/n) probability,each run has no bad directed paths.
Where there is overlap, recurs.
ConclusionsTheorem: Alg fails with prob O(1/n).
Theorem: Alg fails k times with prob O(1/nk).
Repeat k times.
Outline
• Deterministic Ω(n log n) Lower Bound
• Randomized with Approximate Cuts Ω(n log n) Lower Bound
• Randomized with Exact Cuts O(n) Upper Bound
Done
Skipped
Done
A piece of cake.
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
End
Informal Problem StatementResource allocation between
n self-interested players
AdvRand Alg
I flip coins to give sequence of
Eval[x,y] & Cut[x,v]operations.
I dynamically choose error in answers
so after O(nlogn) operationsAlg fails whp.
AdvRand Alg
I deterministically give sequence of
Eval[x,y] & Cut[x,v]operations.
I flip coins to choose value function.
I dynamically choose error in answers
so after O(nlogn) operationsAlg fails whp.
RandAdv
Alg
Yao
I flip coins to give sequence of
Eval[x,y] & Cut[x,v]operations.
I dynamically choose error in answers
so after O(nlogn) operationsAlg fails whp.
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?
Example: Too many Vees
Exp(# of Vees) = n3 × 1/n × 1/n = (n)
n/2
Exp(# of Vees) = (1) × (n2)
n/2
Example: Too many Vees
If independent,
Exp(# of Vees) = n3 × 1/n × 1/n = (n)
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.