Techniques for truthful scheduling

Rob van Stee

Max Planck Institute for Informatics (MPII) Germany

2

Overview

Algorithmic mechanism design

Machine scheduling

Monotonicity

Monotone approximation algorithms

3

Approximation algorithms

Input is given (correctly)

Output is controlled by algorithm

Problem is to get efficiently from input to output

Note: efficient means fast! (polynomial-time)

Performance measure: approximation ratio

)()(max)(IOPTIALGALGR I

4

Economics

Correct data is not directly available

Output is not controlled: agents cannot be told what to do

Algorithmic mechanism design: [NR99]

Optimize some function Not necessarily social welfare or profit of seller / mechanism

Agents´ preferences and goal of mechanism are tied to secret data of agents

5

Today: One-parameter agents

Output: set of loads placed on the agents

Private data: cost per unit load

Goal of agent: maximize profit = payment – cost

Goal of mechanism: optimize some function of the loads

6

Machine scheduling

m related machines (controlled by agents)

n jobs must be assigned to the machines

Possible goals:

Minimize maximum load (makespan)maximize minimum load (cover)

Max-min fairnessMinimize p-norm

7

Motivation for covering

Fair division: give as much as possible to the agent that gets the least

Each agent should contribute to the work: egalitarian division of chores

Some systems are only alive (productive) if all machines are alive

Jobs = batteries

Backup on parallel harddisks: backup capacity = minimum load

8

Cover vs. makespan 1

Low makespan often good cover

Optimal schedules can be different!

Input optimal opt. cover makespan=18 =15

6

13 9 9 6 6 6 13 9 6

9 6

13 9 9

66 6

9

Cover vs. makespan 2

A good approximation for makespan may be very bad for cover!

Optimal makespan = optimal cover

Cover of this schedule

Motivation for p-norm

Another way of allocating jobs “reasonably”

Bansal and Pruhs:

“The standard way to compromise between optimizing for the average and optimizing for the worst case is to optimize the p-norm, generally for something like p = 2 or p = 3.”

10

11

Monotonicity and truthfulness

Machines are controlled by selfish agentsThey report speeds to a mechanism and get assigned works wi and paymentsThe assignment must be monotone, else agents might lie

(s1,…,si,….,sm) (w1,….,wi,…,wm)

(s1,…,si’,….,sm)

Increase in si no decrease in wi!

(w1’,….,wi’,…,wm’)

12

Monotonicity and truthfulness

Monotonicity is necessary and sufficient

That is, given that the allocation is monotone, truthtelling is a dominant strategy for the agents

We can define payouts based on the allocation curve (graph of allocation as a function of reported speed)

Allocation must be monotone

13

Truth = y: save A+B by bidding xTruth = x: extra cost of A for bidding yMotivate truthfulness: payment for bidding y instead of x should be at least A+B, at most A...

Overbidding does not help

14

Bid x instead of true t_i: cost decreases by A, payment by A+BPayment to agent = constant – marked area

Technique 1: fixed ordering of machines

15

Technique 1: fixed ordering of machines

Often there are multiple schedules which achieve the optimal objective valueTo achieve monotonicity, we need a fixed way to choose between such schedules[AT01]:

use a fixed ordering for the machines (independent of speeds!)use the lexicographically minimal optimal schedule

What happens if some machine (agent) claims to be faster?

16

17

Monotonicity

If it is not the bottleneck, nothing changes

Makespan: bottleneck = machine with maximum loadCover: bottleneck = machine with minimum load

If there existed a lexicographically smaller optimal assignment with the new speed, it would have been optimal previously, a contradiction

Monotonicity

Proof for makespan objective:

If machine i is bottleneck, it will get less work (objective= makespan!) or the same work

If original assignment is still the best, amount allocated to i does not change, has load C´ (less than before)

If another assignment is now better, machine i must get less work to get a load below C´

18

Technique 2: randomization

19

Technique 2: randomization

We can use randomization in our mechanismsAssumption: agents are risk-neutral

Profit of M with probability 1/M means expected profit 1Humans are more likely to say: most likely profit = 0

Expected profit of the agents should be monotone

We get mechanisms that are truthful in expectation (not universally truthful)

20

Example: makespan

Idea: use fractional assignmentCalculate simple lower bound on optimal makespanAssign jobs machine by machine (fastest first) and fill them up to makespan levelLast job on each machine may be split over two machines

Each machine gets at most two partial jobsTo get a valid assignment, we can put every split job on its first machineSimple 2-approximation!

21

... But not monotone

22

5

2

2

2

1

Jobs 5,4,2,1

rounding

7 4 1Speeds

5

4

2 17 4 1

5

2.1

1.9

2

0.8

rounding

7 3.9 1Speeds

5

4

21

7 3.9 1

Randomized rounding

Solution: use randomized roundingEvery partial job gets rounded to machine i with probability proportional to the fraction assigned to machine i

Each machine has at most two partial jobs, so gets at most 2 extra jobs We have a 3-approximation for every choice of the random bitsWe can show that the expected load of every machine is monotone

23

Randomized rounding

Randomized rounding is NOT used to improve the approximation ratio!

In fact, the approximation ratio goes upOnly use: achieve monotonicity

Dhangwatnotai et al.[2008]: randomized PTAS for makespan and cover objective with the same property

PTAS = arbitrarily good approximation ratio in polynomial time

Deterministic QPTAS for makespanQPTAS = almost but not quite polynomial time

24

Achieving a deterministic monotone PTAS seemed much harderChristodoulou & Kovacs achieved this for makespan [2010]Very complicated proof, several special cases

I will come back to this later

25

Technique 3: ignoring the speeds

26

27

Technique 3: ignore the speeds completely

Conflict: mechanism wants to allocate jobs based on reported speeds Agents may lie about speeds to get better assignments/profit

Possible solution: just ignore the agents’ bids completely

Example: machine covering [EvS 08]

28

Next Cover [Azar & Epstein 1997]

Input:Guess value Gm machines sorted by speed (fastest first)n jobs sorted by size (largest first)

Algorithm: for each machineassign jobs in sorted order until load G is reached

G

29

Next Cover [Azar & Epstein 1997]

If no jobs are left and some machine has load less than G, return fail

If load G is reached everywhere:Assign remaining jobs (if any) to machine m, return success

Next Cover is a 2-approximation if value of OPT is known

Sorted Next Cover [EvS 08]

Initial guess: run LPT on identical machines, gives value AWe know: (On identical machines, LPT is a 4/3-approximation [CKW92, DFL82])Next Cover is a 2-approximation if value of OPT is known [AE97]Thus, NC will succeed with guess A/2Do geometric search

Initial upper bound is U = 4A/3Initial lower bound is L = A/2Guess value G = (UL)1/2

30

3/4AOPTA

31

Sorted Next Cover

For each guess value, we run NCWe stop the search when

We use geometric search since we want to have a bound on the ratio U/LGeometric search is the fastest way to get this

LU

21

32

Sorted Next Cover

Finally, we need to assign the jobs to the actual (related) machinesWe use the job sets that NC createsWe assign them to machines in sorted order: fastest machine gets largest setThis ensures monotonicity

33

Monotonicity

The job sets do not depend on speedsThey are created for identical machines

If a machine claims to be faster than it really is, it can only get a larger setIf a machine claims to be slower than it really is, it can only get a smaller set

34

Approximation ratio

At most :SNC has load on machine iNC cannot find a cover above U on identical machines,

Optimal cover on identical machines of speed 1 is at most

Optimal cover on identical machines of speed is at most

Ratio

mss /)2( 1isL /

LU )2/1(

LL )2()2/1(2 ms

msL /)2(

mmi

im

sssssLsL

/)2(/)2()//()/)2((

