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

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 fairness Minimize 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 =

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 agents They report speeds to a mechanism and get assigned works w i and payments The assignment must be monotone, else agents might lie (s 1,…,s i,….,s m )  (w 1,….,w i,…,w m ) (s 1,…,s i ’,….,s m ) Increase in s i no decrease in w i !  (w 1 ’,….,w i ’,…,w m ’)

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 x Truth = x: extra cost of A for bidding y Motivate 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+B Payment 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 value To 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 load Cover: 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 mechanisms Assumption: agents are risk-neutral Profit of M with probability 1/M means expected profit 1 Humans 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 assignment Calculate simple lower bound on optimal makespan Assign jobs machine by machine (fastest first) and fill them up to makespan level Last job on each machine may be split over two machines Each machine gets at most two partial jobs To get a valid assignment, we can put every split job on its first machine Simple 2-approximation! 21

... But not monotone Jobs 5,4,2,1 rounding 7 4 1Speeds rounding Speeds

Randomized rounding Solution: use randomized rounding Every 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 bits We 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 up Only 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 makespan QPTAS = almost but not quite polynomial time 24

Achieving a deterministic monotone PTAS seemed much harder Christodoulou & 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 G m machines sorted by speed (fastest first) n jobs sorted by size (largest first) Algorithm: for each machine assign 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 A We 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/2 Do geometric search Initial upper bound is U = 4A/3 Initial lower bound is L = A/2 Guess value G = (UL) 1/2 30

31 Sorted Next Cover For each guess value, we run NC We stop the search when We use geometric search since we want to have a bound on the ratio U/L Geometric search is the fastest way to get this

32 Sorted Next Cover Finally, we need to assign the jobs to the actual (related) machines We use the job sets that NC creates We assign them to machines in sorted order: fastest machine gets largest set This ensures monotonicity

33 Monotonicity The job sets do not depend on speeds They are created for identical machines If a machine claims to be faster than it really is, it can only get a larger set If 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 i NC 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

35 Approximation ratio At most m : (complicated) proof by induction This 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 vector We 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 assignment Test this assignment on actual bid vector Use best assignment found We need to limit the number of possible bid vectors 37

38 Monotone FPTAS [AAS05] Round bids up geometrically Bid = announced cost per unit load Very high bids are cut off Such bids correspond to extremely slow machines These are easy to cover: only one job is needed Maximum rounded bid is

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 work Test all assignments on actual bids Return the (lex. smallest) optimal one Works for makespan [AAS05] and cover [EvS08] Only works for constant m

Technique 5: optimize over limited set 40

Optimizing over a limited set A main problem is the existence of “tiny” jobs Usually, in a PTAS, we group jobs below a certain threshold size, and don’t use their exact size in calculations Furthermore, we round job sizes to have only a limited number of different job sizes Monotonicity 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 machines To deal with tiny jobs, these were rounded using a much finer coarsity than the rounding of machine speeds Blocks of tiny jobs were always moved towards faster machines, which were kept filled up to makespan level Then use dynamic programming Special 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 them Tiny jobs means uncertain workload Monotonicity 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 classes Thus 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 makespan cover p-norm No special cases No 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!