Algorithmic Mechanism Design VII: Compensation-and-Bonus Based on a Non-Optimal Approximation Algorithm Is Not TruthfulResearch Paper
Motivation
Algorithmic mechanism design studies optimization problems whose inputs are held by self-interested agents: the algorithm must compute a good solution and, through payments, make it in each agent's interest to report its input honestly. Nisan and Ronen introduced the field with the problem of scheduling tasks on unrelated machines, where each machine is an agent that privately knows how long it needs for every task (Nisan–Ronen 2001).
The classical tool for truthfulness, the Vickrey–Groves–Clarke (VGC) family of mechanisms, requires the allocation to be exactly optimal. Exact optimization is often computationally out of reach: minimizing the make-span on unrelated machines is NP-hard, and even approximating it within a factor below 3/2 is NP-hard (Lenstra–Shmoys–Tardos 1990). A mechanism designer would therefore like to plug an approximation algorithm into a truthful mechanism and keep truthfulness. This mission formalizes a result showing that the simplest way of doing so fails in the model with verification, where the mechanism may pay after the tasks are performed and observes the actual execution times.
Timeline.
- 1999/2001: Nisan and Ronen define mechanisms with verification and the Compensation-and-Bonus mechanism, prove it strongly truthful when its allocation algorithm is optimal (their Theorem 5.1), and prove that replacing the optimal algorithm by a non-optimal approximation algorithm destroys truthfulness (Theorem 5.6, the goal here). They remark that a similar argument applies to VGC mechanisms.
- 2002: Lehmann, O'Callaghan and Shoham show the analogous failure for VGC payments with approximate allocation in combinatorial auctions (JACM 2002).
- 2007: Nisan and Ronen study which approximation algorithms can be made truthful within the VGC framework (JAIR 2007).
Setting
There are agents and tasks. The type of agent is a vector of positive reals, being the minimum time agent needs for task ; a type vector is . An allocation gives each task to one agent. The make-span is
and is optimal for if for every allocation .
In the model with verification, an agent's strategy has two parts: a declaration (any positive vector) and an execution plan that, for every allocation the mechanism may choose, fixes the actual time in which the agent performs each task it receives. An allocation algorithm maps the declarations to an allocation ; the tasks are then executed, producing actual times .
The Compensation-and-Bonus mechanism based on pays agent
a compensation for the time actually spent plus a bonus equal to minus the make-span computed from agent 's actual times on its own tasks and the other agents' declared times on theirs (the corrected time vector ). The agent's utility is its payment minus the time it spends. A strategy is dominant if it is at least as good as every alternative whatever the other agents declare and execute; the mechanism is truthful if every agent of every type has a dominant strategy that declares its true type.
Formalization targets
Goal: Theorem 5.6
Let be an allocation algorithm such that, for some real ,
and such that for some positive and some allocation . Then the Compensation-and-Bonus mechanism based on is not truthful.
The ratio is arbitrary and existentially quantified: the theorem holds for every finite approximation ratio, so it is stated without a constant.
Milestones
- Claim 5.7. If the mechanism based on is truthful, is optimal for and is at least every entry of , then replacing one agent's type by on and elsewhere gives a type vector with .
- Corollary 5.8. Under the same assumptions, the type vector that makes this replacement for every agent satisfies .
- Final step. , is optimal for , and every allocation has .
Significance
The result. Theorem 5.1 of the same paper shows that with an optimal algorithm the Compensation-and-Bonus mechanism is a strongly truthful implementation of make-span minimization. Theorem 5.6 shows that this guarantee is tied to exact optimization: it does not survive replacing the optimizer by any non-optimal approximation algorithm, whatever its ratio. It explains why the paper then turns to a restricted problem (bounded scheduling) and a mechanism designed around a specific rounding algorithm, and it is an early instance of the general tension between approximation and incentive compatibility.
Formalizing it. The result is proved in the paper; to the best of the platform's catalog it has not been formalized. The mission produces a machine-checked model of mechanisms with verification (declarations together with execution plans that may depend on the decision), the Compensation-and-Bonus payment rule for an arbitrary allocation algorithm, and Definition 19 truthfulness, together with a checked proof of the impossibility.
Difficulty
The argument is short on paper; the difficulty lies in the model. The paper's "" is not a number, and a faithful statement must replace it by a finite value that is large enough to conflict with the approximation ratio yet keeps every type positive and entrywise above the true types; both requirements refer to data fixed earlier in the argument. The incentive step compares utilities in a mechanism where an agent's strategy is a declaration and an execution plan that may depend on the decision, and where the bonus mixes the agent's actual times with the other agents' declarations, so a naive reading in which only declarations matter (the direct-revelation model of §2) does not capture the claim. Finally, Corollary 5.8 concerns a type vector modified at every agent, while Claim 5.7 modifies one agent at a time, so the claim must be applicable at type vectors that are no longer the original one.
Formalization scope
- Agents are
Fin nwith[NeZero n], tasksFin k, allocations are functionsFin k → Fin n, types and declarations are positive real vectors. Make-spans areFinset.sup'over the nonempty set of agents. With no agents no allocation algorithm meets the hypotheses, so requiring loses nothing. - An execution plan is a function of the allocation; feasibility is on the agent's own tasks. In the dominance quantifier the other agents' declarations are positive and their execution plans arbitrary; the agent's alternative declarations are positive and its alternative plans feasible for its true type.
- The allocation algorithm is an arbitrary function of the declarations; "approximation algorithm" is the hypothesis above, "non-optimal" the hypothesis of one positive witness. The optimal allocation in the milestones is any optimal allocation , supplied as a parameter.
- The paper's is a real parameter with for all ; extended reals are not used.
- Claim 5.7 is stated for an arbitrary agent , not only for agent 1, so that Corollary 5.8 can iterate it.
- Running time is not modelled; "algorithm" means function.
- Dropping the approximation hypothesis makes the statement false: an allocation rule that ignores the declarations is non-optimal, yet its Compensation-and-Bonus mechanism is truthful. Stating only "not strongly truthful", or proving the theorem for a fixed instance, would be a weaker claim.
Welcome contributions: proofs of the milestones and the goal, and reusable lemmas about the corrected time vector and the monotonicity of the make-span in the time vector.
Selected references
- N. Nisan, A. Ronen, Algorithmic Mechanism Design, Games and Economic Behavior 35 (2001) 166–196. https://doi.org/10.1006/game.1999.0790
- J. K. Lenstra, D. B. Shmoys, É. Tardos, Approximation algorithms for scheduling unrelated parallel machines, Mathematical Programming 46 (1990) 259–271. https://doi.org/10.1007/BF01585745
- D. Lehmann, L. I. O'Callaghan, Y. Shoham, Truth revelation in approximately efficient combinatorial auctions, Journal of the ACM 49 (2002) 577–602. https://doi.org/10.1145/585265.585266
- N. Nisan, A. Ronen, Computationally Feasible VCG Mechanisms, Journal of Artificial Intelligence Research 29 (2007) 19–47. https://doi.org/10.1613/jair.2046
- E. Horowitz, S. Sahni, Exact and approximate algorithms for scheduling nonidentical processors, Journal of the ACM 23 (1976) 317–327. https://doi.org/10.1145/321941.321951