Seminar Report

Algorithmic Mechanism DesignPaul Dutting Andreas Geiger

Universitat Karlsruhe (TH) Universitat Karlsruhe (TH)

May 9, 2007

Seminar: Mechanism DesignProf. Dr. Peter Sanders

Dr. Rob van Stee

Universitat Karlsruhe(TH)Fakultat fur InformatikITI Sanders

About This Report

This report emerged from the seminar Mechanism Design held in the summer term 2007at the ITI Sanders, Universitat Karlsruhe (TH). It is based on the paper AlgorithmicMechanism Design of Noan Nisan and Amir Ronen [5]. Within this report we try topresent their results in an illustrative manner using several additional examples.

Mechanism Design is a subfield of game theory. It deals with problems in which multipleselfish agents are to be organized in a way that the global outcome meets specified goals.The organizing entity, called mechanism, tries to motivate the agents to reveal their truecharacters. This is achieved by payments given to the agents. Thus, the mechanism isable to guide the agents towards a social choice.

In the first chapter the term Mechanism Design is motivated and introduced formally.The second chapter deals with a famous concept, the Vickrey-Groves-Clarke Mechanismwhich exhibits desirable properties. Furthermore, two examples illustrate useful appli-cations. In the third chapter the Task Scheduling Problem is discussed as a MechanismDesign Problem. A lower and an upper bound for approximation mechanisms are given.The fourth chapter transfers the paradigm of randomization to the field of MechanismDesign. A randomized mechanism for the Task Scheduling Problem is proposed thatbeats the lower bound for deterministic mechanisms. Finally, the fifth chapter presentsan enhanced model, Mechanisms with Verification, in which the mechanism has furtherinformation about the behavior of the agents. Two optimal, but computationally in-tractable, mechanisms as well as a approximation mechanism are investigated.

List of Figures

1 VGC Example 1: 3 bidders, 2 cars . . . . . . . . . . . . . . . . . . . . . . 92 VGC Example 1: Drawbacks . . . . . . . . . . . . . . . . . . . . . . . . . 103 VGC Example 2: The WAD-Problem, Protagonists . . . . . . . . . . . . 114 VGC Example 2: The WAD-Problem, Graph . . . . . . . . . . . . . . . . 125 VGC Example 2: Assumption 1 . . . . . . . . . . . . . . . . . . . . . . . 126 VGC Example 2: Assumption 2 . . . . . . . . . . . . . . . . . . . . . . . 137 VGC Example 2: Assumption 3 . . . . . . . . . . . . . . . . . . . . . . . 138 MinWork Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 How to fool the MinWork Mechanism . . . . . . . . . . . . . . . . . . . . 2010 Proof of Claim 1: The quicker agent . . . . . . . . . . . . . . . . . . . . . 2311 Proof of Claim 1: Merging of two k-tasks . . . . . . . . . . . . . . . . . . 24

2

Contents

1 Introduction 41.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2 Introduction to Mechanism Design . . . . . . . . . . . . . . . . . . . . . 4

2 The VGC Mechanism 72.1 Vickrey-Groves-Clarke Mechanisms . . . . . . . . . . . . . . . . . . . . . 72.2 A first example: 3 agents are bidding for 2 cars . . . . . . . . . . . . . . 8

2.2.1 Sell the cars to the most bidding party . . . . . . . . . . . . . . . 92.2.2 Take only the opportunity costs . . . . . . . . . . . . . . . . . . . 9

2.3 A second example: The (not so famous) WAD-Problem . . . . . . . . . . 102.3.1 Assumption 1: Truthful reporting . . . . . . . . . . . . . . . . . . 122.3.2 Assumption 2: Cheating Knut . . . . . . . . . . . . . . . . . . . . 132.3.3 Assumption 3: Cheating Dishwasher . . . . . . . . . . . . . . . . 13

3 Task Scheduling 143.1 Problem description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143.2 An Upper Bound using the MinWork mechanism . . . . . . . . . . . . . 14

3.2.1 A MinWork example illustrating the Upper Bound . . . . . . . . 153.3 A Lower Bound for Task Scheduling Implementations . . . . . . . . . . . 163.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.5 Nisan and Ronen’s Conjecture . . . . . . . . . . . . . . . . . . . . . . . . 18

4 Randomized Mechanisms 194.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.2 Model of Randomization . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.3 A Randomized Mechanism for Task Scheduling . . . . . . . . . . . . . . 20

4.3.1 How to fool the MinWork Mechanism . . . . . . . . . . . . . . . . 204.3.2 The Biased MinWork Mechanism . . . . . . . . . . . . . . . . . . 214.3.3 The Randomly Biased MinWork Mechanism . . . . . . . . . . . . 22

4.4 Intermediate Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

5 Mechanisms with Verification 255.1 Model of Verification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255.2 Task Scheduling with Verification . . . . . . . . . . . . . . . . . . . . . . 275.3 Optimal Mechanisms for Task Scheduling with Verfification . . . . . . . . 27

5.3.1 The Compensation-and-Bonus Mechanism . . . . . . . . . . . . . 275.3.2 The Generalized Bonus-and-Compensation Mechanism . . . . . . 30

5.4 Polynomial-Time Mechanisms for Task Scheduling with Verification . . . 305.4.1 Bounded Scheduling Problem . . . . . . . . . . . . . . . . . . . . 315.4.2 The Rounding Mechanism . . . . . . . . . . . . . . . . . . . . . . 31

5.5 Intermediate Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

6 Summary 32

3

1 Introduction

In this section we want to introduce the term ’Mechanism Design’ following the publica-tion of Nisan and Ronen [5]. Furthermore we explain the ’Mechanism Design optimizationproblem’ associated with it and define what a mechanism looks like. In the last part ofthis section we highlight an important principle which is called the ’Revelation Principle’and is achieved by so-called ’Truthful Implementations’. We conclude by showing that ifa mechanism implements a given problem with dominant strategies there exists a truthfulimplementation as well.

1.1 Motivation

The emergence of the Internet lead to more interest for algorithms dealing with intercon-nected collections of computers. Current research examples are load balancing or routing.However most of the research was done assuming that each participant acts as instructedand information is globally known. Since this can’t be assumed in general algorithmdesign must take into account agents’ selfishness and the ownership of privately knowninformation.

Mechanism Design as a subfield of game theory deals with such problems. It tries tomotivate agents to tell the truth by giving payments to the agents. Thus the mechanismis able to guide the agents towards a social choice. Fields of application include:

◦ Network routing

◦ Load balancing

◦ Auctioning (Ebay,...)

◦ Advertisment (Google AdWordsTM ,...)

1.2 Introduction to Mechanism Design

We describe Mechanism Design as follows:

Definition 1 (Mechanism Design) Mechanism Design is a subfield of game-theory.It is the art of designing rules of a game to achieve a specific outcome. Desired outcomesare: Truthfulness, individual rationality, budget balance and social welfare. Here weconcentrate on the first desire: Truthfulness.

A simple example: The rules of german soccer games have been updated in 1995to make the game more interesting to spectators. 3 points are given to the winner, 0points to the looser and 1 point to each team if the game has been drawn. This leads toa more aggressive game.

4

Mechanism Design in the sense of Nisan and Ronen:

◦ Participants can choose between different strategies Ai

◦ A participant has private input data termed its type ti

◦ Each participant has a personal preference (utility function) ui

◦ Participants try to optimize their utility function: argmax ui

◦ Such selfish participants are termed agents i

◦ The mechanism tries to achieve a specific outcome using payments pi given to theagents to direct their decisions

Let us now define a Mechanism Design problem more formally.

Definition 2 (Mechanism Design problem) We define the following proporties:

◦ There are n agents with private types ti ∈ T i

◦ The output specification maps to each type vector t = t1...tn a set of allowedoutputs o ∈ O

◦ An agent i’s utility is ui = pi + vi(ti, o) where pi is the payment the mechanismhands to the agent and vi is an agent’s valuation given its true type (not itsdeclaration!) and the mechanism’s output.

The machanism tries to reach a specific outcome (e.g. find the shortest path in agraph). The agents are selfish and optimize their utility functions ui (e.g. time neededand money received for performing an action).

The mechanism is interested in optimizing its own global objective function. This canbe done exactly or approximately.

Definition 3 (Mechanism Design optimization problem) The output specificationis given by a positive real valued objective function g(t, o) and a set of feasible outputs F :

