truth, justice, and cake cutting ariel procaccia (harvard seas) 1
Post on 19-Dec-2015
220 views
TRANSCRIPT
1
TRUTH, JUSTICE, AND CAKE CUTTING
Ariel Procaccia (Harvard SEAS)
2
Standing on the shoulders of giantsSuperman: “I’m here
to fight for truth, justice, and the American Way.”
Lois Lane: “You’re gonna wind up fighting every elected official in this country!”
Superman (1978)
3
Truth, justice, and cake cutting Division of a heterogeneous divisible good The cake is the interval [0,1] Set of agents N={1,...,n} Piece of cake X [0,1] = finite union of
disjoint intervals Each agent has a valuation function Vi over
pieces of cake Integral over a value density function vi
iN, Vi(0,1) = 1
Find an allocation A1,...,An
4
Truth, justice, and cake cutting Proportionality: iN, Vi(Ai) 1/n Envy-freeness: i,jN, Vi(Ai) Vi(Aj) Assuming free disposal the two
properties are incomparable Envy-free but not proportional: throw away
cake Proportional but not envy-free
1/3 1/2 1/61 1
5
Some childhood nostalgia
Assume that n=2 The cut and choose algorithm
[Procaccia&Procaccia, circa 1987?]: Player 1 cuts the cake into two pieces X1,X2 s.t.
V1(X1)=V1(X2) = ½ Player 2 chooses the piece that he prefers Player 1 gets the other piece
Not a bad algorithm! Envy-free proportional (Contiguous pieces one cut)
1/2 1/21/3 2/3
6
Cake cutting is not a piece of cake Very cool envy-free algorithm for n=3
[Selfridge&Conway, circa 1960] Envy-free algorithm for n4 [Brams&Taylor,
1995] May require an unbounded number of steps!
Recent lower bounds in a concrete complexity model Envy-free unbounded assuming contiguous
pieces [Stromquist, 2008]
(n2) lower bound for envy-free cake cutting [Procaccia, 2009]
7
Truth, justice, and cake cutting Previous work considered strategyproof
cake cutting [Brams, Jones & Klamler 2006, 2008]
Their notion: agents report the truth if there exist valuations for others s.t. agent does not gain by lying Prior-free!
Truthful algorithm = truthfulness is a dominant strategy
Cut and choose is “strategyproof” but not truthful
8
An inconvenient truth
Goal: design truthful, fair (envy-free and proportional), and tractable cake cutting algorithms
Requires restricting the valuation functions Valuation Vi is piecewise constant if its value
density function vi is piecewise constant Valuation is piecewise uniform if moreover vi is
some uniform constant or zero Agent is uniformly interested in piece of cake Ui
Representation: boundaries of these intervals A natural (?) restriction and also proof of concept
9
Restricted valuations illustrated
Piecewise constant valuation that is not piecewise uniform
Piecewise uniform valuation
0 0.5 10
1
2
0 0.5 10
1
2
Vi([0,0.1][0.5,0.7]) = 0.4
10
The case of two agents: take 1 We first assume n=2 (and piecewise uniform
valuations) A simple algorithm:
For each agent, make a mark at the beginning and end of each of the agent’s desired intervals
For each subinterval between consecutive marks, allocate left half to agent 1and right half to agent 2
Each agent gets value ½ envy-free and proportional
... but not truthful If U1 = [0,0.5] and U2 = [0,1] then A1=
[0,0.25][0.5,0.75] and A2 = [0.25,0.5][0.75,1] Agent 1 can gain by reporting [0,1] A1= [0,0.5]
11
The case of two agents: take 2
Initialization phase:
1. Discard [0,1]\U1U2
2. Make a mark at the beginning and end of each desired interval
3. Allocate half of each subinterval between consecutive marks to agent 1 and half to agent 2
Denote: len(X) = the total
length of intervals in X
X1 = U1\U2 , X2 = U2\U1, X12 = U1U2
Assume len(U1) len(U2)
Another simple algorithm (that works)
12
The case of two agents: take 2
Swapping phase:
1. Swap pieces Y,Z of equal length where agent 1 owns Y, agent 2 owns Z, YX2, ZX1
2. Swap pieces Y,Z of equal length where agent 1 owns Y, agent 2 owns Z, YX2, ZX12
3. If there are still pieces of X2 owned by agent 1, give them to agent 2
U1
U1 U2
X1
X2
X12
X2
Initialization phase:
1. Discard [0,1]\U1U2
2. Make a mark at the beginning and end of each desired interval
3. Allocate half of each subinterval between consecutive marks to agent 1 and half to agent 2
13
Properties of the algorithm (n=2)
Envy-free and proportional: obvious
There are two cases (given len(U1) len(U2)): len(U1) len(U1U2)/2:
the agents receive a desired piece of length len(U1U2)/2 (an exact allocation)
len(U1) len(U1U2)/2: agent 1 gets U1 and agent 2 gets X2
Swapping phase:
1. Swap pieces Y,Z of equal length where agent 1 owns Y, agent 2 owns Z, YX2, ZX1
2. Swap pieces Y,Z of equal length where agent 1 owns Y, agent 2 owns Z, YX2, ZX12
3. If there are still pieces of X2 owned by agent 1, give them to agent 2
14
The algorithm is truthful (n=2) Assume agent 1 misreports U’1 we have X’1 ,
X’2 , X’12
Can assume len(U1) len(U1U2)/2 Originally got len(U1U2)/2 = (len(X1)+len(U2))/2 Now gets len(U’1U2)/2 = (len(X’1)+len(U2))/2 len(X’1) = len(X1)k increases length of piece by
k/2 but length of k is useless Crucial: Agent 1 first trades for X1
len(X’1) = len(X1)k decreases length of A1 by k/2, before all of A1 was desired
15
The general algorithm: setup Let S N, X is a piece of cake D(S,X) = (iSUi)X = portions of X desired by
at least one agent in S avg(S,X) = len(D(S,X))/|S| A1,...,An is exact wrt S,X if iS,
len(Ai)=avg(S,X) and Ai is desired by agent i For example, S={1,2} and X=[0,1] U1=U2=[0,0.2] A1=[0,0.1], A2=[0.1,0.2] is exact U1=[0,0.2], U2=[0.3,0.7] no exact allocation
16
The general algorithm
U1
Initialization:
1. SN, X[0,1]
While S
2. Sminargmin avg(S’,X)
3. Let E1,...,En be an exact allocation wrt Smin ,X
4. iSmin , AiEi
5. SS\Smin
6. XX\D(Smin,X)
S’S
U3
U2
0.39
00
0.1
0.6
17
The case of two agents revisited Assume len(U1) len(U2) Smin is either {1} or
{1,2} len(U1) len(U1U2)/2:
Smin is {1,2}, give exact allocation wrt {1,2},[0,1]
len(U1) < len(U1U2)/2: Smin is {1}, give 1 exact allocation wrt {1},[0,1] (U1), the rest to 2 in next iteration
Initialization:
1. SN, X[0,1]
While S
2. Sminargmin avg(S,’X)
3. Let E1,...,En be an exact allocation w.r.t. Smin ,X
4. iSmin , AiEi
5. SS\Smin
6. XX\D(Smin,X)
S’S
18
Exact allocations and network flow There are two
problematic steps in while loop: Step 1: computing
Smin? Step 2: existence and
computation of exact allocation?
Solution: use network flow
Initialization:
1. SN, X[0,1]
While S
2. Sminargmin avg(S,’X)
3. Let E1,...,En be an exact allocation w.r.t. Smin ,X
4. iSmin , AiEi
5. SS\Smin
6. XX\D(Smin,X)
S’S
19
Let it flow
Define a graph G(S,X) Mark beginning and end
of every interval in UiX Nodes: consecutive
markings, agents, s and t For each I, edge (s,I) with
capacity len(I) Each iN connected to t
with capacity avg(S,X) Edge (I,i) with capacity if
agent i desires interval I
s t
1
2
0.25,0.4
0.5,1
0,0.1
0.1,0.25
0.4,0.5
U1= [0,0.25][0.5,1] , U2 = [0.1,0.4]
0.5
0.15
0.1
0.1
0.15
0.450.45
20
A lemma
Lemma: Let SN, a piece of cake X. If for all S’S, avg(S’,X) avg(S,X) then there is a network flow of size len(D(S,X)) in G(S,X)
Proof: Max Flow = Min Cut Disconnect subset TS
from t at cost |T|avg(S,X) Need to additionally
disconnect len(D(S\T,X)) =|S\T|avg(S\T,X) |S\T|avg(S,X)
s t
1
2
0.25,0.4
0.5,1
0,0.1
0.1,0.25
0.4,0.5
0.5
0.15
0.1
0.1
0.15
0.450.45
21
Properties of the algorithm
Lemma: Let SN, a piece of cake X. If there exists a network flow of size len(D(S,X)) in G(S,X) then there is an exact allocation wrt S,X
If Smin minimizes avg(S’,X) then there is an exact flow wrt Smin,X, can be computed using network flow algorithms
Computing Smin is similar but more involved Theorem: assume that the agents have
piecewise uniform valuations, then the algorithm is truthful, proportional, envy-free, and polynomial-time
22
Randomized algorithms
A randomized alg is universally envy-free (resp., universally proportional) if it always returns an envy-free (resp., proportional) allocation
A randomized alg is truthful in expectation if an agent cannot gain in expectation by lying
Looking for universal fairness and truthfulness in expectation
Does it make sense to look for fairness in expectation and universal truthfulness?
Theorem: assume that the agents have piecewise linear valuations, then there is a randomized alg that is truthful in expectation, universally proportional, universally envy-free, and polynomial-time
23
Discussion
Conceptual contributions Truthful cake cutting Restricted valuations functions and tractable
algorithms Communication model
Many previous discrete algorithms can be simulated using eval and cut queries
Our algorithms are centralized Future work
Generalize deterministic algorithm Piecewise uniform valuations with minimum
interval length
24
Bibliographic notes
Yiling Chen, John K. Lai, David C. Parkes and Ariel D. Procaccia. Truth, Justice, and Cake Cutting. In the proceedings of AAAI 2010
Full version coming soon, will be posted online (rought draft available on request)
26
Properties of the algorithm
There are two problematic steps in while loop: Step 1: computing Smin? Step 2: existence and
computation of exact allocation?
Solution: use network flow / max flow min cut
Theorem: assume that the agents have piecewise uniform valuations, then the algorithm is truthful, proportional, envy-free, and polynomial-time
Initialization:
1. SN, X[0,1]
While S
2. Sminargmin avg(S,’X)
3. Let E1,...,En be an exact allocation w.r.t. Smin ,X
4. iSmin , AiEi
5. SS\Smin
6. XX\D(Smin,X)
S’S