1

35

Approximation ratio

At most m : (complicated) proof by inductionThis was the best known result if m is part of the input until WINE 2010 [CKvS10] (new ratio: 2+epsilon)...and the best known efficient/practical algorithm until earlier this year [O12]

Technique 4: check all possible bid vectors

36

Technique 4: try all possible assignments

We are given a bid vectorWe want to ensure that if one bid changes, that agent does not improve

Idea (Andelman, Azar, Sorani 05):for every possible bid vector, find best assignmentTest this assignment on actual bid vectorUse best assignment found

We need to limit the number of possible bid vectors

37

38

Monotone FPTAS [AAS05]

Round bids up geometricallyBid = announced cost per unit load

Very high bids are cut offSuch bids correspond to extremely slow machinesThese are easy to cover: only one job is neededMaximum rounded bid is

1)1( l

39

Monotone FPTAS [AAS05]

Apply classical FPTAS to all possible bid vectors

Sort output assignment such that i th fastest machine gets i-th largest amount of workTest all assignments on actual bidsReturn the (lex. smallest) optimal one

Works for makespan [AAS05] and cover [EvS08]Only works for constant m

))1(,...,)1(( 1 mii jli j 1,...,0

Technique 5: optimize over limited set

40

Optimizing over a limited set

A main problem is the existence of “tiny” jobsUsually, in a PTAS, we group jobs below a certain threshold size, and don’t use their exact size in calculationsFurthermore, we round job sizes to have only a limited number of different job sizesMonotonicity is an exact requirement!

41

Optimizing over a limited set

The PTAS for makespan [CK10] does the following.

Instead of rounding jobs, always use a fixed order to allocate them to machinesTo deal with tiny jobs, these were rounded using a much finer coarsity than the rounding of machine speedsBlocks of tiny jobs were always moved towards faster machines, which were kept filled up to makespan level

Then use dynamic programmingSpecial case for last machines...

42

Optimizing over a limited set

What about other objective functions?Consider covering

Bottleneck machines now collect tiny jobs instead of getting rid of themTiny jobs means uncertain workloadMonotonicity argument breaks down

43

Optimizing over a limited set

We found a way to exactly represent schedules where the job size ratio on a machine can be unbounded (!)Idea: not every job size can occur on a machine, only a polynomial number of classesThus we completely avoid “tiny” jobs with uncertain (rounded) size

This is sufficient to get very close to optimality:For every optimal schedule, a “nearby” highly structured schedule exists with the above property

We look for this structured schedule using dynamic programming

44

New results

This works for every objective function that is a “nice” function of the loads

ELvS12 (arxiv 15 July 2012): deterministic monotone PTAS for

makespancoverp-norm

No special casesNo need to round speeds (!)Objective function only goes into the dynamic program

45

Summary / open questions

We can approximate any nice objective that is based on the loads arbitrarily well

This basically resolves truthful one-parameter scheduling

What is the next interesting one-parameter/simple problem?

General problem: how much more difficult is it to solve (one-parameter) problems truthfully than to solve them classically? So far only separations known for fairly difficult problems 46

47

Thank you!