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