Algorithmic Mechanism Design: an Introduction
1 / 25

Algorithmic Mechanism Design: an Introduction - PowerPoint PPT Presentation

  • Uploaded on

Algorithmic Mechanism Design: an Introduction Approximate (one-parameter) mechanisms, with an application to combinatorial auctions Guido Proietti Dipartimento di Ingegneria e Scienze dell'Informazione e Matematica University of L'Aquila [email protected] Results obtained so far.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about ' Algorithmic Mechanism Design: an Introduction' - topper

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

Algorithmic Mechanism Design: an Introduction

Approximate (one-parameter) mechanisms, with an application to combinatorial auctions

Guido Proietti

Dipartimento di Ingegneria e Scienze dell'Informazione e Matematica

University of L'Aquila

[email protected]

Results obtained so far
Results obtained so far

  • Two classes of truthful mechanisms:

  • VCG-mechanisms: arbitrary valuation functions and types, but only utilitarian problems

  • OP-mechanisms: arbitrary social-choice function, but only one-parameter types and workloaded monotonically non-increasing valuation functions

In all these basic examples, the underlying optimization problem is polytime computable…but what does it happen if this is not the case?

Single minded combinatorial auction
Single-minded combinatorial auction

t1 =20

SCF: the set XF with the highest total value






the mechanism decides

the set of winners and the

corresponding payments

Each player wants a specific bundle of objects

ti: value player i is willing to pay for

her bundle

ri: value player i offers for her bundle

F={ X{1,…,n} : winners in X

are compatible}

Combinatorial auction ca problem single minded case
Combinatorial Auction (CA) problem – single-minded case

  • Input:

    • n buyers, m indivisible objects

    • each buyer i:

      • wants a subset Si of the objects

      • has a value ti for Si (or any superset of Si), while she is not interested in any other allocation not containing all the items in Si (single-minded case); basically, ti is the maximum amount buyer i is willing to pay for Si

  • Solution:

    • X{1,…,n}, such that for every i,jX, with ij, SiSj= (and so Siis allocated to buyer i)

  • Buyer i’s valuation of XF:

    • vi(ti,X)= ti if iX (and so Siis allocated to buyer i), 0 otherwise

  • SCF (to maximize): Total value of X: iX ti

Ca problem single minded case 2
CA problem – single-minded case (2)

  • Each buyer makes a payment to the system pi(X) as a consequence of the selected output X; as usual, payments are used by the system to incentive players to be collaborative.

  • Then, for each feasible outcome X, the utility of player i (in terms of the common currency) coming from outcome X will be:

    ui(ti,X) = pi(X) + vi(ti,X) = pi(X) + ti

Designing a mechanism for the ca game
Designing a mechanism for the CA game

  • Each buyer is selfish

  • Only buyer i knows ti (while Siis public)

  • We want to compute an optimal solution w.r.t. the true values (we will see this is a hard task)

  • We do it by designing a mechanism that:

    • Asks each buyer to report her value ri

    • Computes a solution using an output algorithm g(r)

    • Receives payments pifrom buyer i using some payment function p (depending on the computed solution)

How to design a truthful mechanism for the problem
How to design a truthful mechanism for the problem?

Notice that:

the (true) total value of a feasible solution X is:

i vi(ti,X)

… and so the problem is utilitarian!

 VCG-mechanisms (should) apply

The vcg mechanism
The VCG-mechanism

  • M=<g,p>:

    • g(r) = arg maxXFj vj(rj,X)

    • pi = -j≠i vj(rj,g(r-i)) +j≠i vj(rj,g(r))

g(r)has to compute an

optimal solution…

…but can we do that?

Hardness of the CA problem

Theorem: Approximating the CA problem within a factor better than m1/2- is NP-hard, for any fixed >0 (recall m is the number of items).


Reduction from the maximum independent set problem

Maximum independent set mis problem
Maximum Independent Set (MIS) problem

  • Input:

    • a graph G=(V,E) of n nodes and m edges

  • Solution:

    • UV, such that no two vertices in U are joined by an edge

  • Measure:

    • Cardinality of U

Theorem (J. Håstad, 2002)

Approximating the MIS problem within a factor better than n1- is NP-hard, for any fixed >0.

The reduction from mis to ca
The reduction from MIS to CA

Let be given an instance G=(V,E) of the MIS pb; then, we build an instance of the CA pb in which:



input graph

each edge is an object




each node i is a buyer with

Si: set of edges incident to i








CA instance: S1={a,b,c,d}, S2={a}, S3={b,e,m}, S4={c,e,f,g}, S5={d,f,h,l}, S6={m}, S7={g,h,i}, S8={i,l}









