non-linear objectives in mechanism design shuchi chawla university of wisconsin – madison focs...

Non-linear objectivesin mechanism design

Shuchi Chawla

University of Wisconsin – Madison

FOCS 2012

Shuchi Chawla: Non-linear objectives

So far today…

Revenue & Social Welfare

This talk:

Non-linear functions of type & allocation

Question: how well can we optimize in strategic settings?

Do Bayesian assumptions help?


Algorithmic mechanism design

Three desiderata: Computational efficiency Incentive compatibility Optimize/approximate objective

Main theme in AMD: all three not always achievable together

What should we give up?


AMD tradeoffs

Overall OPT

OPT-IC

OPT-IC+E

OPT-E

Black-box

Social welfare has gap=1

Bayesian social welfare has small gap

Standard approximation

question

Social welfare can have large gap,

e.g. comb. auctions


Social welfare has gap=1

Bayesian social welfare has small gap

AMD tradeoffs

Overall OPT

OPT-IC

OPT-IC+E

OPT-E

Black-box

Question 1: OPT vs OPT-IC gap for multi-parameter non-linear

objectives

Question 2: Black-box reductions for single-parameter monotone

objectives

Single-parameter: each agent has a single value

Monotone objectives: unilateral increase in an agent’s value causes OPT to allocate more to the agent

IC condition: unilateral increase in an agent’s value results in larger allocation

All single-parameter “monotone”

objectives have gap=1

Prior-free

Bayesian (sometimes)


Rest of this talk

Part I

The makespan objective

Impossibility of black-box reductions for makespan

Part II

Bayesian truthful approximations for makespan

Other non-linear objectives; Open problems


Part I.1: Minimizing makespan


Scheduling to minimize makespan

n jobs, m machines

Jobs have different runtimes on different machines

Makespan = completion time of last job

J1 J2 J3 J4

M1

M2

M3

Makespan“Unrelated instance”


Scheduling to minimize makespan

Strategic setting [Nisan Ronen’99]:

Machines are “selfish workers”; jobs’ runtimes are private

Mechanism = (schedule, payments to machines)

Machines’ objective: maximize payment – work done

Want assignment+payments to induce truthtelling


Why makespan?

Important CS problem

Captures the difficulty with non-linear objectives

A single agent can disproportionately affect objective

Has received the most attention in AGT


J1 J2 J3 J4

M1

M2

M3

Single-parameter makespan

Each machine has a speed; each job has a size

Runtime of job j on machine i = (size of j)/(speed of i)

Monotone objective

Makespan“Related instance”


A history of prior-free scheduling

Truthful approximations for related machines Archer-Tardos’01: constant approx Dhangwatnotai et al.’08: PTAS

Unrelated machines: upper & lower bounds Nisan-Ronen’99: m approximation Nisan-Ronen’99: lower bound of 2 Christodoulou et al.’07: 2.41; Koutsoupias-Vidali’07: 2.61 Mu’alem-Shapira’07: randomized, fractional mechanisms Ashlagi-Dobzinski-Lavi’09: lower bound of m for anonymous

mechanisms

Overall OPT

OPT-IC

OPT-IC+E

OPT-E


Bayesian model for scheduling

Unrelated setting:Running time of every job on every machine

drawn independently from known distribution

Related setting:Speed of every machine drawn

independently from known distribution; jobs sizes fixed

Objective: Expected min makespan


Part I.2: Black-box transformations


Black-box transformations

Transformation

Algorithm

Input vAllocation x

Payment p

GOAL: for every algorithm, transformation preserves quality of solution and satisfies incentive compatibility.

(cf. Nicole’s talk)


Black-box transformations

Social welfare: can transform any approx. algorithm into BIC mechanism with “no” loss in expected performance. [Hartline-Lucier’10, Hartline-Kleinberg-Malekian’11, Bei-Huang’11]

Is this possible for other objectives?

Makespan: For any polytime BIC transformation, there is a makespan problem and algorithm such that mech.’s expected makespan is polynomially larger than alg.’s.[C.-Immorlica-Lucier’12]

NO!


Single-parameter makespan

v1 v2 v3 v4 v5 v6 v7 v8

x1

m machines,machine i has speed vi ~ Fi

n jobs,size of job j is xj