◦ Exact case: o = argmaxo {g(t, o)}

◦ Approx. case: O = {o ∈ F |∀o′ ∈ F : g(t, o) ≥ cg(t, o′)}for a given approximation factor c < 1.

where o and O represent the desired outputs.

The mechanism itself is composed of an output function and a tuple of payments.

5

Definition 4 (A mechanism) A mechanism m = (o, p) is composed of an output func-tion o() and a n-tuple of payments p1()...pn().

◦ It defines for each agent i a family of feasible strategies Ai

◦ An Agent can choose to perform any strategy ai ∈ Ai

◦ The mechanism provides an output function o = o(a1...an)

◦ and a payment function pi = pi(a1...an) per agent

We now define the term of an implementation with dominant strategies.

Definition 5 (An implementation with dominant strategies) We say that a mech-anism is an implementation ⇔

◦ For each agent i and each type ti there exists a dominant strategy ai ∈ Ai.(A dominant strategy maximizes an agents utility no matter which strategy each ofthe other agents has chosen.)

◦ For each tuple of dominant strategies ai...an the output o(ai...an) satisfies the spec-ification (exact or approximately).

As a special case we find the so-called Revelation Principle where an agent’s choicewill be to reveal its true value. This is what we try to achieve. We might also term sucha mechanism a ’good’ one.

Definition 6 (The Revelation Principle: A Truthful Implementation) We say thata mechanism is truthful ⇔

◦ ∀i : Ai = T i (an agent’s strategy is to report its type)

◦ ∀i : ai = ti (truth-telling) is a dominant strategy

An even more desirable property is that truth-telling presents itself as the only dominantstrategy. This means that selfish agents will act like expected, telling their true values.

Definition 7 (A Strongly Truthful Implementation) We say that a mechanism isstrongly truthful ⇔

◦ ∀i : ai = ti (truth-telling) is the only dominant strategy

In a first lemma we show an important property of mechanisms.

6

Lemma 1 (Existence of truthful implementations) If there exists a mechanism thatimplements a given problem with dominant strategies then there exists a truthful imple-mentation as well.

Proof: We simulate the strategies with the truthful implementation:

◦ We are given a mechanism m = (o, p1...pn) with dominant strategies ai(ti)

◦ We define the following mechanism now: m = (o, p1...pn) where o(t1...tn) = o(a1(t1)...an(tn))and pi(t1...tn) = pi(a1(t1)...an(tn))

As one can easily examine this new mechanism m is a truthful implementation.

2 The VGC Mechanism

In this section we introduce the Vickrey-Groves-Clarke Mechanism. We show what spec-ifications a mechanism has to satisfy to belong to the VGC family or to the weightedVGC family and prove that such a mechanism is truthful. Furthermore we illustrate themechanism using two examples: On the one hand we apply it to an auctioning problemand on the other hand we introduce a simple shortest path problem.

2.1 Vickrey-Groves-Clarke Mechanisms

The Vickrey-Groves-Clarke (VGC) Mechanism is one of the most important positive re-sults in mechanism design. It is a generalization of the famous Vickrey auction wherebidders submit written bids without knowing the bid of the other people in the auc-tion. In the Vickrey auction the highest bidder wins, but the price paid is thesecond highest bid. The VGC mechanism applies to mechanism design maximiza-tion problems where the objective function is simply the sum of all agents’ valuations:g(t, o) =

∑i v

i(ti, o). This property is called ’Utilitarian’.

Definition 8 (Utilitarians) We say that a maximization mechanism design problem isutilitarian if its objective function satisfies g(t, o) =

∑i v

i(ti, o).

To ’reduce’ a mechanism to the VGC family (which has very nice properties indeed) thatmechanism has to satisfy two properties: On the one hand it must be ’Utilitarian’ andon the other hand it must define payment functions for the agents as below.

Definition 9 (The VGC family) A mechanism m(o(t), p(t)) belongs to the VGC fam-ily ⇔

◦ o(t) ∈ argmaxo(∑n

i=1 vi(ti, o)) = argmaxo g(t, o)

◦ pi(t) =∑

j 6=i vj(tj, o(t)) + hi(t−i)

where hi is an arbitrary function of t−i.

The ’nice property’ of a mechanism we have ’reduced’ to the VGC family is that it istruthful.

7

Theorem 1 (Groves, 1973) A VGC mechanism is truthful.

Proof: Let us assume that truth-telling is not a dominant strategy! ⇒ There existsa di so that the following holds (∗):

g(t, o(d−i, ti)) =∑n

j=1 vj(tj, o(d−i, ti)) = vi(ti, o(d−i, ti)) +∑n

j=1,j 6=i vj(tj, o(d−i, ti)) =

vi(ti, o(d−i, ti))+pi(d−i, ti)−hi(d−i) <∗ vi(ti, o(d−i, di))+pi(d−i, di)−hi(d−i) = vi(ti, o(d−i, di))+∑nj=1,j 6=i v

j(tj, o(d−i, di)) =∑n

j=1 vj(tj, o(d−i, di)) = g(t, o(d−i, di))

⇒ Contradiction to: o(t) ∈ argmaxo g(t, o)

The VGC idea can be extend to a more general family of mechanisms: The weightedVGC family.

Definition 10 (Weighted Utilitarians) We say that a maximization mechanism de-sign problem is weighted utilitarian if its objective function satisfies g(t, o) =

∑i β

ivi(ti, o).

Definition 11 (The weighted VGC family) A mechanism m(o(t), p(t)) belongs tothe weighted VGC family ⇔

◦ o(t) ∈ argmaxo(∑n

i=1 vi(ti, o)) = argmaxo g(t, o)

◦ pi(t) = 1βi

∑j 6=i β

jvj(tj, o(t)) + hi(t−i)

where hi is an arbitrary function of t−i.

Proof: The prove can be done in analogy to the non-weighted case.

2.2 A first example: 3 agents are bidding for 2 cars

As a first example of a VGC Mechanism application we show a auction where 3 bidders(1,2,3) are bidding different sums for (different number of) cars. We want to sell the carsto the most bidding party (which in this case can consist of 1 or 2 bidders) and thereforewe want the agents to tell the truth.Thus the agents’ types are t1 = 400, t2 = 250, t3 = 600 and feasible outputs areF = {{1, 2} , {3}}

The agents’ valuations: Our agents are assumed to be able to resell their cars for themoney indicated by their type in their home country (e.g. cars are less worth in Moscowthan in Berlin). Therefore their valuations are:

vi =

