📝 Original Info
- Title: Truthful Mechanisms with Implicit Payment Computation
- ArXiv ID: 1004.3630
- Date: 2015-11-17
- Authors: Researchers from original ArXiv paper
📝 Abstract
It is widely believed that computing payments needed to induce truthful bidding is somehow harder than simply computing the allocation. We show that the opposite is true: creating a randomized truthful mechanism is essentially as easy as a single call to a monotone allocation rule. Our main result is a general procedure to take a monotone allocation rule for a single-parameter domain and transform it (via a black-box reduction) into a randomized mechanism that is truthful in expectation and individually rational for every realization. The mechanism implements the same outcome as the original allocation rule with probability arbitrarily close to 1, and requires evaluating that allocation rule only once. We also provide an extension of this result to multi-parameter domains and cycle-monotone allocation rules, under mild star-convexity and non-negativity hypotheses on the type space and allocation rule, respectively. Because our reduction is simple, versatile, and general, it has many applications to mechanism design problems in which re-evaluating the allocation rule is either burdensome or informationally impossible. Applying our result to the multi-armed bandit problem, we obtain truthful randomized mechanisms whose regret matches the information-theoretic lower bound up to logarithmic factors, even though prior work showed this is impossible for truthful deterministic mechanisms. We also present applications to offline mechanism design, showing that randomization can circumvent a communication complexity lower bound for deterministic payments computation, and that it can also be used to create truthful shortest path auctions that approximate the welfare of the VCG allocation arbitrarily well, while having the same running time complexity as Dijkstra's algorithm.
💡 Deep Analysis
Deep Dive into Truthful Mechanisms with Implicit Payment Computation.
It is widely believed that computing payments needed to induce truthful bidding is somehow harder than simply computing the allocation. We show that the opposite is true: creating a randomized truthful mechanism is essentially as easy as a single call to a monotone allocation rule. Our main result is a general procedure to take a monotone allocation rule for a single-parameter domain and transform it (via a black-box reduction) into a randomized mechanism that is truthful in expectation and individually rational for every realization. The mechanism implements the same outcome as the original allocation rule with probability arbitrarily close to 1, and requires evaluating that allocation rule only once. We also provide an extension of this result to multi-parameter domains and cycle-monotone allocation rules, under mild star-convexity and non-negativity hypotheses on the type space and allocation rule, respectively. Because our reduction is simple, versatile, and general, it has many
📄 Full Content
Algorithmic Mechanism Design studies the problem of implementing the designer's goal under computational constraints. Multiple hurdles stand in the way for such implementation. Computing the desired outcome might be hard (as in the case of combinatorial auctions) or truthful payments implementing the goal might not exist (as when exactly minimizing the make-span in machine scheduling [Archer and Tardos 2001]). Even when payments that will generate the right incentives do exist, finding such payments might be computationally costly or impossible due to online constraints.
It is widely believed that computing payments needed to induce truthful bidding is somehow harder than simply computing the allocation. For example, the formula for payments in a VCG mechanism involves recomputing the allocation with one agent removed in order to determine that agent’s payment; this seemingly increases the required amount of computation by a factor of n + 1, where n is the number of agents. Likewise, for truthful single-parameter mechanisms the formula for payments of a given agent includes integrating the allocation rule over this agent’s bid [Myerson 1981;Archer and Tardos 2001]. In some contexts with incomplete observable information, such as online pay-per-click auctions, computing these “counterfactual allocations” may actually be information-theoretically impossible. This calls into question the mechanism designer’s ability to compute payments that make an allocation rule truthful, even when such payment functions are known to exist. Rigorous lower bounds based on these observations have been established for the communication complexity [Babaioff et al. 2013] and regret [Babaioff et al. 2014;Devanur and Kakade 2009] of truthful deterministic mechanisms.
In contrast to these negative results, we show that the opposite is true for randomized single-parameter mechanisms that are truthful-in-expectation: computing the allocation and payments is essentially as easy as a single call to the allocation rule. This allows for positive results that circumvent the lower bounds for deterministic mechanisms cited earlier.
We consider an arbitrary single-parameter domain. The paradigmatic example is an auction that allocates items between agents whose utility is linear in the number of items they receive. The private information of each agent is expressed by a single parameter: her value per item. 1 Each agent submits a bid, then the mechanism performs the allocation and charges payments. A mechanism is called “truthful” if each agent maximizes her utility by submitting her true value per item. The allocation rule in a truthful mechanism is called “truthfully implementable”. It is known that an allocation rule is truthfully implementable if and only if it is “monotone”: increasing one agent’s bid while keeping all other bids the same does not decrease this agent’s allocation [Myerson 1981;Archer and Tardos 2001]. A similar property holds for randomized mechanisms and truthfulness-in-expectation.
Our contributions. Our main result is a general procedure to take any monotone-inexpectation allocation rule A and transform it into a randomized mechanism that is truthful-in-expectation, implements the same outcome as A with probability arbitrarily close to 1, and requires evaluating that allocation rule only once. (We refer to this procedure as the generic transformation.) The allocation rule A is accessed only as a function call, so our result applies even if A is an online algorithm. Moreover, for each realization of randomness an agent never loses by participating in the mechanism and bidding truthfully; thus the agents are protected from undesirable random deviations.
We make a distinction between randomness in the mechanism and randomness in “nature”: the environment that the mechanism interacts with. Randomness in nature is subject to modeling assumptions and hence is less “reliable”; moreover, agents’ beliefs about nature may be different from the mechanism’s. On the other hand, randomness in the mechanism is fully controlled by the mechanism. Therefore it is desirable to design mechanisms that are truthful in a stronger sense: in expectation over the mechanism’s random seed, for every realization of randomness in nature; we will call such mechanisms ex-post truthful. It is easy to see from [Myerson 1981;Archer and Tardos 2001] that in any ex-post truthful mechanism the allocation rule must satisfy ex-post monotonicity (which is defined similarly to ex-post truthfulness). In the generic transformation described above, if the original allocation rule A is ex-post monotone then the resulting randomized mechanism is ex-post truthful.
Similarly, our result extends to Bayesian incentive-compatibility: if A is monotone in expectation with respect to a Bayesian prior over other agents’ bids, then the mechanism is truthful in expectation over this prior.
Our generic transformation is particularly useful for mechanism design problems
…(Full text truncated)…
📸 Image Gallery
Reference
This content is AI-processed based on ArXiv data.