x2 x3

x4

collection F of feasible assignments


Proof outline

Define makespan instance (feasibility constraints, value distribution).

Find algorithm with low expected makespan.

Use monotonicity condition to show any BIC transformation has high expected makespan.

Key issue: Transformation must rely on algorithm to understand/satisfy feasibility constraint

That is, transformation must return an allocation that it observes the algorithm return

Higher speed ⇒ higher expected load


Makespan Instance

feasibility set F = {at most one job per machine}

v1 v2 v3 v4 v5 v6 v7 v8

xm/2

m machines, speeds vi ~ Uniform{low = 1, high = α}

x2x1

xkx2x1

m/2 jobs, small size xj = 1

m1/2 jobs, large size xj = α


Approximation Algorithm

1. If (m/2 ± m3/4) machines report high speed, assign large jobs to fast machines (at random) assign small jobs to slow machines (at random) assign NO job to all remaining machines

2. Else assign all jobs randomly


Approximation Algorithm

high speeds low speeds

Note 1: By Chernoff, expected makespan is low.

Note 2: Expected allocation is not monotone.


Transformation

To fix non-monotonicity, must more often:

1. allocate nothing to low speed machines, or

2. allocate something to high speed machines.


Transformation

1 1 1 1 α α α α

Query v’: pretend some low machines are high and vice versa...

Input v:

α α α α 1 1 1 1

Each “fast” machine gets large job with probability m-1/2

then with high probability, makespan is high.


Transformation

1 1 1 1 α α α α

Query v’: pretend number of high machines deviates from expectation..

Input v:

1 1 1 1 1 1 1 1

Each machine gets large job with probability m-1/2

then with high probability, makespan is high.


Recap and other results

For any BIC transformation, there is an alg. such that the transformation’s makespan is polynomially larger than the algorithm’s even when the algorithm is a constant approximation

What about other non-linear functions? Ironing doesn’t work Gap increases with non-linearity

[C.-Immorlica-Lucier’12]

Non-linear objectivesin mechanism design

Shuchi Chawla

University of Wisconsin – Madison

Part II


Recap of part I

A representative non-linear objective: makespan

Black-box transformations are essentially impossible for makespan: objective function increases by polynomial factor

Overall OPT

OPT-IC

OPT-IC+E

OPT-E

Black-box


Part II.1: Bayesian approximation

for makespan


Recall: scheduling to minimize makespan

n jobs, m machines

Jobs’ runtimes drawn from known indep. distributions

Makespan = completion time of last job

Prior-free setting: any anonymous truthful mechanism is at best an m approximation.

J1 J2 J3 J4

M1

M2

M3

Makespan


A truthful mechanism: MinWork

For every job: Assign the job to the machine that reports the lowest

runtime Pay the machine the job’s running time on its “second best”

machine m’

“Second-price” payments: induce truthtelling

Makespan ≤ sum of best runtimes of all jobs ≤ total work done in optimal schedule

≤ m x optimal makespan

⇒ m-approximation to makespan

Shuchi Chawla: Bayesian scheduling 31

Overcoming the lower bound

Ashlagi et al.’s lower bound of m for makespan Ordered instance: machine i is better than machine i+1

for all jobs Running times within 1+eps of each other Any truthful mechanism must allocate all jobs to machine

1

How do Bayesian assumptions help? Knowledge of distribution => we can penalize allocations

that are always bad for the given instance A priori identical machines: bad instances have extremely

low probability


Prior-independent approximation

Unknown Bayesian prior, but belongs to some “nice” family

In particular, the runtime of a job j is identically distributed on every machine. That is, machines are a priori identical However, any instantiation of runtimes is an unrelated

instance

Result: There exists a truthful prior-independent mechanism that achieves an O(n/m) approximation to expected makespan (*) [C.-Hartline-Malec-Sivan’12]

(cf. Tim’s talk)


Benchmark

Hindsight OPT For any instantiation, finds the optimal makespan

OPT1/2 Discards m/2 machines randomly For any instantiation, finds optimal makespan over

remaining machines

For many distributions, OPT1/2 ~ constant. OPT Key property: min over 2 draws ~ 2 times a single draw Includes all “MHR” distributions, e.g. uniform, exponential,

