View
66
Download
0
Category
Preview:
DESCRIPTION
Mechanism Design with Execution Uncertainty. Ryan Porter, Amir Ronen, Yoav Shoham, and Moshe Tennenholtz Stanford University. Task Allocation. Motivating Example: Center = Government Task = Transport a package between two offices Agents = Shipping companies - PowerPoint PPT Presentation
Citation preview
Mechanism Design with
Execution Uncertainty
Ryan Porter, Amir Ronen,
Yoav Shoham, and Moshe Tennenholtz
Stanford University
August 3, 2002 Mechanism Design with Execution Uncertainty 2
Task Allocation
Motivating Example: Center = Government Task = Transport a package between two offices Agents = Shipping companies What protocol should the government use to allocate and pay for
the task? The general class of task allocation settings is well-studied, but
standard settings assume that the task is always completed.
task
CenterAgent 1
Agent N
value
cost
cost
August 3, 2002 Mechanism Design with Execution Uncertainty 3
Execution Uncertainty
What protocol should we use if there is uncertainty about the execution of the task?
First, we need to decide which type of execution uncertainty to consider.
We assume that agents make a full effort, but there is an inherent probability of failure.
We will revisit this assumption in the conclusion. Why Mechanism Design?
Consider the case of costless tasks, but firms only succeed with some probability.
What protocol should the government use?
August 3, 2002 Mechanism Design with Execution Uncertainty 4
Mechanism Design
Naïve Protocol: Firms declare probability to complete each task. Government assigns the task to the firm with the highest
declared probability for that task. Government pays this agent a fixed, positive amount if
succeeds, and nothing if it fails.
Problem: firms have incentive to lie about their probability of success.
This example shows the need for Mechanism Design (MD), the science of crafting protocols that give self-interested agents incentive to act in a way that achieves the goals of the center.
August 3, 2002 Mechanism Design with Execution Uncertainty 5
Outline
I. Single-Task Setting:
a. Formulation and mechanism goals
b. Mechanism that satisfies all goals
II. Multiple-Task Setting:
a. Different possible formulations
b. When dependencies exist:
1. Impossibility result
2. Possibility result for a relaxed set of goals
III. Conclusion
August 3, 2002 Mechanism Design with Execution Uncertainty 6
Formulation: Single-Task Setting
Single task t
N agents, each agent i is characterized by its privately-known
type θi2 θi = (pi,ci):
pi is the probability of completing t
ci is the cost of attempting t
Let θ = (θ1,…,θn)
Let θ-i = (θ1,…,θi-1,θi+1,…,θn). Then, θ = (θi,θ-i)
Center: has a value V for the completion of the task Necessary for making the correct allocation
V is common knowledge
August 3, 2002 Mechanism Design with Execution Uncertainty 7
Formulation: Mechanism
A mechanism consists of the following steps:
1. Nature reveals to each agent its type θi
2. Each agent declares θi Strategy for agent i is S: → (a direct mechanism)
Restriction allowed by the Revelation Principle
3. Center allocates task: A(θ) = ( A1(θ) , … , An(θ) )
4. Agents attempt their assignment (only one agent in this case) Result is recorded by the indicator variable µ
5. Center pays agents: R(θ,µ) = ( R1(θ,µ) , … , Rn(θ,µ) )
1. A mechanism is defined by the pair = (A(¢), R(¢))
August 3, 2002 Mechanism Design with Execution Uncertainty 8
Utility Functions
Utility function for agent i: ui(ci,θ,µ) = Ri(θ,µ) – ci(Ai(θ)
Agents are assumed to be expected-utility maximizers
Expectations always taken before the task is attempted
(that is, the expectation is over µ | p,A(θ))
Social welfare: W(A(θ),c,µ) = V· µ - i ci(Ai(θ))
Key idea of MD: align utility of each agent with social welfare
August 3, 2002 Mechanism Design with Execution Uncertainty 9
Mechanism Goals
Incentive Compatibility (IC): truth-telling (8 θi, si(θ i) = θi) is a
dominant strategy – 8 i,θ,θ-i,θi E[ui(ci,(θi,θ-i),µ)] ¸ E[ui(ci,(θi,θ-i),µ)]
Individual Rationality (IR): truthful agents always have nonnegative
expected utility – 8 i,θ,θ-i E[ui(ci,(θi,θ-i),µ)] ¸ 0
Center Rationality (CR): center’s utility always nonnegative – 8 θ,µ
V· µ - i Ri(θ,µ) ¸ 0
Social Efficiency (SE): allocation function maximizes expected social
welfare based on the true types –
8 θ, equilibria θ A(θ) = argmaxA' E[W(A',c,µ)]
Shows the use of IC, because A(·) can only depend on θ.
IC allows us to conclude that θ = θ.
August 3, 2002 Mechanism Design with Execution Uncertainty 10
Single-Task Setting: Only Costs
Second-Price Reverse Auction: Aj(θ) = {t} iff cj = c[1]
(That is, assign t1 to the agent with the lowest declared cost.)
Rj(θ,µ) = c[2]
(That is, pay this agent the second-lowest declared cost.)
agent cost (ci)
1 5
2 12
3 8
V = 10Example:
August 3, 2002 Mechanism Design with Execution Uncertainty 11
Single-Task Setting: Only Probabilities
Mechanism: Aj(θ) = {t} iff pj = p[1]
(Assign t1 to the agent with the highest declared probability.)
Rj(θ,µ) = – V·p[2] + V·µ
(Pay this agent according to the second-highest declared probability.)
Intuition: V·µ aligns the agent’s utility with social welfare, while (–
V·p[2]) gives us IC because no other agent could profit from R j(·).
agent probability (pi)
1 0.6
2 0.5
3 0.3
V = 10Example:
August 3, 2002 Mechanism Design with Execution Uncertainty 12
Single-Task Setting: General Case
Single-Task Mechanism: Aj(θ) = {t} iff j = argmaxi (pi ·V – ci)
(Assign the task to the agent i that maximizes expected welfare
E[W(A(θ),c,µ)] based on the declared types.)
Rj(θ,µ) = – E[W-j(A(θ-j),c,µ)] + V·µ
(Starting with a baseline loss of the expected welfare of the
system without this agent, agent j gets the value of the task
if it successfully completes the task.)
Theorem: Single-Task Mechanism satisfies IC, IR, CR, and SE.
August 3, 2002 Mechanism Design with Execution Uncertainty 13
Proof Sketch of IC
Plan: Derive an equation for the expected utility of a truthful agent, and then show it cannot do better.
Consider both cases for a truthful agent i: If agent i is assigned the task, then:
E[ui(ci,(θi,θ-i),µ)] = – E[W-i(A(θ-i),c,µ)] + pi·V – ci = – E[W-i(A(θ-i),c,µ)] +
E[W(A(θi,θ-i),c,µ)] If agent i is not assigned the task, then E[ui(·)] can be
written the exact same way. Agent i can only affect the second term, and the
mechanism optimizes this term assuming that agent i’s true type is θi.
August 3, 2002 Mechanism Design with Execution Uncertainty 14
Outline
I. Single-Task Setting:
a. Formulation and mechanism goals
b. Mechanism that satisfies all goals
Multiple-Task Setting:
a. Different possible formulations
b. When dependencies exist:
1. Impossibility result
2. Possibility result for a relaxed set of goals
III. Conclusion
August 3, 2002 Mechanism Design with Execution Uncertainty 15
Multiple-Task Setting
Simple Extension of the Single-Task Setting:
All variables become vectors of variables:
t = (t1,…,ts), pi = (p1i,…,ps
i), etc.
Since the tasks are independent (for both the center and the
agents), we can simply apply the Single-Task Mechanism to
each task separately.
Alternative formulations (skipped due to time constraints):
Combinatorial costs or probabilities for the agents
Combinatorial valuation function for the center
August 3, 2002 Mechanism Design with Execution Uncertainty 16
Multiple-Task Setting: Dependencies
Interesting settings have dependencies.
For example, object must be shipped from SF to Denver
before it can be shipped from Denver to Boston.
Definition: A task t2 is dependent on task t1 if t2 cannot be
attempted unless t1 is completed.
Dependencies induce a partial order in which the tasks are
attempted, and an agent does not incur the cost for an
assigned task that it cannot attempt.
t2
t1 t3
t4
t5
Nodes = tasks
Arcs = dependencies
(or, prerequisites)
August 3, 2002 Mechanism Design with Execution Uncertainty 17
Impossibility Result
Theorem: When dependencies exist between tasks, there
does not exist a mechanism that satisfies IC, IR, CR, and SE,
for any n,s ¸ 2.
Full proof is long, and it’s in the paper.
Intuition: Consider the case of: t1 assigned to agent 1 and t2 to agent 2.
How do you pay agent 2 in a way that satisfies IC?
A key part of the payment rule for the Single-Task Mechanism was the
ability to “test” the agent’s true probability of success.
However, agent 1 can block this test, and does so with a probability that is
unknown to the mechanism.
t2t1
August 3, 2002 Mechanism Design with Execution Uncertainty 18
Possibility Result
Relaxed set of goals: ex post Nash equilibrium versions of IC, IR, and SE.
No CR
The ex post Nash equilibrium: all agent truthfully reveal their type (8 i,θi si(θi) = θi). That is, even if each agent knew the true types of the other agents, truth-telling is still a best response.
Ex Post Nash Equilibrium Mechanism: A(θ) = A*(θ)
(Tasks are assigned according to A*(θ), the socially optimal allocation rule for the declared the types.)
8 i, Ri(θ,µ) = – E[W-i(A*(θ-i),c,µ)] + W-i(A*(θ),c,µ)
(Each agent i start with a loss equal to the expected social welfare
if this agent did not exist, and is then paid the actual welfare of the
entire system except for agent i.)
August 3, 2002 Mechanism Design with Execution Uncertainty 19
Conclusion
Main Idea:
Add the dimension of execution uncertainty to a basic
Mechanism Design problem for task allocation.
Main Results: Single-Task Setting:
We present a mechanism that satisfies all goals.
Multiple-Task Setting:
Dependencies prevent us from satisfying all goals, but
we present a mechanism that satisfies a relaxed set of
goals.
August 3, 2002 Mechanism Design with Execution Uncertainty 20
Future Work
Classes of execution uncertainty:This work:
1. Full effort, but inherent probability of failure
2. Rational, intentional failures
Future work:
3. “Irrational”, intentional failures
Mechanism Design with
Execution Uncertainty
Ryan Porter, Amir Ronen,
Yoav Shoham, and Moshe Tennenholtz
Stanford University
August 3, 2002 Mechanism Design with Execution Uncertainty 22
August 3, 2002 Mechanism Design with Execution Uncertainty 23
Introduction
Basic mechanism design problem for task allocation: Center has a set of tasks it wants completed
Agents have private costs to complete the tasks
Center constructs a protocol (mechanism) where: Agents pass information (e.g., bids) to the center
Center assigns tasks and makes payments
We add the dimension of uncertainty for the
completion of tasks
August 3, 2002 Mechanism Design with Execution Uncertainty 24
Dependencies
t2
t1 t3
t4
t5
Nodes = tasks
Arcs = dependencies
(or, prerequisites)
August 3, 2002 Mechanism Design with Execution Uncertainty 25
Single-Task Setting: Only Probabilities
Straw-man Mechanism:
Each agent declares a probability pi1
Assign the task to the agent with the high probability (p[1]1)
Pay this agent the difference in E[W-i(·)] (regardless of the
outcome of the attempt): (p[1]1 – p[2]
1) · V1
a1: p11 = 0.6
a2: p21 = 0.5
a3: p31 = 0.3
t1
V1 = 10
Example:
August 3, 2002 Mechanism Design with Execution Uncertainty 26
Impossibility Result: Proof Sketch
SE implies: A1(θ) = {t2} and A2(θ) = {t1}
Three variables to set: R1(θ , ;) , R1(θ , {t1}) and R1(θ , {t1,t2})
R1(θ , ;) = 0 – otherwise, IR violated or a1 would lie if p12 = 0
So, set up “sequential” mechanisms, where the second is only
implemented if t1 is completed: R1(θ , {t1,t2}) = 9 (if a1 succeeds)
R1(θ , {t1}) = -1 (if a1 fails)
This lack of IC because of the dependency is unavoidable
a1: p11 = 0.4 p1
2 = 1.0
a2: p21 = 0.0 p2
2 = 0.1
t1 t2
V1 , V2 = 10
8 i,s cis = 0
p21 = 0.5
{
p11 = 0.6
August 3, 2002 Mechanism Design with Execution Uncertainty 27
agent 1: c11 = 5
agent 2: c12 = 12
agent 3: c13 = 8
V1 = 10Example:t1
Recommended