Observation: the obtained CA instance is quite special: each object is contended by only two players, and any two players contend at most one object!

Then, it is easy to see that the CA instance has a solution of total value  k if and only if there is an IS of size  k

…and since m=O(n2), if we could find an approximate solution for CA of ratio better (i.e., less) than m1/2- , then we would find an IS with a ratio better than n1-.

How to design a truthful mechanism for the problem1
How to design a truthful mechanism for the problem?

So, the CA problem is utilitarian, and we could in principle apply a VCG-mechanism, but the solution that should be returned by its algorithm is not computable in polynomial time, unless P=NP.

The question is: If we want to keep on to guarantee the truthfulness of the VCG-mechanism, can we provide in polynomial time a reasonable approximate solution for the SCF?

A general negative result
A general negative result

For many natural mechanism design minimization problems (and the CA problem is one of them), any truthful VCG-mechanism is either optimal, or it produces results which arearbitrarily far from the optimal (this means, truthfulness will bring the system to compute an inadequate solution!)

What can we do for the CA problem?

…fortunately, the problem is one-parameter, and we now show that a corresponding one-parameter mechanism will produce a reasonable result.

A problem is binary demand bd if


A problem is binary demand (BD) if

  • ai‘s type is a single parameter ti

  • ai‘s valuation is of the form:

    vi(ti,o)= ti wi(o),

    wi(o){0,1}workload for ai in o

Whenwi(o)=1 we say that ai is selected in o

 The CA problem is clearly BD: a buyer is either selected or not in the solution!

Reminder (2)

An algorithm g for a maximization BD problem is monotone if

 agent ai, and for every r-i=(r1,…,ri-1,ri+1,…,rN), wi(g(r-i,ri)) is of the form:




Өi(r-i){+}: threshold

paymentfromai is:

pi(r)= Өi(r-i)

Our new goal
Our new goal

To design a (truthful) OP and BD mechanism M=<g,p> satisfying:

  • g is monotone

  • Solution returned by g is a “good” solution, i.e., a provably approximate solution (we will actually show a O(m)-approximate solution, which is tight)

  • g and p are computable (efficiently) in polynomial time

A greedy m approximation algorithm
A greedy m-approximation algorithm

  • reorder (and rename) the bids such that

  • W ; X 

  • for i=1 to n do

    if SiW= then X X{i}; W W{Si}

  • return X

r1/|S1|  r2/|S2|  …  rn/|Sn|

Monotonicity of g

Theorem: The algorithm g is monotone


It suffices to prove that, for any selected agent i, we have that i is still selected when she raises her bid.

In fact, increasing ri can only move bidder i up in the greedy order, making it easier to win for her.

Homework: it is easy to see that the running time of g is polynomial in n and m. What is your faster implementation for g?

Computing the payments
Computing the payments

…we have to compute for each selected bidder i

her threshold value

How much can bidder i decrease her bid until she is non-selected?

Computing the payment p i
Computing the payment pi

Consider the greedy order without i

r1/|S1|  …  ri/|Si|  …  rn/|Sn|

index j

Use the greedy algorithm to find

the smallest index j>i (if any) such that:

1. j is selected

2. SjSi

pi= 0 if j doesn’t exist

Homework: it is easy to see that each payment can be computed in O(mn) time, and so we need a total of O(mn2) time for all the payments. Can you provide a faster implementation?

pi= rj |Si|/|Sj| otherwise

The approximation bound on g

Let OPT be an optimal solution for the CA problem, and let X be the solution computed by the algorithm g, then

iOPT ri  m iX ri



let OPTi={jOPT : j i and SjSi}

Observe that iX OPTi=OPT; indeed, any player j selected in OPT must either have a non-empty intersection with at least a player i<j selected in X, or j is selected in X as well (because of the greedy approach)

rj  m ri


Then it suffices to prove that:


crucial observation

for greedy order we have

ri |Sj|


rj 


proof (contd.)

then, iX



rj 

 m ri






we can bound



 |OPTi|

 |Si|m




≤ m

Cauchy schwarz inequality
Cauchy–Schwarz inequality



…in our case…


n= |OPTi|

for j=1,…,|OPTi|



  • We have introduced a simple type of combinatorial auction, the single-minded one, for which it is computationally hard to find an optimal solution (i.e., a best possible allocation of objects)

  • In a corresponding strategic setting in which types are private, the problem is both utilitarian and one-parameter, but VCG-mechanisms cannot be used since they will return an arbitrarily bad allocation!

  • On the other hand, it is not hard to design an OP-mechanism, which is instead satisfactory: we showed a straigthforward greedy monotone algorithm returning an O(m)-approximate solution, which is tight!