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 outcomes
• Every agent has preferences over the outcomes,
represented by a type
– We only know priors over agents’ types
• Each agent reports its type to the mechanism,
mechanism chooses outcome
– mechanism = function from type vectors to outcomes
– auction 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 lie
– justified by revelation principle
• Some 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 arbitration
• Outcomes:
• Each agent is of high type with probability 0.2 and of
low type with probability 0.8
– Preferences of high type:
•
•
•
•
•
u(get the painting) = 100
u(other gets the painting) = 0
u(museum) = 40
u(get the pieces) = -9
u(other gets the pieces) = -10
– Preferences of low type:
•
•
•
•
•
u(get the painting) = 2
u(other gets the painting) = 0
u(museum) = 1.5
u(get the pieces) = -9
u(other gets the pieces) = -10
Optimal randomized, dominant strategies, single-stage
mechanism for maximizing sum of divorcees’ utilities
high
high
low
.47
.96
.4
low
.13
.04
.96
.04
The elicitation problem
• In general, every agent must report its whole type
• This may be impractical in larger examples
– In a combinatorial auction, each agent has values for
exponentially many bundles
– Computing one’s type may be costly
– Privacy loss
• For most mechanisms, this is not necessary
– E.g. second-price auction only requires us to find the winner and
the second-highest bidder’s valuation
• Multistage mechanisms query the agents sequentially for
aspects of their type, until they have determined enough
information
– E.g. an English auction
• Can we automatically design multistage mechanism?
A multistage mechanism corresponding
to the single-stage mechanism
low
low
high
high
.96
.04
low
.96
.04
high
.47
.4
.13
Saving some queries
low
low
high
with probability .4, exit
early with
high
.96
.04
low
.93
.07
.78
.22
high
Asking the husband first
low
low
high
high
low
high
.96
.04
.96
.04
.47
.4
.13
Saving some queries (more this time)
low
low
high
.96
.04
low
high
with probability .51, exit
early with
high
.92
.08
.82
.18
Changing the underlying mechanism
• For the given optimal single-stage mechanism, we
can save more wife-queries than husband-queries
• Suppose husband-queries are more expensive
• We 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 tree
• As we saw: If all of a node’s descendants have at least a
given amount of probability on a given outcome, then we
can propagate this probability up
• Theorem. 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
before
• Observation: The exit probability at a node does not
depend on the structure of the tree after it
• A greedy approach to asking queries: next query = query
maximizing the probability of exiting right after it
– Time 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 programming
• After receiving certain answers to certain
questions, we are in some information state
• Dynamic 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 singlestage 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 techniques
• So, can we express query savings linearly? Yes:
• For every vertex v in the tree, let
– c(v) be the cost of the query at v
– P(v) be the probability that v is on the elicitation path
– e(v) the probability of exiting early at or before v given that v is
on the elicitation path
• Then, the query savings is Σvc(v)P(v)e(v)
• All of these are constant except e(v) = Σominθv p(θ, o)
What if nothing is fixed?
• Could apply previous approach to all possible
trees (inefficient)
• No other techniques here yet…
Auction example
• One item, two bidders with values uniformly
drawn from {0, 1, 2, 3}
• Objective: maximize revenue
• Optimal single-stage mechanism generated:
(compare: Myerson auction)
Multistage version of same mechanism
• Using the dynamic programming approach for
determining the optimal tree, we get:
Changing the underlying single-stage mechanism
• Using tree generated by dynamic program, we optimized
the underlying mechanism for cost of 0.001 per query
• Same expected revenue, fewer queries
Changing the underlying single-stage mechanism
• Same tree, but with a cost of 0.5 per query:
• Lower expected revenue, fewer queries
Beyond dominant-strategies single-stage mechanisms
• So far, we have focused on dominant strategies incentive
compatibility for the single-stage mechanism
– Any corresponding multistage mechanism is ex-post incentive
compatible
• Weaker notion: Bayes-Nash equilibrium (BNE)
– Truth-telling optimal if each agent’s only information about
others’ types is the prior (and others tell the truth)
– Multistage mechanisms may break incentive compatibility by
revealing information
• Proposition. There exist settings where
– the optimal single-stage BNE mechanism is unique
– the unique optimal tree for this mechanism is not incentive
compatible
– there 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
Conclusions
• For 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 given
• greedy 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 not
• BNE mechanisms seem harder (need randomization over
queries)
Thank you for your attention!