Automated Design of Multistage Mechanisms

Tuomas Sandholm (Carnegie Mellon)Vincent Conitzer (Carnegie Mellon)Craig Boutilier (Toronto)

Mechanism design An outcome must be chosen from a set of outcomesEvery agent has preferences over the outcomes, represented by a typeWe only know priors over agents typesEach agent reports its type to the mechanism, mechanism chooses outcomemechanism = function from type vectors to outcomesauction rules, voting rules, But: agents will lie if this is to their benefit!Solution: mechanism should be designed so that agents have no incentive to liejustified by revelation principleSome general mechanisms exist (e.g. VCG) but they are not always applicable/optimal

Automated mechanism design [Conitzer & Sandholm UAI-02] Idea: design optimal mechanism specifically for setting at hand, as solution to an optimization problem

Generates optimal mechanisms in settings where existing general mechanisms do not apply/are suboptimal

If mechanism is allowed to be randomized, can be done in polynomial time using linear programming (if number of agents is small)

Small example: Divorce arbitrationOutcomes:Each agent is of high type with probability 0.2 and of low type with probability 0.8Preferences of high type:u(get the painting) = 100u(other gets the painting) = 0u(museum) = 40u(get the pieces) = -9u(other gets the pieces) = -10Preferences of low type:u(get the painting) = 2u(other gets the painting) = 0u(museum) = 1.5u(get the pieces) = -9u(other gets the pieces) = -10

Optimal randomized, dominant strategies, single-stage mechanism for maximizing sum of divorcees utilities lowhigh.96.04.96.04.47.4.13

The elicitation problemIn general, every agent must report its whole typeThis may be impractical in larger examplesIn a combinatorial auction, each agent has values for exponentially many bundlesComputing ones type may be costlyPrivacy lossFor most mechanisms, this is not necessaryE.g. second-price auction only requires us to find the winner and the second-highest bidders valuationMultistage mechanisms query the agents sequentially for aspects of their type, until they have determined enough informationE.g. an English auctionCan we automatically design multistage mechanism?

A multistage mechanism corresponding to the single-stage mechanism .96.04.96.04.47.4.13lowhighlowlowhighhigh

Saving some queries .93.07.96.04.78.22lowhighlowlowhighhighwith probability .4, exit early with

Asking the husband first.96.04.96.04.47.4.13lowhighlowlowhighhigh

Saving some queries (more this time).96.04.82.18lowhighlowlowhighhighwith probability .51, exit early with.92.08

Changing the underlying mechanismFor the given optimal single-stage mechanism, we can save more wife-queries than husband-queriesSuppose husband-queries are more expensiveWe can change the underlying single-stage mechanism to switch the roles of the wife and husband (still optimal by symmetry)If we are willing to settle for (welfare) suboptimality to save more queries, we can change the underlying single-stage mechanism even further

Fixed single-stage mechanism, fixed elicitation treeAs we saw: If all of a nodes descendants have at least a given amount of probability on a given outcome, then we can propagate this probability upTheorem. Suppose both the single-stage mechanism and the elicitation tree (query order) are fixed. If we propagate probabilities up as much as possible, we get the maximum possible savings in terms of number of queries.

What if the tree is not fixed?Construct the tree first, then we can propagate up as beforeObservation: The exit probability at a node does not depend on the structure of the tree after itA greedy approach to asking queries: next query = query maximizing the probability of exiting right after itTime complexity: O(|Q|*|A|*|O|*||)Proposition. In various (small) examples, the greedy approach can save only an arbitrarily small fraction of the queries saved with the optimal tree

Finding the optimal tree using dynamic programmingAfter receiving certain answers to certain questions, we are in some information stateDynamic program computes the (minimum) expected number of queries needed from every state (given that we have not exited early)Time complexity: O(|Q|*|A|*|O|*||*2||)

What if underlying single-stage mechanism is not fixed (but elicitation tree is)?Approach: design single-stage mechanism taking eventual query savings into account Single-stage mechanism is designed using linear programming techniquesSo, can we express query savings linearly? Yes:For every vertex v in the tree, let c(v) be the cost of the query at vP(v) be the probability that v is on the elicitation pathe(v) the probability of exiting early at or before v given that v is on the elicitation pathThen, the query savings is vc(v)P(v)e(v)All of these are constant except e(v) = ominv p(, o)

What if nothing is fixed?Could apply previous approach to all possible trees (inefficient)No other techniques here yet

Auction exampleOne item, two bidders with values uniformly drawn from {0, 1, 2, 3}Objective: maximize revenueOptimal single-stage mechanism generated:(compare: Myerson auction)

Multistage version of same mechanismUsing the dynamic programming approach for determining the optimal tree, we get:

Changing the underlying single-stage mechanismUsing tree generated by dynamic program, we optimized the underlying mechanism for cost of 0.001 per querySame expected revenue, fewer queries

Changing the underlying single-stage mechanismSame tree, but with a cost of 0.5 per query:Lower expected revenue, fewer queries

Beyond dominant-strategies single-stage mechanismsSo far, we have focused on dominant strategies incentive compatibility for the single-stage mechanismAny corresponding multistage mechanism is ex-post incentive compatibleWeaker notion: Bayes-Nash equilibrium (BNE)Truth-telling optimal if each agents only information about others types is the prior (and others tell the truth)Multistage mechanisms may break incentive compatibility by revealing informationProposition. There exist settings wherethe optimal single-stage BNE mechanism is uniquethe unique optimal tree for this mechanism is not incentive compatiblethere is a tree that randomizes over the next query asked that is BNE incentive compatible and obtains almost the same query savings as the optimal tree, more than any other tree

ConclusionsFor dominant-strategies mechanisms, we showed how to:turn a single-stage mechanism into its optimal multistage version when the tree is given (propagate probability up)turn a single-stage mechanism into a multistage version when the tree is not givengreedy approach (suboptimal, but fast)dynamic programming approach (optimal, but inefficient)generate the optimal multistage mechanism when the tree is given but the underlying single-stage mechanism is notBNE mechanisms seem harder (need randomization over queries)

Thank you for your attention!