{ti if agent i is a winner0 else

Now, what could a simple auction mechanism look like?

8

Figure 1: 3 bidders (let us type them 1,2 and 3 are bidding for 2 cars. 1 and 2 bid for 1 car each and 3bids for 2 cars the amount depict in this figure. The auctioneer wants to sell both cars. It can do so byassigning one to 1 and 2 each or by assigning both to bidder 3. Remark: Similarities with individuals incommon live are unintended and occured by pure chance.

2.2.1 Sell the cars to the most bidding party

What will happen? Since our agents want to make some profit they won’t bid their truevaluation, but a bit less (let’s say -100). Thus we get the following agents’ declarations:d1 = 300, d2 = 150, d3 = 500. Thusw note that our mechanism is not a truthful imple-mentation! The cars will be sold to agent 3 for 500 bucks regardless of the fact that agent1 and agent 2 are bidding more than agent 3.

Can we do any smarter?

2.2.2 Take only the opportunity costs

Sell the cars to the most bidding party and take only the opportunity costs that thewinner’s presence introduces to all the other bidders! (Opportunity costs for agent iequals the second highest bid minus that part of the highest bid which doesn’t includeagent i itself.)

Since Opportunity costs are lower than the highest bid the agents will even make profit bybidding their real values. The agents’ declarations are: d1 = 400 d2 = 250 d3 =600. The cars will be sold to agent 1 and agent 2 who bid 650 bucks together. Neverthelessthe agents’ real payments qi are lower: q1 = q3 − q2 = 350 q2 = q3 − q1 =200 q3 = 0

Why does our mechanism belong to the VGC family? Up to now we didn’t showwhy our algorithm belongs to the VGC family and therefore is a truthful implementation.We will make up for this now:

◦ g(t, o) =∑n

i=1 vi(ti, o)

9

◦ o(t) ∈ argmaxo g(t, o)

◦ pi(t) =∑

j 6=i vj(tj, o(t))− (−hi(t−i)) = −qi(t)

where −hi(t−i) is the second highest bid.

Note that pi is the ’negative’ payment the auctioneer hands to the agents and qi = −pi

is the ’real’ payment our agents have to pay to the auctioneer.

Drawbacks of the VGC algorithm: The VGC mechanism’s direct transfer to anauctioning problem unfortunately also leads to some drawbacks. We will outline one ofthem now by modifying our example’s parameters. Our agents’ types are now t1 = 400,

Figure 2: This example depicts essentially the same as depict in Figure 1. Agent 1 and Agent 2 arethe winning parties, too. Nethertheless the agent’s types have changed a little bit.

t2 = 400, t3 = 300. The feasible outputs are the same as before: F = {{1, 2} , {3}}.

Results of this VGC auction: We use the same VGC auction mechanism as before.Therefore the agents bid their types truthfully: d1 = 400 d2 = 400 d3 = 300. Thecars will be sold to agent 1 and agent 2 who bid 800 bucks together. But note what willhappen now. What is the payment our agents have to pay to the auctioneer?q1 = q3 − q2 = −100 q2 = q3 − q1 = −100 q3 = 0

In this case our auctioneer will give the 2 cars away with some extra 200 bucks. Themechanism is truthful, but the auctioneer won’t be happy!

2.3 A second example: The (not so famous) WAD-Problem

The (not so famous) ”Washing-up and drying the dishes”-Problem (WADP) consists ofthe question: How to assign the task ”wash-up and dry the dishes” to Knut, Ilse and thedishwasher so that the overall time needed to perform this task is minimal. We assumethe times needed to do the job like depict in Figure 3.

10

Knut Ilse Dishwasher

Figure 3: The ”Washing-up and drying the dishes”-Problem knows 3 agents which represent connectionsin a bi-connected graph. Knut is able to wash the dishes in tK = 5 minutes. Ilse is able to dry the dishesin tI = 5 minutes. The Dishwasher can wash and dry the dishes in tD = 40 minutes.

The agents valuations. We define the valuation of an agent x as following:

vx =

{−tx if x is part of the chosen washing path0 else

This means that each agent’s valuation is 0 if it is not chosen or the negative time itneeds to finish its job, if it is chosen. All agents try to maximize their utility. The utilityfunction of agent x is

ux = vx + px

with px being the payment defined by our VGC Mechanism.

There exist 2 feasible paths for the WAD-Problem. To implement a truthfulmechanism we pay some pocket money (pK , pI) to Knut and Ilse and spend some time(pD) for cleaning the dishwasher. Since time is money we say that we pay out Knut,Ilse and the Dishwasher in time units according to the following rules.

The mechanism’s payment function. We define the mechanism’s payment func-tion for agent x as

px =

{dG|tx=∞ − dG|tx=0 if x is part of the chosen washing path

0 else

where dG|tx=∞ is the duration of the shortest washing path which doesn’t include agentx and dG|tx=0 stands for the length of the shortest washing path when agent x’s time isassumed to be 0. Note that dG|tx=∞ and dG|tx=0 refer to the reported times (which wedenote as txr ). The real times (tx) are private knowledge to the agents.

Relationship to the VGC mechanism. Our mechanism is a VGC mechanism:

◦ Our mechanism minimizes the path length (time needed) which corresponds tomaximizing the objective function g(o, t) =

∑i v

i(ti, o) since vi = −ti for all agentsbelonging to the path.

11

Figure 4: As illustrated in this shortest-path graph there exist 2 feasible paths for the problem.Either Knut has to wash the dishes and Ilse will dry them afterwards (needing 10 minutes at all) orthe dishwasher does all the work in 40 minutes. So our goal is to assign the work to Knut and Ilse.Unfortunately we don’t know the agents’ real types. Fortunately we have the VGC Mechanism!

◦ Our mechanism belongs to the VGC-family since identifying hi(t−i) with dG|tx=∞and

∑j 6=i v

j(tj, o(t)) with dG|tx=0 results in pi(t) =∑

j 6=i vj(tj, o(t)) + hi(t−i) =

dG|tx=∞ − dG|tx=0

2.3.1 Assumption 1: Truthful reporting

Figure 5: Each agent reports its true time (depict in green).

Each agent reports its true time. ⇒ Reported times: tDr = 40, tKr = 5, tIr = 5tKr + tIr = 10 < tDr = 40 ⇒ output o = A → B → C. This means that the mechanismchooses Knut and Ilse for washing the dishes!

12

⇒ Valuation: vD = 0 vK = −5 vI = −5⇒ Payment: pD = 0 pK = 35 pI = 35⇒ Utility: uD = 0 uK = 30 uI = 30⇒ Maximal utility!

2.3.2 Assumption 2: Cheating Knut

Figure 6: Knut is cheating (depict in green).

Knut is cheating. ⇒ Reported times: tDr = 40, tKr = 36, tIr = 5tKr + tIr = 41 > tDr = 40 ⇒ output o = A→ C. This means that the mechanism choosesthe dishwasher for washing!

⇒ Valuation: vD = −40 vK = 0 vI = 0⇒ Payment: pD = 41 pK = 0 pI = 0⇒ Utility: uD = 1 uK = 0 uI = 0⇒ Knut won’t do that!

2.3.3 Assumption 3: Cheating Dishwasher

Figure 7: The Dishwasher is cheating. (depict in green).

The Dishwasher is cheating. ⇒ Reported times: tDr = 9, tKr = 5, tIr = 5tKr + tIr = 10 > tDr = 9 ⇒ output o = A → C. This means that the mechanism chooses

13

the dishwasher for washing!

⇒ Valuation: vD = −40 vK = 0 vI = 0⇒ Payment: pD = 10 pK = 0 pI = 0⇒ Utility: uD = −30 uK = 0 uI = 0⇒ The Dishwasher won’t do that!

We learn by example that an agent participating in a task- scheduling problem solvedby a VGC mechanism maximizes its utility by telling the truth (as expected). Cheatingeither doesn’t change its utility (if the output doesn’t change) - since its payment onlydepends on the others type declarations and its utility doesn’t change no matter whattype it is declaring - or leads to a decreasing utility. Thus agents are forced to tell thetruth if they want to maximize their utility and the mechanism is truthful.

3 Task Scheduling

The task scheduling problem encloses the question of assigning a set of tasks to a set ofagents (who are able to perform these tasks). The goal is to minimize the make-spanwhich is the overall time needed to perform all tasks by the set of agents. Note that thisis not the sum of all minimal execution times since all agents are able to work in parallel.This fact is responsible for the difficulty of the problem.

3.1 Problem description

We define the task scheduling problem as follows:

◦ Allocate k tasks to n agents

◦ tij is the time needed by agent i to perform task j

◦ Feasible outputs are all partitions x = x1...xn where xi is the set of tasks allocatedto agent i

◦ Agent i’s valuation is vi(x, ti) = −∑j∈xi tij

◦ Our goal is to minimize the make-span g(x, t) = maxi∑

j∈xi tij

We denote a mechanism for the task scheduling problem by m = (x(t), p(t)), where x isthe allocation algorithm (former output) and p stands for the payment.

3.2 An Upper Bound using the MinWork mechanism

Our first goal is to determine an upper bound. This is achieved by looking at a verysimple mechanism (the MinWork mechanism) which assigns each task to the agent whois able to perform it in minimal time. As we will see this leads to an upper bound.

Definition 12 (The MinWork Mechanism) The idea is to minimize the totalwork done. This is no very good solution since our agents are able to work in par-allel.

14

◦ Each task is allocated to the agent who is capable of doing it in a minimal amountof time.

◦ Each agent is given payment equal to the time of the second best agent forevery task: pi(t) =

∑j∈xi(t) mini′ 6=it

i′j

We will now show that MinWork is a truthful n-approximation mechanism.

Theorem 2 (MinWork) MinWork is a truthful n-approximation mechanism.

Proof: We first prove that MinWork is an n-approximation. In the worst caseone agent (i) offers the best execution times for all tasks: ∃i∀i∀j : tij ≤ tij. Thus

g(x(t), t) ≤ ∑kj=1 minit

ij holds for MinWork.

On the other hand an optimal algorithm can never be faster than doing all k jobs in min-imal execution times on all n machines in parallel. Therefore g(opt(t), t) ≥ 1

n

∑kj=1 minit

ij

holds for an optimal allocation opt(t).

Together we get: g(x(t), t) ≤ n× g(opt(t), t).

Proof: We show now that MinWork belongs to the VGC family (⇒ is truthful), too:

◦ The output maximizes∑n

i=1 vi(ti, x) = −∑ni=1

∑j∈xi tij.

◦ On the other hand the payment function can be split up:pi(t) =

∑j∈xi(t) mini′ 6=it

i′j

=∑k

j=1 mini′ 6=iti′j −

∑j /∈xi(t) mini′ 6=it

i′j

= −∑j /∈xi(t) mini′ 6=it

i′j +

∑kj=1 mini′ 6=it

i′j

= −∑i′ 6=i

∑j∈xi′ ti

′j + h−i =

∑i′ 6=i

(−∑

j∈xi′ ti′

j

)+ h−i

=∑

i′ 6=i vi′(ti

′, x) + h−i

3.2.1 A MinWork example illustrating the Upper Bound

We have 2 agents (Homer, Marge) and 2 tasks (eating, iron). Let’s assume our agentshave reported their types truthfully. Our mechanism wants to reduce the overall time.We use the MinWork mechanism described above.

Since Homer (agent 1) offers the shortest time for performing both tasks the MinWorkmechanism assigns both task to it. Thus g(x(t), t) = t11 + t12 = 10. It would be better tohandle task 2 to Marge (agent 2): g(opt(t), t) = max(t11, t

22) = 6. Alltogether we get a

c-approximation with c = g(x(t),t)g(opt(t),t)

= 106≈ 1.67 ≤ 2.

Please note that as the ironing time of Marge goes down to 5 this approximation factorapproaches 2.

15

Figure 8: This example task consists of 2 agents (Homer and Marge) and 2 tasks (Eating and Ironing).Obviously Homer is faster in eating the donut. But he is faster in ironing, too. This is due to a shortageof thoroughness. The goal is now to dispatch the tasks to the agents so that the overall make-span islow.

3.3 A Lower Bound for Task Scheduling Implementations

We now aim at giving a lower bound for mechanisms that implement the task schedulingproblem. Due to the revelation principle (”if there exists a mechanism that implementsa problem with dominant strategies there exists a truthful implementation, too!”) itsuffices to prove the lower bound for truthful implementations. Therefore our mechanismm is always assumed to be truthful! We start with a lemma stating that the paymentoffered to an agent does not depend on its type declaration as long as the other agents’types and the allocation are fixed.

Lemma 2 (Independence) ∀i,t1,t2 : t−i1 = t−i

2 ∧ xi(t1) = xi(t2)⇒ pi(t1) = pi(t2)

Proof: Assume pi(t1) < pi(t2)! If agent i’s type is ti1 cheating by declaring type ti2would be better ⇒ Contradiction to truthfulness.

Now we define the price offered for a set of task as follows.

Definition 13 (Price offered for a set of task) Let t be a type vector and let X bea set of tasks. Then:

pi(X, t−i) =

{pi(ti, t−i) if there exists ti s.t. xi(ti, t−i) = X

0 otherwise

Furthermore the mechanism has to maximize the agent’s benefit. Otherwise the agentwill cheat in order to reach maximal benefit itself.

16

Lemma 3 (Maximization) For each type vector t and agent i there holds:

xi(t) ∈ argmaxX⊆{1,...,k} (pi(X, t−i)− ti(X))︸ ︷︷ ︸Agent i’s utility

where ti(X) is the overall time needed by agent i to perform the set of tasks X.

In order to prove our main theorem we need some further preparation.

Lemma 4 (There doesn’t exist a better allocation like the best one) Nothing elsedoes this lemma state. Let t be a type vector and let X be xi(t). For each set D 6= X oftasks the following inequalities hold:

◦ D ⊂ X ⇒ ∆i(D, X \D) ≥ ti(X \D)

◦ D ⊃ X ⇒ ∆i(X, D \X) ≤ ti(D \X)

◦ else ⇒ ∆i(L, X \ L)− ti(X \ L) ≥ ∆i(L, D \ L)− ti(D \ L)

where ∆i(A, B) is the price difference pi(A∪B, t−i)− pi(A, t−i) and L = D∩X. If a setY of tasks satisfies these inequalities sharply for all D’s, then Y = X = xi(t) (X is theonly set maximizing i’s utility).

A type modification needs to be defined, too. It assigns new type vector elements to typevectors of an agent i regarding tasks of a subset X.

Definition 14 (A type modification) Let t be a type vector, i an agent, X a set of

tasks and let α > 0 be a real number. We now denote t = t(Xi→ α) the type which we

obtain by the following case selection:

ti′

j =

{α if i′ = i and j ∈ Xti′

j otherwise

It will become easier to understand looking at this small Example:

Let’s have 2 agents and 2 tasks. Let t be t({1, 2} 2→ 0.5).

t11 = 1.5 t12 = 2.5 t21 = 0.0 t22 = 1.5

⇓t11 = 1.5 t12 = 2.5 t21 = 0.5 t22 = 0.5

W.l.o.g. we assume from now on: n = 2, k ≥ 3,∀i,j : tij = 1 and |x1(t)| ≤ |x2(t)|.This means that we have 2 agents, more than 2 tasks, both agents need one time unit toperform each of the tasks and we have more tasks assigned to agent 2 than to agent 1.We now show that a special type modification (which we need in the prove of the maintheorem) doesn’t change the current allocation.

17

Lemma 5 (An allocation invariant type modification)

0 < ε < 1, t = t(x1 1→ ε, x2 1→ 1 + ε)⇒ x(t) = x(t)

Proof: Since n = 2, it is enough to show that x1(t) = x1(t). Agent 2’s type isinvariant under transformation t → t. Thus the price offered to agent 1 remains thesame. Our transformation therefore only changes the value (time needed). x1(t) fulfillsthe inequalities of the ”best allocations” lemma above. Type transformation to t makesthe inequalities strict since 0 < ε < 1. Therefore the allocation remains the same:x(t) = x(t)

Now we are able to prove this section’s main theorem.

Theorem 3 (Basic Lower Bound) There does not exist a mechanism that implementsa c-approximation for the task scheduling problem for any c < 2.

Proof: We are discriminating 2 cases for this prove: The even and the odd case.Case 1: |x2(t)| % 2 = 0Since |x1(t)| ≤ |x2(t)| and t → t does not change the allocation there is g(x(t), t) =|x2(t)| = |x2(t)|. On the other hand an optimal algorithm puts half of agent 2’s load ontoagent 1. Therefore agent 1 is now the limiting factor for g() and we get g(opt(t), t) ≤12|x2|+ kε.

Thus we get 2× (g(opt)− kε) ≤ g(x(t), t).

Case 2: |x2(t)| % 2 = 1Since k ≥ 3 and |x1(t)| ≤ |x2(t)| it must be that |x2(t)| ≥ 3 Choosing j ∈ x2(t) arbi-

trarily and considering the new type ˆt = t({j} 2→ ε) now still yields the same allocation.

Now g(x(t), ˆt) becomes |x2| − 1 + ε. Again an optimal algorithm would ease agent 2’sburden by putting half of the heavy-weight tasks on agent 1 making it the limiting factor:

g(opt(t), ˆt) ≤ |x2|−12

+ kε.

Thus we get 2× (g(opt(t), ˆt)− kε) + ε ≤ |x2| − 1 + ε = g(x(t), ˆt)

3.4 Conclusion

Let us think back to the MinWork mechanism now! MinWork is truthful and an n-approximation to the task scheduling problem. Thus, in the case of 2 agents we havefound a 2-approximation mechanism. The previous lemma has learned us that thereexists no mechanism that implements a c-approximation for the task scheduling problemfor any c < 2!

⇒MinWork is an optimal implementation for 2 agents!

3.5 Nisan and Ronen’s Conjecture

Nisan and Ronen speculate that there does not exist a mechanism that implements ac-approximation for any c < n. They are not able to prove this conjecture, but theyshow that it is correct for two cases which they call ’additive’ and ’local’ mechanisms.

18

4 Randomized Mechanisms

A very powerful concept in the classical theory of algorithms is randomization. Follow-ing the approach of Nisan and Ronen [5] we will subsequently introduce the notion ofrandomization to the context of algorithmic mechanism design and analyze its impacton the task scheduling problem.

4.1 Motivation

In the previous section we saw a strongly truthful n-approximation mechanism for thetask scheduling problem: the MinWork Mechanism. In addition we were able to derive ageneral lower bound of 2 for the approximation factor. Hence, in the case of two agentsthe MinWork Mechanism is optimal.

In the classical theory of algorithms randomized algorithms are a common approachto either improve upon the (expected) running time of an algorithm or to improve uponits perfomance guarantees.

Thus, it is quite natural to ask whether randomized mechanisms can be used to yieldsimilar effects in the area of algorithmic mechanism design. More specifically we will tryto answer the following question in the course of this section:

Question 1 Is it possible to beat the lower bound for deterministic mechanisms for thetask scheduling problem using a randomized mechanism?

Obviously a thorough analysis of this question requires a formalization of the notion ofrandomized mechanisms. This is the topic of the following subsection.

4.2 Model of Randomization

A randomized mechanism is given by a probability distribution over similar mechanisms.In other words a randomized mechanism is a specific mechanism chosen at random outof a family {mr|r ∈ I} of mechanisms. In the simplest case there are two alternativemechanisms m1 and m2 both chosen with a probability of 0.5. As the behavior of therandomized mechanism depends on the random coin tosses it is quite natural to optimizethe expected value of the mechanisms’ particular objective functions.

Definition 15 (Randomized Mechanism) A randomized mechanism is a probabilitydistribution over a family {mr|r ∈ I} of mechanisms, all sharing the same sets of strate-gies and possible outputs. The outcome of such a mechanism is a probability distributionover outputs and payments; the problem specification must specify what output distribu-tions are required. For the case of optimization problems, the objective function on sucha distribution is taken to be the expectation g(a, t) = Er∈I(g(omr(a), t)).

Once we introduced the concept of randomization it is straightforward to transfer thenotions of dominance and truthfulness (cmp. Section 1) to randomized mechanisms:We simply require that a universally dominant (or truthful) randomized mechanism isdominant (or truthful) independently of the random coin tosses. For convenience we willsubsequently omit the word ’universally’.

19

Definition 16 (Universally Dominant Strategy) A strategy ai is called universallydominant for agent i if it is a dominant strategy for every mechanism in the supportof the randomized mechanism. A randomized mechanism is called universally truthful iftruth-telling is a dominant strategy, and strongly truthful if it is the only one.

In order to substantiate the theoretical notions introduced so far we will revise the taskscheduling problem and see how randomization can be used to improve upon the Min-Work Mechanism introduced in Section 3. In particular we will present the RandomlyBiased MinWork Mechanism of Nisan and Ronen [5].

4.3 A Randomized Mechanism for Task Scheduling

In order to understand the Randomly Biased MinWork Mechanism it is quite useful toget an intuition about how the MinWork Mechanism can be fooled.

4.3.1 How to fool the MinWork Mechanism

Let’s look at a very simple scenario: Assume that there are two kind of tasks j = 1 and 2and that there are two agents i = 1 and 2 such that the execution times of the first task(resp. second task) are t11 = 1 (resp. t21 = 1 + ε) for the first agent and t12 = 10 + ε (resp.t22 = 10) for the second agent. Assume further that there are two tasks of each kind. Asthe MinWork Mechanism allocates each task to the agent that is more efficient for thistask it allocates all requests for the first task to the first agent while it is the other wayround for all tasks of the second task. Obviously, this is not very clever as the secondtask is much more voluminous. Hence, it would be smarter to share the tasks of eachkind among the agents (as the optimal mechanism Opt would do) as the following figure(Figure 9) depicts:

agent 1

agent 2 2

time20

agent 1

agent 2

time1 10 11+e

Figure 9: Comparison of the allocation obtained by the MinWork Mechanism and the optimal mecha-nism Opt if there are two dictinct kinds of tasks i = 1 and 2 such that tasks of the first kind are executedby the first agent in 1 time unit and in 1 + ε time units on the second. Tasks of the second kind areexecuted in 10 time units by the second agent while they take 10 + ε time units when executed by thefirst agent.

Let’s quickly evaluate the makespans: tMinWork = tmw = 20 while topt = 11+ ε. Thus theapproximation factor is tMinWork

tOpt= 20

11+ε≈ 1.81 for small enough ε. Obviously this factor

gets even worse if the number of tasks or the size discrepancy increases.

20

What does this simple example teach us? Apparently, it is quite easy to enforce adisadvantageous behavior of MinWork: If the tasks are executed in roughly the sametime by both agents but sligthly quicker on one of them, then MinWork will allocate alltasks to the swifter agent eventhough it could be more beneficial to distribute the tasksamong them. Thus, it is quite natural to ask the following question(s):

Question 2 Is it possible to achieve a similar behavior as Opt with a randomized mech-anism? Should we allow some tasks to be allocated to the less efficient agent (as long asit is not much less efficient)?

4.3.2 The Biased MinWork Mechanism

Let’s first look at a (still not randomized) variant of the MinWork Mechanism: TheBiased MinWork Mechanism. This mechanism can be described as follows:

Biased MinWork Mechanism:

Parameters: A real number β ≥ 1 and a bit vector s ∈ {1, 2}Input: The reported type vectors t = (t1, t2)

Output: An allocation x = (x1, x2) & a payment p = (p1, p2)

Mechanism:x1 ← ∅; x2 ← ∅, p1 ← 0; p2 ← 0For each task j = 1..k do:

Let i = sj and i′ = 3− iIf tij ≤ β ti

′j

Then xi ← xi ∪ {j}; pi ← pi + β ti′

j

Else xi′ ← xi′ ∪ {j}; pi′ ← pi′ + β tij

Obviously, the Biased MinWork Mechanism is based on two ideas: On the one hand itdeploys a bias to avoid the effect that we observed in the previous example (see Figure9) on the other hand it uses a bit vector to indicate the ’line of sight’. The followingexample depicts how the Biased MinWork Mechanism works:

Example: Let β equal 2 and assume that there are 4 tasks. Assume further thats = (1, 1, 2, 1). Finally, let the execution times be defined as described in the followingtable:

j 1 2 3 4

t1j 1 2 1 2t2j 4 1 3 2

Let’s quickly act out this simple example: As s1 = 1 the mechanism compares t11 = 2and βt21 = 8. Consequently, the first task will be assigned to the first agent. Likewise (ass2 also equals 1) it compares t12 = 2 and βt22 = 2. Again, the task will be assigned to thefirst agent. Now s3 = 2. Hence, the mechanism checks whether t23 = 3 is smaller or equal

21

than βt13 = 2. As this is not the case the task will again be allocated to the first agent.Finally, the last task also goes to the first agent as t14 = 2 ≤ βt24 = 4.Apparently, this is not the mechanism that we hoped for. However, the subsequentsection explains how to use this mechanism to obtain the Randomly Biased MinWorkMechanism that beats the deterministic lower bound for the task scheduling problempresented in Section 3.

4.3.3 The Randomly Biased MinWork Mechanism

At the core of the Randomly Biased MinWork Mechanism is the Biased MinWork Mecha-nism presented in the previous subsection. The sole changes are that the bias β is chosenadroitly and that the bit vector s is chosen at random. More formally, we define:

Definition 17 (Randomly Biased Min Work Mechanism) The Randomly BiasedMin Work Mechanism is the distribution on biased min work mechanisms given by β =4/3, and a uniform distribution of s ∈ {1, 2}k.

We will now turn to the main result of Nisan and Ronen’s [5] analysis of the RandomlyBiased MinWork Mechanism:

Theorem 4 (Randomly Biased Min Work Mechanism) The Randomly Biased Min-Work Mechanism is a (polynomial time comnputable) strongly truthful implementationof a 7/4−approximation for task scheduling with two agents.

As no deterministic mechanism can achieve a better approximation factor than two, thistheorem clearly answers Questions 1 and 2: Randomized mechanisms can improve uponthe performance guarantees of deterministic mechanisms and allowing some tasks to beallocated to the less efficient agents obviously is a promising strategy. The precedingtheorem can be proven in two steps:

Step 1 The Randomly Biased Min Work Mechanism is strongly truthful.

Proof: We will prove an even stronger claim: The Biased MinWork Mechanism isstrongly truthful for all parameter values. Therefore we take a closer look at the utilityof agent i which is defined as ui = pi + vi(x, ti). By definition pi =

∑j∈xi

βt3−ij and

vi(x, ti) = −∑j∈xi tij. As the total utility of agent i is the sum of the utilities of each

step, we can look at each step individually. Recalling Definition 11 one can easily seethat the Biased MinWork Mechanism is a Weighted Vickrey-Groves-Clarke Mechanismwith weights {1, β} or {β, 1} depending on sj. As any Weighted Vickrey-Groves-ClarkeMechanism is truthful, the final step is to prove that truthtelling is the only dominantstrategy (see [5] for a proof).

Once we have shown, that the Randomly Biased Min Work Mechanism is strongly truthfulit is up to us to prove that it really achieves an approximation factor of 7/4:

Step 2 The allocation obtained by the Randomly Biased Min Work Mechanism is a 7/4−approximation for the task scheduling problem.

22

In order to do so, we will first ’distillate’ the hardest case: the worst case situation forthe Randomly Biased MinWork Mechanism when compared to the optimal mechanism.More specifically, one can show that the following claim holds:

Claim 1 It is enough to consider the following case:

1. For each k-task (a task j that either fulfillst1jt2j

> β ort2jt1j

> β). the efficiency

discrepany between the agents is arbitrarily close to β.

2. If opt allocates an l-task (a task j that is not a k-task) to agent i, then t3−ij /tij = β.

3. Under opt both agents have the same finishing time.

4. One of the agents is more efficient than the other on all k-tasks.

5. There are at most four tasks, where at most one k-task and at most one l-task isallocated by opt to each agent.

We will focus on the 3rd and 5th point, as they are (in the eyes of the authors) very wellsuited to depict the general idea behind the proof of this claim.

Proof: Assume by contradiction, that w.l.o.g. agent 1 finishes δ−time before agent2 (as depicted in Figure 10). If we know add an l-task j such that t1j = δ and t2j = βδ themakespan of the optimal mechanism topt remains unchanged but the makespan tbmw ofthe Randomly Biased MinWork Mechanism increases. Thus the ratio tbmw/topt increases,too. We conclude, that in order to distillate the hardest case we can concentrate onsituations where both agents have the same finishing times under opt (3rd point).

agent 1

agent 2

time

delta

Figure 10: Agent 1 finishes δ−time before agent 2.

To prove the 5th point we distinguish between k-tasks and l-tasks: First assume that twok-tasks a and b are allocated to agent i by Opt (as Figure 11 depicts). Then ’merging’a and b to c such that tic = tia + tib obviously leaves topt unchanged. Likewise tbmw isnot affected by this replacement as the 4th point states that when concentrating on thehardest case one agent is more efficient than the other on all k-tasks. Hence a and b areallocated to the same agent by the Randomly Biased MinWork Mechanism.Let’s consider two l-tasks a and b. We distinguish four cases A to D.

Case A: W.l.o.g. agent i finishes after agent 3 − i regardless of how a and b areallocated. Let Y be an allocation of all tasks except a and b. Furthermore, denoteby tY,a,b the expected makespan of the Randomly Biased MinWork Mechansim when all

23

tia tib

tic

Figure 11: Tasks a and b with execution time tia and tib are replaced by a task c with execution timetic = tia + tib.

other tasks are allocated according to Y and a and b are randomly allocated. Likewisedenote by tY,c the expected makespan when a and b are replaced by c. Let T i a (resp.T 3−i) denote the finishing time of agent i (resp. agent 3 − i) when the allocation is Y .As agent i finishes after agent 3 − i no matter how a and b are allocated the expectedmakespan of the Randomly Biased MinWork Mechanism equals the expected finishingtime of agent i. Since task a (resp. task b) is allocated to agent i with a probability of

1/2, tY,a,b = T i + tia2

+tib2

= T i +tia+tib

2= T i + tic

2. Obviously, this is the expected makespan

when task c is randomly allocated. It follows that tY,a,b = tY,c.

Case B: W.l.o.g agent i finishes last if (and only if) a and b are allocated to it. Inthis situation we need to distinguish between four cases which are equally likely to occur:a and b are allocated to agent i (and agent i finishes last) or only a, only b or a and b areallocated to agent 3 − i (and agent 3 − i finishes last). Let Y , tY,a,b and tY,c be defined

as above. Then the expected makespan is tY,a,b =T i+tia+tib

4+

T 3−i+t3−ia +t3−i

b

4+ T 3−i+t3−i

a

4+

T 3−i+t3−ia

4. As agent i finishes last iff a and b are allocated to it, T 3−i ≤ T i + tia + tib. It

follows that tY,a,b ≤T i+tia+tib

2+

T 3−i+t3−ia +t3−i

b

2= tY,c.

We will omit the proofs for Case C and Case D as they are very similar to the casespresented above. However a detailed proof can be found in Nisan and Ronen’s paper [5].

Due to the preceding considerations we can concentrate on the ’hardest case’ given bythe following table:

t1j t2j opt-alloc bmw-alloc

k1 a β a 1 1k2 b β b 2 1l1 c β c 1 rnd1

l2 β d d 2 rnd2

The variables rndi (i ∈ {1, 2}) are chosen at random such that rndi ∈ {1, 2}. The proofof Step 2 consists of a case distinction whether a + b + βd ≤ βc or a + b + βd ≥ βc anda + b ≤ βc + d respectively a + b ≥ βc + d. We will focus on the first case as the other

24

two cases can be treated in an analogous manner.

Proof: As mentioned above we will only prove the case where a + b + βd ≤ βc.The expected makespan of the Randomly Biased MinWork Mechanism depends on theoutcome of the random choice of the variables rndi (i ∈ {1, 2}). Basically, there are fourpossible outcomes that are equally likely to occur: (rnd1, rnd2) ∈ {(1, 1)(1, 2)(2, 1)(2, 2)}.If (rnd1, rnd2) = (1, 1) then both l-tasks are allocated to agent 1. Hence, the makespanof the Randomly Biased MinWork Mechanism would equal a + b + c + βd. Similarly,the makespans are a + b + c, βc or βc + d if (rnd1, rnd2) = (1, 2),(2, 1) or (2, 2). Thus,

the expected makespan is tbmw = (a+b+c+βd)+(a+b+c)+(βc)+(βc+d)4

. Applying the fact thattopt = a + c = βb + d and the inequality above yields that tbmw ≤ 7/4topt. The cases thatare not covered here can be found in Nisan and Ronen’s paper [5].

4.4 Intermediate Summary

Following the approach of Nisan and Ronen [5] we introduced randomized mechanismsand transferred the notions dominant strategy and (strongly) truthful mechanism to thiskind of mechanisms. Afterwards we presented a randomized mechanism for the taskscheduling problem with two agents - the Randomly Biased MinWork Mechanism - thatbeats the lower bound for deterministic mechanisms. Oviously this adumbrates the powerof randomization in the field of algorithmic mechanism design. In the subsequent sectionwe will deal with yet another class of mechanisms: mechanisms with verification.

5 Mechanisms with Verification

Up to now the sole information the mechanisms are based upon are the agents’ declara-tions. In many settings though, one could take advantage of various extra informationavailable at varying points in time. In this section we will study an enhanced model ofmechanism design proposed by Nisan and Ronen [5]: The Two Phases Model. As itsname implies the Two Phases Model consists of two stages: A declaration phase and anexecution phase. In the declaration phase the agents ’talk’. This results in a decision(e.g. an allocation) of the mechanism itself. Afterwards the agents execute the agreedoutput. The payments of the mechanism need only to be given after the execution phase.Thus the mechanism is able to compare the agents’ declarations to their actual execu-tion times. This enables the mechanism to verify if the declarations were correct. Thus,cheating agents can be identified and punished. Nisan and Ronen [5] refer to this kindof mechanism as mechanisms with verification.

In the following subsection we will give a formal definition of what a mechanism withverification is and how the notions of dominance and truthfulness can be translated.

5.1 Model of Verification

The most important change in the enhanced model is the separation between an agent’sdeclaration di and its execution ei. As we explained in the introduction of this section,the payment pi that the mechanism provides depends on both the declarations of the

25

agents and their actual executions while the decision k of the mechanism is only basedon the agents’ declarations. More formally we define:

Definition 18 (Mechanism with Verification) A Mechanism with Verification hasthe following properties:

◦ An agent’s strategy is composed of two separate parts: a declaration di and anexecution ei.

◦ Each declaration di is chosen by the agent, based on its type ti, in an unrestrictedmanner.

◦ The decision k of the mechanism must be a function of just the declarations d1, .., dn.

◦ The agent’s execution ei may depend on ti as well as on k. The problem specificationspecifies, for each ti, the possible e()’s an agent of type ti may choose.

◦ The output of the mechanism is the result of the decision k and the agents’ execu-tions e1(k), .., en(k). The output function o(k, e) is a part of the problem specifica-tion.

◦ The output o, determines both the objective function g(o, t) and the agents’ valua-tions’ vi(ti, o).

◦ The payment pi that the mechanism provides depends on both, the declarationsd1, .., dn and the executions e1(k), .., en(k).

As we did with randomized mechanisms we would like to transfer the notion of (strong)truthfulness to mechanism with verification. Again we can do this in a rather canonicalfashion:

Definition 19 (Truthful Mechanism with Verification) A mechanism with verifi-cation is called truthful if

1. The agents’ declarations are simply to report their types.

2. For each agent i of type ti, there is a dominant strategy of the form ai = (ti, ei()).

We say that the mechanism is strongly truthful if it is the only dominant strategy.

In the following subsection we will reformulate the task scheduling problem so as to adaptit to the model of verification proposed by Nisan and Ronen [5]. Afterwards we will lookat two optimal mechanisms for this problem.

26

5.2 Task Scheduling with Verification

The Task Scheduling with Verification problem is quite similar to the standard formu-lation of the problem. As in the standard formulation the task scheduling mechanismcomputes an allocation of tasks to agents based on the agents’ declarations. While inthe standard problem the mechanism’s payments are only based on the agents’ types tthe mechanism knows about the actual execution times t = t1, .., tk of the tasks and maybase its payments on this extra information in the modified formulation of the problem.More specifically we define:

Definition 20 (Task Scheduling with Verification) The problem is the same as be-fore, except that the mechanism knows the the times t = t1, .., tk the tasks were actuallyperformed in and may base its payment p(t, t) = p1(t, t), .., pn(t, t) on this extra informa-tion.

◦ Mechanism: (x(t), p) where x(t) is the allocation function

◦ Feasible output: (x, t) where x = x1, .., xn is the allocation

◦ Objective function: g(x, t) = maxi∑

j∈xi tj (make-span)

◦ Agent i’s valuation: vi(x, t) = −∑j∈xi tj

◦ Agent i’s utility: ui(t, t) = pi(t, t) + vi(x, t)

5.3 Optimal Mechanisms for Task Scheduling with Verfification

In this subsection we will encounter two optimal mechanisms with verification for thetask scheduling problem. Both of which are based on an optimal allocation of tasksto agents (which will involve serious problems when taking running times into account)and two important concepts: bonus and compensation. The latter one is introduced tocompensate the agents’ valuations while the former one is used to reward or punish theagents for their specific behavior.

5.3.1 The Compensation-and-Bonus Mechanism

The crucial aspect in designing an optimal mechanism with verification for the taskscheduling problem is to choose the payments adequately: the payment for agent i is thesum of its compensation and its bonus. The compensation ci(t, t) of agent i is simplythe sum over the execution times of all tasks allocated agent i. Agent i’s bonus bi(t, t)is defined to be the negative makespan defined by the optimal allocation and a ’localview’ of the execution times. This ’local view’ is defined by agent i’s knowledge of theexecution times: the actual execution times of the tasks assigned to the agent itself andthe declarations of the agents the other tasks were allocated to. In order to be able toexpress this ’local view’ Nisan and Ronen use so called corrected time vectors. So do we.

Definition 21 (Compensation-and-Bonus Mechanism) The Compensation-and-Bonus Mechanism is defined by an optimal allocation function x(t) and the paymentfunctions pi(t, t) = ci(t, t) + bi(t, t) with

27

◦ Compensation: ci(t, t) =∑

j∈xi tj

◦ Corrected time vector: corri(x, t, t) = {tlj if j∈xl and l 6=i

tj if j∈xi

◦ Bonus: bi(t, t) = −g(x(t), corri(x, t, t))

Before launching into the analysis of the Compensation-and-Bonus Mechanism let’s firstlook at some examples. All of them are restricted to two agents and three tasks. Theoptimal allocation (the one that minimizes the makespan) is highlighted in blue whilethe corresponding actual execution times are presented in green.

Example 1: Truthtelling and Eager Agents

j 1 2 3 Remarks

Agent 1 t1j 10 30 45 opt.alloc.t1j 10 30 45 act.exec.times

Agent2 t2j 100 60 100 opt.alloc.t2j 100 60 100 act.exec.times

In this case both agents are truthtelling and eager, i.e. their declarations are simply todeclare their types and their actual executions times are equal to their declarations. Inother words tij = tij for all i and j. A quick evaluation of the agents payments and utilitiesyields the following:

◦ Compensations: ci(t, t) =∑

j∈xi tj ⇒ c1(..) = 55 and c2(..) = 60

◦ Corr. time vec.: corri(x, t, t) = {tlj if j∈xl and l 6=i

tj if j∈xi ⇒ corr1,2(..) = t

◦ Bonuses: bi(t, t) = −g(x(t), corri(x, t, t))⇒ b1,2(..) = −60◦ Payments: pi(t, t) = ci(t, t) + bi(t, t)⇒ p1(..) = −5 & p2(..) = 0◦ Utilities: ui(t, t) = pi(t, t) + vi(x, t)⇒ u1(..) = u2(..) = −60

One can easily see that the payments are almost neutral. In addition the agents utilitiesequal the optimal makespan and thus are optimal.

Example 2: Lying but Eager Agents

j 1 2 3 Remarks

Agent 1 t1j 10 30 200 opt.alloc.t1j 10 30 200 act.exec.times

Agent2 t2j 100 60 100 opt.alloc.t2j 100 60 100 act.exec.times

In the situation described in the preceding table agent 1 tries to get rid of task 3 bydeclaring t13 = 200 (instead of its ’real’ type t13 = 45). As a consequence task 3 is nolonger allocated to agent 1 but to agent 2. In return task 2 is now allocated to agent 1.

28

Let’s look at the payments and utilities in this particular situation:

◦Compensations: c1(..) = 40 and c2(..) = 100◦Corr. time vec.: corr1,2(..) = t = (10, 30, 100)◦Bonuses: b1,2(..) = −100◦Payment: p1(..) = −60 & p2() = 0◦Utilities: u1(..) = u2(..) = −100

As compared to the first example we see that agent 1’s payment is now −60 instead of−5 and that both utilities decreased to −100. Obviously lying is not the best idea!

Example 3: Truthtelling but Lazy Agents

j 1 2 3 Remarks

Agent 1 t1j 10 30 45 opt.alloc.t1j 20 40 80 act.exec.times

Agent2 t2j 100 60 100 opt.alloc.t2j 100 60 100 act.exec.times

In the final example the agents are assumed to be truthtelling, but agent 1 is lazy. Insteadof executing task 3 in 45 time units it executes the task in 80 time units. As a matterof fact this decreases agent 1’s payment to −60 (instead of −5) and its utility to −100(instead of −60) while the second agent is not affected. Consequently, agent 1 won’t dothat.

◦Compensations: c1(..) = 40 and c2(..) = 100◦Corr. time vec.: corr1(..) = (20, 60, 80) & corr2(..) = (10, 60, 45)◦Bonuses: b1(..) = −100 and b2(..) = −60◦Payments: p1(..) = −60 and p2(..) = 0◦Utilities: u1(..) = −100 and u2(..) = −60

Now that we have a certain intuition about how the Compensation-and-Bonus Mechanismworks we can prove the following theorem:

Theorem 5 (Compensation-and-Bonus Mechanism) The Compensation-and-Bonus Mechanism is a strongly truthful implementation of the task scheduling problem.

Proof: Let’s first ascertain that agent i’s utility equals its bonus: ui = pi + vi =(ci+bi)+vi = (−vi+bi)+vi = bi. Thus agent i’s utility is maximal if its bonus is maximal.Recalling the definition of agent i’s bonus, bi(t, t) = −g(x(t), corri(x(t), t, t)) where g isthe makespan, it becomes obvious that the bonus is maximal when agent i executes itstask in minimal time. Since this is true for an arbitrary agent i it is true for all agents.Thus truthtelling is a dominant strategy. That it is the only one follows directly fromthe optimality of the allocation function. Let ti denote agent i’s type; let d−i denote thedeclarations of all other agents and let corr∗(x, t) be the (unique) vector that satisfiescorr∗(x, t, t)j = tij for all i and j ∈ xi. Then, −g(x(t), corr∗(x(t), t)) ≥ −g(x(d−i, t

′i), t)

for all t′i.

29

5.3.2 The Generalized Bonus-and-Compensation Mechanism

Taking a closer look at the examples above one may wonder why all the payments andutilities are negative eventhough this might appear counter-intuitive at the first glance.Indeed we can generalize the approach of the Bonus-and-Compensation Mechanism so asto meet further design goals. Actually, this generalization consists in modified definitionsof the notions bonus and compensation as the following definition states:

Definition 22 (Generalized Compensation-and-Bonus Mechanism) The Gener-alized Compensation-and-Bonus Mechanism is defined by an optimal allocation functionx(t) and the payment functions pi(t, t) = ci(t, t) + bi(t, t) with

◦ Generalized Compensation: ci(t, t) ≤ ∑j∈xi tj

◦ Generalized Bonus: bi(t, t) = mi(t−i,−g(x(t), corri(x, t, t))) where mi(t−i, w) is anypositive real-valued function, that is monotonically increasing in w

A similar argumentation as in the proof of the previous theorem leads to the followingtheorem:

Theorem 6 (Generalized Compensation-and-Bonus Mechanism) The Generali-zed Compensation-and-Bonus Mechanism is a strongly truthful implementation of the taskscheduling problem.

This tells us that the Generalized Compensation-and-Bonus Mechanism, as the standardversion presented earlier, is an optimal mechanism for the task scheduling problem withverification. However, its relatively loose requirements can be used to satisfy additionalrequirements such as:

◦ Participation Constraints: If an agent is truth-telling, its utility is non-negative.

◦ Budget Limits: The total payments may not exceed a certain maximum amountspecified in advance.

5.4 Polynomial-Time Mechanisms for Task Scheduling with Ver-ification

In the preceding subsection we encountered two optimal mechanisms for the task schedul-ing problem with verification. Nevertheless these mechanisms reveal a severe problem:

Problem 1 Computing an optimal allocation is known to be NP-hard.

Hence, both mechanisms are intractable from a computational view. Quite naturallyone could ask if replacing the optimal allocation function with a known polynomial-time approximation algorithm preserves their positive properties such as truthfulness.Unfortunately, this is not the case as the following theorem shows:

Theorem 7 (Approximation Lacks Truthfulness) Any Compensation-and-BonusMechanism that is based on a non-optimal allocation algorithm is not truthful.

30

Proof: This theorem is shown by contradiction. Assume that a Compensation-and-Bonus Mechanism deploys a non-optimal allocation algorithm. One can show that anyagent could prevent that some of its execution times are infinite (eventhough there arenot) for its own benefit. This contradicts the truthfulness of this mechanism. A detailedproof can be found in Nisan and Ronen’s paper [5].

Notably, Nisan and Ronen were not able to solve the problem of intractability in thegeneral case. However, they present a (1 + ε)−approximation mechanism for a restrictedvariant of the task scheduling problem in their paper [5]. Let’s first look at this specialcase!

5.4.1 Bounded Scheduling Problem

The variant of the scheduling problem they deal with is quite similar to the originalproblem except that the execution times are bounded (from below and from above) bysome constants:

Definition 23 (Bounded Scheduling Problem) The problem is the same as in taskscheduling with verification, except that the number of agents n is fixed to a constant andthere exist fixed constants a, b > 0 such that a ≤ tij ≤ b for all i and j.

The remainder of this report will deal with Nisan and Ronen’s (1 + ε)−approximationmechanism for this restricted variant of the problem: The Rounding Mechanism.

5.4.2 The Rounding Mechanism

The Rounding Mechanism is based on two components: On the one hand Nisan andRonen deploy the Rounding Algorithm of Horowitz and Sahni [4] for the allocation oftasks and on the other hand they suggest a carefully chosen payment function. Let’s firstsketch how the approximation algorithm of Horowitz and Sahni works (see Horowitz andSahni [4] for details):

The Rounding Algorithm:

◦ Round up the entries tij to integer multiples of δ (a parameter chosen as a functionof a and ε).

◦ Solve this rounded problem exactly in polynomial time using dynamic program-ming.

The key idea with respect to the payment functions is to use the exact execution timesfor the compensation, but the rounded ones for the bonus. More precisely Nisan andRonen [5] define:

Definition 24 (Nisan and Ronen’s Payment Function) Let t denote the vector whereall entries of t are rounded up to an integer multiple of δ. Let g(..) be the make-spanfunction and denote by g(x, t) the make-span g(x, t). The payment function is given bypi(t, t) = ci(t, t) + bi(t, t), where

31

◦ ci(t, t) =∑

j∈i(t) tj is the Compensation and

◦ bi(t, t) = −g(x(t), corri(x(t), t, t)) is the Bonus.

Finally, the Rounding Mechanism is defined to be the mechanism that is composed ofHorowitz and Sahni’s [4] allocation algorithm and the payment function stated above.The following theorem (whose proof is sketched subsequnetly) states that this RoundingMechanism is a truthful implementation and that it is a (1 + ε)− approximation for thebounded task scheduling problem.

Theorem 8 The Rounding Mechanism uses the Rounding Algorithm of Horowitz andSahni for the allocation of tasks and the Payment Function of Nisan and Ronen. Forevery fixed ε > 0 it is a polynomial time mechanism with verification that truthfullyimplements a (1 + ε)−approximation for the bounded task scheduling problem.

Proof: The idea is to show that the sole dominant strategies declare tij such that theirrounded values coincide with the rounded values of their true types. Thus, truthtellingis among the dominant strategies (but it is not the only one). In addition one canderive from the fact that the rounding algorithm is used for the allocation of tasks thatthe Rounding Mechanism is within a factor of (1 + ε) of the optimal mechanism whichcompletes the proof. A more detailed argumentation can be found in [5, 4].

5.5 Intermediate Summary

Following the approach of Nisan and Ronen [5] we introduced an extended model, for-malizing situations in which the mechanism has to make a descision based on the agents’declarations but delays their payments until it knows about their actual bahavior. After-wards we presented two optimal mechanisms for the adapted task scheduling problem:The Compensation-and-Bonus Mechanism and the Generalized Compensation-and-BonusMechanism. The key idea was to calculate an optimal allocation of tasks based on theagents’ declarations and to determine their payments based on the actual execution times.This allows cheating agents to be punished. Unfortunately, computing an optimal allo-cation of tasks is known to be NP-hard. As a consequence the optimal (Generalized)Compensation-and-Bonus Mechanism is computionally intractable. Simply replacing theoptimal allocation algorithm by an approximation algorithm does not work in general. Tocircumvent this difficulty we introduced a restricted variant of the task scheduling withverification problem. For this problem we presented Nisan and Ronen’s [5] polynomialtime (1 + ε)−approximation mechanism: The Rounding Mechanism

6 Summary

This report outlined the approach suggested by Noan Nisan and Amir Ronen [5] toleverage the field of Mechanism Design for algorithmic purposes concerning selfish agents.Their paper opened a wide field of research. Among others Andelman et. al [1] and Archeret. al [2, 3] extended this area of algorithmic theory into different directions.

32

References

[1] N. Andelman, Y. Azar, and M. Sorani. Truthful Approximation Mechanisms forScheduling Selfish Related Machines. In Proceedings of the 22nd Symposium on The-oretical Aspects of Computer Science, 2005.

[2] A. Archer, C. Papadimitriou, K. Talwar, and E. Tardos. An Approximate TruthfulMechanism for Combinatorial Auctions with Single Parameter Agent. In Proceedingsof the 14th Annual ACM Symposium on Discrete Algorithms, 2003.

[3] A. Archer and E. Tardos. Truthful mechanisms for One-Parameter Agents. In Pro-ceedings of the 42nd Annual Symposium on Foundations of Computer Science, 2001.

[4] Ellis Horowitz and Sartaj Sahni. Exact and Approximate Algorithms for SchedulingNonidentical Processors. In Journal of the Association for Computing Machinery,p.317-327, 1976.

[5] N. Nisan, A. Ronen. Algorithmic Mechanism Design. Proceedings of the 31. AnnualACM Symposium on Theory of Computing, 1999.

33