normal,…


How to design a truthful multi-parameter mechanism?

A simple powerful class: affine maximizers Maximize an appropriate linear a.k.a. affine function Essentially, an extension of VCG

For example: Can assign “costs” to some outcomes, and,

minimize total (work – cost) Can forbid certain outcomes by setting cost = ∞ Can assign more weight to the work of some agents than

that of others


The MinWork mechanism again

Essentially VCG: schedule every job on its best machine

Observe: job j’s runtime in MinWork ≤ job j’s runtime in OPT Furthermore, every job goes to a random machine

If jobs were to be distributed uniformly across machines, we would get good makespan

However, balls-in-bins analysis ⇒ some machine has O(log m/log log m) jobs


The MinWork(k) mechanism

Find a min-size matching between jobs and machines that assigns at most k jobs to each machine.

Claim: MinWork(k) is truthful

Proof: It is VCG over a restricted domain.


The MinWork(k) mechanism

Find a min-size matching between jobs and machines that assigns at most k jobs to each machine.

Claim: MinWork(k) is truthful

Claim: MinWork(10) gets a constant approximation Obs1: The schedule is almost balanced Obs2: Every job still goes to roughly its best

machine


Obs2: the last entry procedure

Fix job j and imagine adding it last in a greedy fashion.

1

2

3

4

5

6

MinWork(3) schedule for all but job j

1

2

3

4

5

6

MinWork(3) schedule sorted by j’s preferences

Machine full

Space available,so j goes here


Obs2: The last entry procedure

Fix job j and imagine adding it last in a greedy fashion.

The probability that j goes to one of its top i machines is at least 1-(1/k)i

MinWork(k) places j in an even better position

Key claim: Placing j on its ith best machine is no worse than placing 5i independent copies of j on their best (of n/2) machines


MinWork(10) analysis

Job j’s runtime in MinWork(k)

≤ max5^i independent copies j’s runtime in OPT1/2

≤ 5i times j’s runtime in OPT1/2

Here i is an exponential random variable; Note: E[5i] = constant.

∴ MinWork(10)’s makespan ≤ 10 E[maxj (j’s runtime in MW)]

≤ constant times OPT1/2

Stochastic dominance


Key technical claim

Placing j on its ith best machine is no worse than placing 5i independent copies of j on their best (of n/2) machines

Expt. 1

n copies of j’s runtime

Expt. 2

5i/2 blocks

n/2 copies of j’s runtime

ith min over n copies max over 5i mins over n/2 copies


Recap and other results

Machines a priori identical, “few” jobs O(1) prior-independent approximation:

MinWork(k) ≤ O(1) OPT1/2

Compare to Bulow-Klemperer’s result for revenue with k items: VCG ≥ O(1) OPTless k agents

Jobs are also a priori identical: multi-stage mechanisms Prior-ind. O(√log m) approximation to OPT1/2

Prior-ind. O((log log m)2) approx to OPT for MHR distributions

[C.-Hartline-Malec-Sivan’12]

Hindsight-OPT1/2

(needs regularity)


Part II.2: Other objectives & open problems


Open problems for makespan

O(1) prior-ind. approximation for non-identical jobs

Bayesian approximation for non-identical machines Will need to use the knowledge of prior Even logarithmic approx is non-trivial A potential approach: charge a prior-dependent amount

for placing each additional job on a machine

Approximation for small-support priors LP based?


Other non-linear objectives

Max-min fairness in schedulinga.k.a. load balancing

Prior-free PTAS for related setting [Epstein-

van Stee’10]

Unrelated approximation?

Max-min fairness in welfare a.k.a. the Santa Claus problem Not monotone! Single-parameter Bayesian approx?

Min makespan

10

3

3

2


Conclusions

Non-linear objectives in general much harder than social welfare

Mild stochastic assumptions can help us circumvent strong impossibility results

Multi-parameter mechanisms are difficult to understand, but “affine maximizers” is a powerful subclass.

Lots of nice open problems!

non-linear objectives in mechanism design shuchi chawla university of wisconsin – madison focs...

Documents

makespan shuchi chawla

job shuchi chawla

truthtelling shuchi

agt shuchi chawla

lucier12 shuchi chawla

different machines makespan

machines jobs

makespan problem