Worst-Case

Optimal

Redistribution

of

VCG

Payments

Mingyu

Guo

Duke

University

Department

of

Computer

Science

Durham,

NC,

USA

mingyu@cs.duke.edu

Vincent

Conitzer

Duke

University

Department

of

Computer

Science

Durham,

NC,

USA

conitzer@cs.duke.edu

ABSTRACT

For

allocation

problems

with

one

or

more

items,

the

wellknown

Vickrey-Clarke-Groves

(VCG)

mechanism

is

efficient,

strategy-proof,

individually

rational,

and

does

not

incur

a

deficit.

However,

the

VCG

mechanism

is

not

(strongly)

budget

balanced:

generally,

the

agents"

payments

will

sum

to

more

than

If

there

is

an

auctioneer

who

is

selling

the

items,

this

may

be

desirable,

because

the

surplus

payment

corresponds

to

revenue

for

the

auctioneer.

However,

if

the

items

do

not

have

an

owner

and

the

agents

are

merely

interested

in

allocating

the

items

efficiently

among

themselves,

any

surplus

payment

is

undesirable,

because

it

will

have

to

flow

out

of

the

system

of

agents.

In

Cavallo

proposed

a

mechanism

that

redistributes

some

of

the

VCG

payment

back

to

the

agents,

while

maintaining

efficiency,

strategy-proofness,

individual

rationality,

and

the

non-deficit

property.

In

this

paper,

we

extend

this

result

in

a

restricted

setting.

We

study

allocation

settings

where

there

are

multiple

indistinguishable

units

of

a

single

good,

and

agents

have

unit

demand.

(For

this

specific

setting,

Cavallo"s

mechanism

coincides

with

a

mechanism

proposed

by

Bailey

in

Here

we

propose

a

family

of

mechanisms

that

redistribute

some

of

the

VCG

payment

back

to

the

agents.

All

mechanisms

in

the

family

are

efficient,

strategyproof,

individually

rational,

and

never

incur

a

deficit.

The

family

includes

the

Bailey-Cavallo

mechanism

as

a

special

case.

We

then

provide

an

optimization

model

for

finding

the

optimal

mechanism-that

is,

the

mechanism

that

maximizes

redistribution

in

the

worst

case-inside

the

family,

and

show

how

to

cast

this

model

as

a

linear

program.

We

give

both

numerical

and

analytical

solutions

of

this

linear

program,

and

the

(unique)

resulting

mechanism

shows

significant

improvement

over

the

Bailey-Cavallo

mechanism

(in

the

worst

case).

Finally,

we

prove

that

the

obtained

mechanism

is

optimal

among

all

anonymous

deterministic

mechanisms

that

satisfy

the

above

properties.

Categories

and

Subject

Descriptors

[Computer

Applications]:

Social

and

Behavioral

Sciences-Economics;

[Distributed

Artificial

Intelligence]:

Multiagent

Systems

General

Terms

Algorithms,

Economics,

Theory

INTRODUCTION

Many

important

problems

in

computer

science

and

electronic

commerce

can

be

modeled

as

resource

allocation

problems.

In

such

problems,

we

want

to

allocate

the

resources

(or

items)

to

the

agents

that

value

them

the

most.

Unfortunately,

agents"

valuations

are

private

knowledge,

and

self-interested

agents

will

lie

about

their

valuations

if

this

is

to

their

benefit.

One

solution

is

to

auction

off

the

items,

possibly

in

a

combinatorial

auction

where

agents

can

bid

on

bundles

of

items.

There

exist

ways

of

determining

the

payments

that

the

agents

make

in

such

an

auction

that

incentivizes

the

agents

to

report

their

true

valuations-that

is,

the

payments

make

the

auction

strategy-proof.

One

very

general

way

of

doing

so

is

to

use

the

VCG

mechanism

(The

VCG

mechanism

is

also

known

as

the

Clarke

mechanism

or,

in

the

specific

context

of

auctions,

the

Generalized

Vickrey

Auction.)

Besides

strategy-proofness,

the

VCG

mechanism

has

several

other

nice

properties

in

the

context

of

resource

allocation

problems.

It

is

efficient:

the

chosen

allocation

always

maximizes

the

sum

of

the

agents"

valuations.

It

is

also

(expost)

individually

rational:

participating

in

the

mechanism

never

makes

an

agent

worse

off

than

not

participating.

Finally,

it

has

a

no-deficit

property:

the

sum

of

the

agents"

payments

is

always

nonnegative.

In

many

settings,

another

property

that

would

be

desirable

is

(strong)

budget

balance,

meaning

that

the

payments

sum

to

exactly

Suppose

the

agents

are

trying

to

distribute

some

resources

among

themselves

that

do

not

have

a

previous

owner.

For

example,

the

agents

may

be

trying

to

allocate

the

right

to

use

a

shared

good

on

a

given

day.

Or,

the

agents

may

be

trying

to

allocate

a

resource

that

they

have

collectively

constructed,

discovered,

or

otherwise

obtained.

If

the

agents

use

an

auction

to

allocate

these

resources,

and

the

sum

of

the

agents"

payments

in

the

auction

is

positive,

then

this

surplus

payment

must

leave

the

system

of

the

agents

(for

example,

the

agents

must

give

the

money

to

an

outside

party,

or

burn

it).

Na¨ıve

redistribution

of

the

surplus

payment

(e.g.

each

of

the

n

agents

receives

of

the

surplus)

will

generally

result

in

a

mechanism

that

is

not

strategy-proof

(e.g.

in

a

Vickrey

auction,

the

second-highest

bidder

would

want

to

increase

her

bid

to

obtain

a

larger

redistribution

payment).

Unfortunately,

the

VCG

mechanism

is

not

budget

balanced:

typically,

there

is

surplus

payment.

Unfortunately,

in

general

settings,

it

is

in

fact

impossible

to

design

mechanisms

that

satisfy

budget

balance

in

addition

to

the

other

desirable

properties

In

light

of

this

impossibility

result,

several

authors

have

obtained

budget

balance

by

sacrificing

some

of

the

other

desirable

properties

Another

approach

that

is

perhaps

preferable

is

to

use

a

mechanism

that

is

more

budget

balanced

than

the

VCG

mechanism,

and

maintains

all

the

other

desirable

properties.

One

way

of

trying

to

design

such

a

mechanism

is

to

redistribute

some

of

the

VCG

payment

back

to

the

agents

in

a

way

that

will

not

affect

the

agents"

incentives

(so

that

strategy-proofness

is

maintained),

and

that

will

maintain

the

other

properties.

In

Cavallo

pursued

exactly

this

idea,

and

designed

a

mechanism

that

redistributes

a

large

amount

of

the

total

VCG

payment

while

maintaining

all

of

the

other

desirable

properties

of

the

VCG

mechanism.

For

example,

in

a

single-item

auction

(where

the

VCG

mechanism

coincides

with

the

second-price

sealed-bid

auction),

the

amount

redistributed

to

bidder

i

by

Cavallo"s

mechanism

is

times

the

second-highest

bid

among

bids

other

than

i"s

bid.

The

total

redistributed

is

at

most

the

second-highest

bid

overall,

and

the

redistribution

to

agent

i

does

not

affect

i"s

incentives

because

it

does

not

depend

on

i"s

own

bid.

In

this

paper,

we

restrict

our

attention

to

a

limited

setting,

and

in

this

setting

we

extend

Cavallo"s

result.

We

study

allocation

settings

where

there

are

multiple

indistinguishable

units

of

a

single

good,

and

all

agents

have

unit

demand,

i.e.

they

want

only

a

single

unit.

For

this

specific

setting,

Cavallo"s

mechanism

coincides

with

a

mechanism

proposed

by

Bailey

in

Here

we

propose

the

family

of

linear

VCG

redistribution

mechanisms.

All

mechanisms

in

this

family

are

efficient,

strategy-proof,

individually

rational,

and

never

incur

a

deficit.

The

family

includes

the

Bailey-Cavallo

mechanism

as

a

special

case

(with

the

caveat

that

we

only

study

allocation

settings

with

multiple

indistinguishable

units

of

a

single

good

and

unit

demand,

while

Bailey"s

and

Cavallo"s

mechanisms

can

be

applied

outside

these

settings

as

well).

We

then

provide

an

optimization

model

for

finding

the

optimal

mechanism

inside

the

family,

based

on

worst-case

analysis.

Both

numerical

and

analytical

solutions

of

this

model

are

provided,

and

the

resulting

mechanism

shows

significant

improvement

over

the

BaileyCavallo

mechanism

(in

the

worst

case).

For

example,

for

the

problem

of

allocating

a

single

unit,

when

the

number

of

agents

is

our

mechanism

always

redistributes

more

than

of

the

total

VCG

payment

back

to

the

agents

(whereas

the

Bailey-Cavallo

mechanism

redistributes

only

in

the

worst

case).

Finally,

we

prove

that

our

mechanism

is

in

fact

optimal

among

all

anonymous

deterministic

mechanisms

(even

nonlinear

ones)

that

satisfy

the

desirable

properties.

Around

the

same

time,

the

same

mechanism

has

been

independently

derived

by

Moulin

Moulin

actually

pursues

a

different

objective

(also

based

on

worst-case

analysis):

whereas

our

objective

is

to

maximize

the

percentage

of

VCG

payments

that

are

redistributed,

Moulin

tries

to

minimize

the

overall

payments

from

agents

as

a

percentage

of

efficiency.

It

turns

out

that

the

resulting

mechanisms

are

the

same.

Towards

the

end

of

this

paper,

we

consider

dropping

the

individual

rationality

requirement,

and

show

that

this

does

not

change

the

optimal

mechanism

for

our

objective.

For

Moulin"s

objective,

dropping

individual

rationality

does

change

the

optimal

mechanism

(but

only

if

there

are

multiple

units).

PROBLEM

DESCRIPTION

Let

n

denote

the

number

of

agents,

and

let

m

denote

the

number

of

units.

We

only

consider

the

case

where

m

n

(otherwise

the

problem

becomes

trivial).

We

also

assume

that

m

and

n

are

always

known.

(This

assumption

is

not

harmful:

in

environments

where

anyone

can

join

the

auction,

running

a

redistribution

mechanism

is

typically

not

a

good

idea

anyway,

because

everyone

would

want

to

join

to

collect

part

of

the

redistribution.)

Let

the

set

of

agents

be

an},

where

ai

is

the

agent

with

ith

highest

report

value

ˆvi-that

is,

we

have

ˆvn

Let

vi

denote

the

true

value

of

ai.

Given

that

the

mechanism

is

strategy-proof,

we

can

assume

vi

ˆvi.

Under

the

VCG

mechanism,

each

agent

among

am

wins

a

unit,

and

pays

for

this

unit.

Thus,

the

total

VCG

payment

equals

When

m

this

is

the

second-price

or

Vickrey

auction.

We

modify

the

mechanism

as

follows.

After

running

the

original

VCG

mechanism,

the

center

returns

to

each

agent

ai

some

amount

zi,

agent

ai"s

redistribution

payment.

We

do

not

allow

zi

to

depend

on

ˆvi;

because

of

this,

ai"s

incentives

are

unaffected

by

this

redistribution

payment,

and

the

mechanism

remains

strategy-proof.

LINEAR

VCG

REDISTRIBUTION

MECHANISMS

We

are

now

ready

to

introduce

the

family

of

linear

VCG

redistribution

mechanisms.

Such

a

mechanism

is

defined

by

a

vector

of

constants

The

amount

that

the

mechanism

returns

to

agent

ai

is

zi

That

is,

an

agent

receives

plus

times

the

highest

bid

other

than

the

agent"s

own

bid,

plus

times

the

second-highest

other

bid,

etc.

The

mechanism

is

strategy-proof,

because

for

all

i,

zi

is

independent

of

ˆvi.

Also,

the

mechanism

is

anonymous.

It

is

helpful

to

see

the

entire

list

of

redistribution

payments:

zi

zn

We

thank

Rakesh

Vohra

for

pointing

us

to

Moulin"s

working

paper.

Not

all

choices

of

the

constants

produce

a

mechanism

that

is

individually

rational,

and

not

all

choices

of

the

constants

produce

a

mechanism

that

never

incurs

a

deficit.

Hence,

to

obtain

these

properties,

we

need

to

place

some

constraints

on

the

constants.

To

satisfy

the

individual

rationality

criterion,

each

agent"s

utility

should

always

be

non-negative.

An

agent

that

does

not

win

a

unit

obtains

a

utility

that

is

equal

to

the

agent"s

redistribution

payment.

An

agent

that

wins

a

unit

obtains

a

utility

that

is

equal

to

the

agent"s

valuation

for

the

unit,

minus

the

VCG

payment

plus

the

agent"s

redistribution

payment.

Consider

agent

an,

the

agent

with

the

lowest

bid.

Since

this

agent

does

not

win

an

item

(m

n),

her

utility

is

just

her

redistribution

payment

zn.

Hence,

for

the

mechanism

to

be

individually

rational,

the

ci

must

be

such

that

zn

is

always

nonnegative.

If

the

ci

have

this

property,

then

it

actually

follows

that

zi

is

nonnegative

for

every

i,

for

the

following

reason.

Suppose

there

exists

some

i

n

and

some

vector

of

bids

ˆvn

such

that

zi

Then,

consider

the

bid

vector

that

results

from

replacing

ˆvj

by

for

all

j

i,

and

letting

ˆvn

If

we

omit

ˆvn

from

this

vector,

the

same

vector

results

that

results

from

omitting

ˆvi

from

the

original

vector.

Therefore,

an"s

redistribution

payment

under

the

new

vector

should

be

the

same

as

ai"s

redistribution

payment

under

the

old

vector-but

this

payment

is

negative.

If

all

redistribution

payments

are

always

nonnegative,

then

the

mechanism

must

be

individually

rational

(because

the

VCG

mechanism

is

individually

rational,

and

the

redistribution

payment

only

increases

an

agent"s

utility).

Therefore,

the

mechanism

is

individually

rational

if

and

only

if

for

any

bid

vector,

zn

To

satisfy

the

non-deficit

criterion,

the

sum

of

the

redistribution

payments

should

be

less

than

or

equal

to

the

total

VCG

payment.

So

for

any

bid

vector

ˆvn

the

constants

ci

should

make

zn

We

define

the

family

of

linear

VCG

redistribution

mechanisms

to

be

the

set

of

all

redistribution

mechanisms

corresponding

to

constants

ci

that

satisfy

the

above

constraints

(so

that

the

mechanisms

will

be

individually

rational

and

have

the

no-deficit

property).

We

now

give

two

examples

of

mechanisms

in

this

family.

Example

(Bailey-Cavallo

mechanism):

Consider

the

mechanism

corresponding

to

m

n

and

ci

for

all

other

i.

Under

this

mechanism,

each

agent

receives

a

redistribution

payment

of

m

n

times

the

highest

bid

from

another

agent.

Hence,

receive

a

redistribution

payment

of

m

n

and

the

others

receive

m

n

Thus,

the

total

redistribution

payment

is

n

+(n−m−

n

This

redistribution

mechanism

is

individually

rational,

because

all

the

redistribution

payments

are

nonnegative,

and

never

incurs

a

deficit,

because

(m

m

n

n

nm

n

(We

note

that

for

this

mechanism

to

make

sense,

we

need

n

m

Example

Consider

the

mechanism

corresponding

to

m

and

ci

for

all

other

i.

In

this

mechanism,

each

agent

receives

a

redistribution

payment

of

m

times

the

(m

highest

reported

value

from

other

agents,

minus

times

the

highest

reported

value

from

other

agents.

Thus,

the

total

redistribution

payment

is

If

n

(which

is

equivalent

to

m

then

each

agent

always

receives

a

nonnegative

redistribution

payment,

thus

the

mechanism

is

individually

rational.

Also,

the

mechanism

never

incurs

a

deficit,

because

the

total

VCG

payment

is

which

is

greater

than

the

amount

that

is

redistributed.

Which

of

these

two

mechanisms

is

better?

Is

there

another

mechanism

that

is

even

better?

This

is

what

we

study

in

the

next

section.

OPTIMAL

REDISTRIBUTION

MECHANISMS

Among

all

linear

VCG

redistribution

mechanisms,

we

would

like

to

be

able

to

identify

the

one

that

redistributes

the

greatest

percentage

of

the

total

VCG

This

is

not

a

well-defined

notion:

it

may

be

that

one

mechanism

redistributes

more

on

some

bid

vectors,

and

another

more

on

other

bid

vectors.

We

emphasize

that

we

do

not

assume

that

a

prior

distribution

over

bidders"

valuations

is

available,

so

we

cannot

compare

them

based

on

expected

redistribution.

Below,

we

study

three

well-defined

ways

of

comparing

redistribution

mechanisms:

best-case

performance,

dominance,

and

worst-case

performance.

Best-case

performance.

One

way

of

evaluating

a

mechanism

is

by

considering

the

highest

redistribution

percentage

that

it

achieves.

Consider

the

previous

two

examples.

For

the

first

example,

the

total

redistribution

payment

is

(m

n

(n

m

n

When

this

is

equal

to

the

total

VCG

payment

Thus,

this

mechanism

redistributes

of

the

total

VCG

payment

in

the

best

case.

For

the

second

example,

the

total

redistribution

payment

is

When

this

is

equal

to

the

total

VCG

payment

Thus,

this

mechanism

also

redistributes

of

the

total

VCG

payment

in

the

best

case.

Moreover,

there

are

actually

infinitely

many

mechanisms

that

redistribute

of

the

total

VCG

payment

in

the

best

case-for

example,

any

convex

combination

of

the

above

two

will

redistribute

if

both

and

Dominance.

Inside

the

family

of

linear

VCG

redistribution

mechanisms,

we

say

one

mechanism

dominates

another

mechanism

if

the

first

one

redistributes

at

least

as

much

as

the

other

for

any

bid

vector.

For

the

previous

two

examples,

neither

dominates

the

other,

because

they

each

redistribute

in

different

cases.

It

turns

out

that

there

is

no

mechanism

in

the

family

that

dominates

all

other

mechanisms

in

the

family.

For

suppose

such

a

mechanism

exists.

Then,

it

should

dominate

both

examples

above.

Consider

the

remaining

VCG

payment

(the

VCG

payment

failed

to

be

redistributed).

The

remaining

VCG

payment

of

the

dominant

mechanism

should

be

whenever

or

Now,

the

remaining

VCG

payment

is

a

linear

function

of

the

ˆvi

(linear

redistribution),

and

therefore

also

a

polynomial

function.

The

above

implies

that

this

function

can

be

written

as

ˆvn),

where

P

is

a

The

percentage

redistributed

seems

the

natural

criterion

to

use,

among

other

things

because

it

is

scale-invariant:

if

we

multiply

all

bids

by

the

same

positive

constant

(for

example,

if

we

change

the

units

by

re-expressing

the

bids

in

euros

instead

of

dollars),

we

would

not

want

the

behavior

of

our

mechanism

to

change.

polynomial

function.

But

since

the

function

must

be

linear

(has

degree

at

most

it

follows

that

P

Thus,

a

dominant

mechanism

would

always

redistribute

all

of

the

VCG

payment,

which

is

not

possible.

(If

it

were

possible,

then

our

worst-case

optimal

redistribution

mechanism

would

also

always

redistribute

all

of

the

VCG

payment,

and

we

will

see

later

that

it

does

not.)

Worst-case

performance.

Finally,

we

can

evaluate

a

mechanism

by

considering

the

lowest

redistribution

percentage

that

it

guarantees.

For

the

first

example,

the

total

redistribution

payment

is

n

n

which

is

greater

than

or

equal

to

m

n

So

in

the

worst

case,

which

is

when

the

percentage

redistributed

is

n

For

the

second

example,

the

total

redistribution

payment

is

which

is

greater

than

or

equal

to

So

in

the

worst

case,

which

is

when

the

percentage

redistributed

is

Since

we

assume

that

the

number

of

agents

n

and

the

number

of

units

m

are

known,

we

can

determine

which

example

mechanism

has

better

worst-case

performance

by

comparing

the

two

quantities.

When

n

and

m

for

the

first

example

(Bailey-Cavallo

mechanism),

the

percentage

redistributed

in

the

worst

case

is

and

for

the

second

example,

this

percentage

is

which

implies

that

for

this

pair

of

n

and

m,

the

first

mechanism

has

better

worst-case

performance.

On

the

other

hand,

when

n

and

m

for

the

first

example,

the

percentage

redistributed

in

the

worst

case

is

and

for

the

second

example,

this

percentage

is

which

implies

that

this

time

the

second

mechanism

has

better

worst-case

performance.

Thus,

it

seems

most

natural

to

compare

mechanisms

by

the

percentage

of

total

VCG

payment

that

they

redistribute

in

the

worst

case.

This

percentage

is

undefined

when

the

total

VCG

payment

is

To

deal

with

this,

technically,

we

define

the

worst-case

redistribution

percentage

as

the

largest

k

so

that

the

total

amount

redistributed

is

at

least

k

times

the

total

VCG

payment,

for

all

bid

vectors.

(Hence,

as

long

as

the

total

amount

redistributed

is

at

least

when

the

total

VCG

payment

is

these

cases

do

not

affect

the

worst-case

percentage.)

This

corresponds

to

the

following

optimization

problem:

Maximize

k

(the

percentage

redistributed

in

the

worst

case)

Subject

to:

For

every

bid

vector

ˆvn

zn

(individual

rationality)

zn

(non-deficit)

zn

(worst-case

constraint)

We

recall

that

zi

TRANSFORMATION

TO

LINEAR

PROGRAMMING

The

optimization

problem

given

in

the

previous

section

can

be

rewritten

as

a

linear

program,

based

on

the

following

observations.

Claim

If

satisfy

both

the

individual

rationality

and

the

non-deficit

constraints,

then

ci

for

i

m.

Proof.

First,

let

us

prove

that

Consider

the

bid

vector

in

which

ˆvi

for

all

i.

To

obtain

individual

rationality,

we

must

have

To

satisfy

the

non-deficit

constraint,

we

must

have

Thus

we

know

Now,

if

ci

for

all

i,

there

is

nothing

to

prove.

Otherwise,

let

j

min{i|ci

Assume

that

j

m.

We

recall

that

we

can

write

the

individual

rationality

constraint

as

follows:

zn

for

any

bid

vector.

Let

us

consider

the

bid

vector

in

which

ˆvi

for

i

j

and

ˆvi

for

the

rest.

In

this

case

zn

cj,

so

we

must

have

cj

The

non-deficit

constraint

can

be

written

as

follows:

zn

for

any

bid

vector.

Consider

the

same

bid

vector

as

above.

We

have

zi

for

i

j,

because

for

these

bids,

the

jth

highest

other

bid

has

value

so

all

the

ci

that

are

nonzero

are

multiplied

by

For

i

j,

we

have

zi

cj,

because

the

jth

highest

other

bid

has

value

and

all

lower

bids

have

value

So

the

non-deficit

constraint

tells

us

that

cj(n

j)

Because

j

m,

so

the

right

hand

side

is

We

also

have

n

j

because

j

m

n.

So

cj

Because

we

have

already

established

that

cj

it

follows

that

cj

but

this

is

contrary

to

assumption.

So

j

m.

Incidentally,

this

claim

also

shows

that

if

m

n

then

ci

for

all

i.

Thus,

we

are

stuck

with

the

VCG

mechanism.

From

here

on,

we

only

consider

the

case

where

m

n

Claim

The

individual

rationality

constraint

can

be

written

as

follows:

Pj

ci

for

j

m

n

Before

proving

this

claim,

we

introduce

the

following

lemma.

Lemma

Given

a

positive

integer

k

and

a

set

of

real

constants

sk,

sktk

for

any

tk

if

and

only

if

Pj

si

for

j

k).

Proof.

Let

di

ti

for

i

and

dk

tk.

Then

.+sktk

for

any

tk

is

equivalent

to

Pk

si)dk

for

any

set

of

arbitrary

non-negative

dj).

When

Pj

si

for

j

k,

the

above

inequality

is

obviously

true.

If

for

some

j,

Pj

si

if

we

set

dj

and

di

for

all

i

j,

then

the

above

inequality

becomes

false.

So

Pj

si

for

j

k

is

both

necessary

and

sufficient.

We

are

now

ready

to

present

the

proof

of

Claim

Proof.

The

individual

rationality

constraint

can

be

written

as

zn

for

any

bid

vector

ˆvn

We

have

already

shown

that

ci

for

i

m.

Thus,

the

above

can

be

simplified

to

zn

for

any

bid

vector.

By

the

above

lemma,

this

is

equivalent

to

Pj

ci

for

j

m

n

Claim

The

non-deficit

constraint

and

the

worst-case

constraint

can

also

be

written

as

linear

inequalities

involving

only

the

ci

and

k.

Proof.

The

non-deficit

constraint

requires

that

for

any

bid

vector,

.+zn

where

zi

for

i

n.

Because

ci

for

i

m,

we

can

simplify

this

inequality

to

qnˆvn

m

(n

m

qi

−(n−i)ci,

for

i

(when

m

n

this

set

of

equalities

is

empty)

qn

−(n

By

the

above

lemma,

this

is

equivalent

to

Pj

qi

for

j

m

n.

So,

we

can

simplify

further

as

follows:

(n

m

m

qm+i

n

cj

(n

m

i)cm+i

m

for

i

n

m

qn

n

cj

m

So,

the

non-deficit

constraint

can

be

written

as

a

set

of

linear

inequalities

involving

only

the

ci.

The

worst-case

constraint

can

be

also

written

as

a

set

of

linear

inequalities,

by

the

following

reasoning.

The

worstcase

constraint

requires

that

for

any

bid

input

zn

where

zi

for

i

n.

Because

ci

for

i

m,

we

can

simplify

this

inequality

to

Qnˆvn

(n

m

km

Qi

(i

(n

i)ci,

for

i

m

n

Qn

(n

By

the

above

lemma,

this

is

equivalent

to

Pj

Qi

for

j

m

n.

So,

we

can

simplify

further

as

follows:

(n

m

km

Qm+i

n

cj

(n

m

i)cm+i

km

for

i

n

m

Qn

n

cj

km

So,

the

worst-case

constraint

can

also

be

written

as

a

set

of

linear

inequalities

involving

only

the

ci

and

k.

Combining

all

the

claims,

we

see

that

the

original

optimization

problem

can

be

transformed

into

the

following

linear

program.

Variables:

k

Maximize

k

(the

percentage

redistributed

in

the

worst

case)

Subject

to:Pj

ci

for

j

m

n

km

(n

m

m

km

n

cj

(n

m

i)cm+i

m

for

i

n

m

km

n

cj

m

NUMERICAL

RESULTS

For

selected

values

of

n

and

m,

we

solved

the

linear

program

using

Glpk

(GNU

Linear

Programming

Kit).

In

the

table

below,

we

present

the

results

for

a

single

unit

(m

We

present

(the

percentage

of

the

total

VCG

payment

that

is

not

redistributed

by

the

worst-case

optimal

mechanism

in

the

worst

case)

instead

of

k

in

the

second

column

because

writing

k

would

require

too

many

significant

digits.

Correspondingly,

the

third

column

displays

the

percentage

Number

of

AgentsWorst−caseRedistributionPercentage

Unit

WO

Unit

BC

Units

WO

Units

BC

Units

WO

Units

BC

Units

WO

Units

BC

Figure

A

comparison

of

the

worst-case

optimal

mechanism

(WO)

and

the

Bailey-Cavallo

mechanism

(BC).

of

the

total

VCG

payment

that

is

not

redistributed

by

the

Bailey-Cavallo

mechanism

in

the

worst

case

(which

is

equal

to

n

n

k

Bailey

Cavallo

Mechanism

The

worst-case

optimal

mechanism

significantly

outperforms

the

Bailey-Cavallo

mechanism

in

the

worst

case.

Perhaps

more

surprisingly,

the

worst-case

optimal

mechanism

sometimes

does

better

in

the

worst

case

than

the

BaileyCavallo

mechanism

does

on

average,

as

the

following

example

shows.

Recall

that

the

total

redistribution

payment

of

the

BaileyCavallo

mechanism

is

(m

n

(n

m

n

For

the

single-unit

case,

this

simplifies

to

n

n

Hence

the

percentage

of

the

total

VCG

payment

that

is

not

redistributed

is

ˆv2−

n

ˆv3−

n

n

n

which

has

an

expected

value

of

E(

n

n

n

n

E

Suppose

the

bid

values

are

drawn

from

a

uniform

distribution

over

The

theory

of

order

statistics

tells

us

that

the

joint

probability

density

function

of

and

is

n(n

for

Now,

E

R

R

So,

the

expected

value

of

the

remaining

percentage

is

n

n

For

n

this

is

whereas

the

remaining

percentage

for

the

worst-case

optimal

mechanism

is

in

the

worst

case.

Let

us

present

the

optimal

solution

for

the

case

n

in

detail.

By

solving

the

above

linear

program,

we

find

that

the

optimal

values

for

the

ci

are

−1

and

That

is,

the

redistribution

payment

received

by

each

agent

is:

times

the

second

highest

bid

among

the

other

agents,

minus

times

the

third

highest

bid

among

the

other

agents,

plus

times

the

fourth

highest

bid

among

the

other

agents.

The

total

amount

redistributed

is

in

the

worst

case,

is

redistributed.

Hence,

the

percentage

of

the

total

VCG

payment

that

is

not

redistributed

is

never

more

than

Finally,

we

compare

the

worst-case

optimal

mechanism

to

the

Bailey-Cavallo

mechanism

for

m

n

m

These

results

are

in

Figure

We

see

that

for

any

m,

when

n

m

the

worst-case

optimal

mechanism

has

the

same

worst-case

performance

as

the

Bailey-Cavallo

mechanism

(actually,

in

this

case,

the

worst-case

optimal

mechanism

is

identical

to

the

BaileyCavallo

mechanism).

When

n

m

the

worst-case

optimal

mechanism

outperforms

the

Bailey-Cavallo

mechanism

(in

the

worst

case).

ANALYTICAL

CHARACTERIZATION

OF

THE

WORST-CASE

OPTIMAL

MECHANISM

We

recall

that

our

linear

program

has

the

following

form:

Variables:

k

Maximize

k

(the

percentage

redistributed

in

the

worst

case)

Subject

to:Pj

ci

for

j

m

n

km

(n

m

m

km

n

cj

(n

m

i)cm+i

m

for

i

n

m

km

n

cj

m

A

linear

program

has

no

solution

if

and

only

if

either

the

objective

is

unbounded,

or

the

constraints

are

contradictory

(there

is

no

feasible

solution).

It

is

easy

to

see

that

k

is

bounded

above

by

(redistributing

more

than

violates

the

non-deficit

constraint).

Also,

a

feasible

solution

always

exists,

for

example,

k

and

ci

for

all

i.

So

an

optimal

solution

always

exists.

Observe

that

the

linear

program

model

depends

only

on

the

number

of

agents

n

and

the

number

of

units

m.

Hence

the

optimal

solution

is

a

function

of

n

and

m.

It

turns

out

that

this

optimal

solution

can

be

analytically

characterized

as

follows.

Theorem

For

any

m

and

n

with

n

the

worstcase

optimal

mechanism

(among

linear

VCG

redistribution

mechanisms)

is

unique.

For

this

mechanism,

the

percentage

redistributed

in

the

worst

case

is

k∗

m

j=m

j

The

worst-case

optimal

mechanism

is

characterized

by

the

following

values

for

the

ci:

c∗

i

(n

m)

i

j=m

j

i

j=i

n

j

for

i

m

n

It

should

be

noted

that

we

have

proved

ci

for

i

m

in

Claim

Proof.

We

first

rewrite

the

linear

program

as

follows.

We

introduce

new

variables

defined

by

xj

Pj

ci

for

j

m

n

The

linear

program

then

becomes:

Variables:

k

Maximize

k

Subject

to:

km

(n

m

m

km

(m

(n

m

i)xm+i

m

for

i

n

m

km

m

xi

for

i

m

m

n

We

will

prove

that

for

any

optimal

solution

to

this

linear

program,

k

k∗

Moreover,

we

will

prove

that

when

k

k∗

xj

Pj

c∗

i

for

j

m

n

This

will

prove

the

theorem.

We

first

make

the

following

observations:

(n

m

(n

m

j=m

j

j

(n

m

j=m

j

j=m

j

m

(n

m

m

(n

m

m

j=m

j

m

k∗

)m

k∗

m

For

i

m

n

ic∗

i

(n

i

i

i

j=m

j

i

j=i

j

(n

i

j=m

j

j

j=m

j

i

j=i

j

(n

i

j=m

j

i

j

j=m

j

k∗

Finally,

(n

(n

j=m

j

j

k∗

Summarizing

the

above,

we

have:

(n

m

k∗

m

(m

(n

m

k∗

(m

(n

m

k∗

(m

(n

m

k∗

(n

k∗

(n

c∗

k∗

(n

k∗

Let

x∗

j

Pj

c∗

i

for

j

m

m

n

the

first

equation

in

the

above

tells

us

that

(n

m

k∗

m.

By

adding

the

first

two

equations,

we

get

(m

(n

m

m

By

adding

the

first

three

equations,

we

get

(m

(n

m

k∗

m

By

adding

the

first

i

equations,

where

i

we

get

(m

i)x∗

(n

m

i)x∗

m+i

m

if

i

is

even

(m

i)x∗

(n

m

i)x∗

m+i

k∗

m

if

i

is

odd

Finally

by

adding

all

the

equations,

we

get

nx∗

m

if

n

m

is

even;

nx∗

k∗

m

if

n

m

is

odd.

Thus,

for

all

of

the

constraints

other

than

the

nonnegativity

constraints,

we

have

shown

that

they

are

satisfied

by

setting

xj

x∗

j

Pj

c∗

i

and

k

k∗

We

next

show

that

the

nonnegativity

constraints

are

satisfied

by

these

settings

as

well.

For

m

i,

i

n

we

have

i

j=i

j

i

i

j=i

j=i

j=i

j

This

implies

that

the

absolute

value

of

c∗

i

is

decreasing

as

i

increases

(if

the

c∗

contains

more

than

one

number).

We

further

observe

that

the

sign

of

c∗

i

alternates,

with

the

first

element

c∗

positive.

So

x∗

j

Pj

c∗

i

for

all

j.

Thus,

we

have

shown

that

these

xi

x∗

i

together

with

k

k∗

form

a

feasible

solution

of

the

linear

program.

We

proceed

to

show

that

it

is

in

fact

the

unique

optimal

solution.

First

we

prove

the

following

claim:

Claim

If

ˆk,

ˆxi,

i

m

m

n

satisfy

the

following

inequalities:

ˆkm

(n

m

m

ˆkm

(m

(n

m

i)ˆxm+i

m

for

i

n

m

ˆkm

m

ˆk

k∗

Then

we

must

have

that

ˆxi

ˆx∗

i

and

ˆk

k∗

Proof

of

claim.

Consider

the

first

inequality.

We

know

that

(n

m

k∗

m,

so

(n

m

ˆkm

k∗

m

(n

m

It

follows

that

x∗

(n

m

Now,

consider

the

next

inequality

for

i

We

know

that

(m

(n

m

m.

It

follows

that

(n

m

so

x∗

(i

n

m

n

m

Now

consider

the

next

inequality

for

i

We

know

that

(m

(n

m

m.

It

follows

that

k∗

(n

m

so

x∗

(i

n

m

n

m

Proceeding

like

this

all

the

way

up

to

i

we

get

that

ˆxm+i

x∗

m+i

if

i

is

odd

and

ˆxm+i

x∗

m+i

if

i

is

even.

Moreover,

if

one

inequality

is

strict,

then

all

subsequent

inequalities

are

strict.

Now,

if

we

can

prove

x∗

it

would

follow

that

the

x∗

i

are

equal

to

the

ˆxi

(which

also

implies

that

ˆk

k∗

We

consider

two

cases:

Case

n

m

is

even.

We

have:

n

m

even

n

m

odd

x∗

We

also

have:

n−m

even

nx∗

m.

Combining

these

two,

we

get

m

nx∗

m

x∗

Case

n

m

is

odd.

In

this

case,

we

have

x∗

and

nx∗

k∗

m.

Then,

we

have:

k∗

m

ˆkm

nx∗

k∗

m

x∗

This

completes

the

proof

of

the

claim.

It

follows

that

if

ˆk,

ˆxi,

i

m

m

n

is

a

feasible

solution

and

ˆk

k∗

then

since

all

the

inequalities

in

Claim

are

satisfied,

we

must

have

ˆxi

x∗

i

and

ˆk

k∗

Hence

no

other

feasible

solution

is

as

good

as

the

one

described

in

the

theorem.

Knowing

the

analytical

characterization

of

the

worst-case

optimal

mechanism

provides

us

with

at

least

two

major

benefits.

First,

using

these

formulas

is

computationally

more

efficient

than

solving

the

linear

program

using

a

generalpurpose

solver.

Second,

we

can

derive

the

following

corollary.

Corollary

If

the

number

of

units

m

is

fixed,

then

as

the

number

of

agents

n

increases,

the

worst-case

percentage

redistributed

linearly

converges

to

with

a

rate

of

convergence

(That

is,

limn→∞

1−k∗

1−k∗

n

That

is,

in

the

limit,

the

percentage

that

is

not

redistributed

halves

for

every

additional

agent.)

We

note

that

this

is

consistent

with

the

experimental

data

for

the

single-unit

case,

where

the

worst-case

remaining

percentage

roughly

halves

each

time

we

add

another

agent.

The

worst-case

percentage

that

is

redistributed

under

the

Bailey-Cavallo

mechanism

also

converges

to

as

the

number

of

agents

goes

to

infinity,

but

the

convergence

is

much

slower-it

does

not

converge

linearly

(that

is,

letting

kC

n

be

the

percentage

redistributed

by

the

Bailey-Cavallo

mechanism

in

the

worst

case

for

n

agents,

limn→∞

n

limn→∞

n

We

now

present

the

proof

of

the

corollary.

Proof.

When

the

number

of

agents

is

n,

the

worst-case

percentage

redistributed

is

k∗

n

m

j=m

j

When

the

number

of

agents

is

n

the

percentage

becomes

k∗

(n

m)

Pn

j=m

(n

j

For

n

sufficiently

large,

we

will

have

and

hence

1−k∗

1−k∗

n

(n

m)

j=m

j

m

Pn

j=m

(n

j

n

n−m

j

(n

j

and

n

n−m

1−k∗

1−k∗

n

n

n−m

(because

`n

j

ni

if

j

i).

Since

we

have

limn→∞

n

n−m

and

limn→∞

n

n−m

it

follows

that

limn→∞

1−k∗

1−k∗

n

WORST-CASE

OPTIMALITY

OUTSIDE

THE

FAMILY

In

this

section,

we

prove

that

the

worst-case

optimal

redistribution

mechanism

among

linear

VCG

redistribution

mechanisms

is

in

fact

optimal

(in

the

worst

case)

among

all

redistribution

mechanisms

that

are

deterministic,

anonymous,

strategy-proof,

efficient

and

satisfy

the

non-deficit

constraint.

Thus,

restricting

our

attention

to

linear

VCG

redistribution

mechanisms

did

not

come

at

a

loss.

To

prove

this

theorem,

we

need

the

following

lemma.

This

lemma

is

not

new:

it

was

informally

stated

by

Cavallo

For

completeness,

we

present

it

here

with

a

detailed

proof.

Lemma

A

VCG

redistribution

mechanism

is

deterministic,

anonymous

and

strategy-proof

if

and

only

if

there

exists

a

function

f

R,

so

that

the

redistribution

payment

zi

received

by

ai

satisfies

zi

ˆvn)

for

all

i

and

all

bid

vectors.

Proof.

First,

let

us

prove

the

only

if

direction,

that

is,

if

a

VCG

redistribution

mechanism

is

deterministic,

anonymous

and

strategy-proof

then

there

exists

a

deterministic

function

f

R,

which

makes

zi

ˆvn)

for

all

i

and

all

bid

vectors.

If

a

VCG

redistribution

mechanism

is

deterministic

and

anonymous,

then

for

any

bid

vector

ˆvn,

the

mechanism

outputs

a

unique

redistribution

payment

list:

zn.

Let

G

Rn

Rn

be

the

function

that

maps

ˆvn

to

zn

for

all

bid

vectors.

Let

H(i,

xn)

be

the

ith

element

of

xn),

so

that

zi

H(i,

ˆvn)

for

all

bid

vectors

and

all

i

n.

Because

the

mechanism

is

anonymous,

two

agents

should

receive

the

same

redistribution

payment

if

their

bids

are

the

same.

So,

if

ˆvi

ˆvj,

H(i,

ˆvn)

H(j,

ˆvn).

Hence,

if

we

let

j

min{t|ˆvt

ˆvi},

then

H(i,

ˆvn)

H(j,

ˆvn).

Let

us

define

K

Rn

N

Rn

as

follows:

K(y,

[j,

wn],

where

wn

are

y,

sorted

in

descending

order,

and

j

min{t|wt

y}.

({t|wt

y}

because

y

wn}).

Also

let

us

define

F

Rn

R

by

F(ˆvi,

ˆvn)

H

K(ˆvi,

ˆvn)

H(min{t|ˆvt

ˆvi},

ˆvn)

H(i,

ˆvn)

zi.

That

is,

F

is

the

redistribution

payment

to

an

agent

that

bids

ˆvi

when

the

other

bids

are

ˆvn.

Since

our

mechanism

is

required

to

be

strategy-proof,

and

the

space

of

valuations

is

unrestricted,

zi

should

be

independent

of

ˆvi

by

Lemma

in

Cavallo

Hence,

we

can

simply

ignore

the

first

variable

input

to

F;

let

So,

we

have

for

all

bid

vectors

and

i,

zi

ˆvn).

This

completes

the

proof

for

the

only

if

direction.

For

the

if

direction,

if

the

redistribution

payment

received

by

ai

satisfies

zi

ˆvn)

for

all

bid

vectors

and

i,

then

this

is

clearly

a

deterministic

and

anonymous

mechanism.

To

prove

strategy-proofness,

we

observe

that

because

an

agent"s

redistribution

payment

is

not

affected

by

her

own

bid,

her

incentives

are

the

same

as

in

the

VCG

mechanism,

which

is

strategy-proof.

Now

we

are

ready

to

introduce

the

next

theorem:

Theorem

For

any

m

and

n

with

n

the

worstcase

optimal

mechanism

among

the

family

of

linear

VCG

redistribution

mechanisms

is

worst-case

optimal

among

all

mechanisms

that

are

deterministic,

anonymous,

strategy-proof,

efficient

and

satisfy

the

non-deficit

constraint.

While

we

needed

individual

rationality

earlier

in

the

paper,

this

theorem

does

not

mention

it,

that

is,

we

can

not

find

a

mechanism

with

better

worst-case

performance

even

if

we

sacrifice

individual

rationality.

(The

worst-case

optimal

linear

VCG

redistribution

mechanism

is

of

course

individually

rational.)

Proof.

Suppose

there

is

a

redistribution

mechanism

(when

the

number

of

units

is

m

and

the

number

of

agents

is

n)

that

satisfies

all

of

the

above

properties

and

has

a

better

worstcase

performance

than

the

worst-case

optimal

linear

VCG

redistribution

mechanism,

that

is,

its

worst-case

redistribution

percentage

ˆk

is

strictly

greater

than

k∗

By

Lemma

for

this

mechanism,

there

is

a

function

f

R

so

that

zi

ˆvn)

for

all

i

and

all

bid

vectors.

We

first

prove

that

f

has

the

following

properties.

Claim

if

the

number

of

is

less

than

or

equal

to

m.

Proof

of

claim.

We

assumed

that

for

this

mechanism,

the

worst-case

redistribution

percentage

satisfies

ˆk

k∗

If

the

total

VCG

payment

is

x,

the

total

redistribution

payment

should

be

in

[ˆkx,

x]

(non-deficit

criterion).

Consider

the

case

where

all

agents

bid

so

that

the

total

VCG

payment

is

also

Hence,

the

total

redistribution

payment

should

be

in

[ˆk

is,

it

should

be

Hence

every

agent"s

redistribution

payment

must

be

Now,

let

ti

where

the

number

of

equals

i.

We

proved

If

consider

the

bid

vector

where

everyone

bids

The

total

VCG

payment

is

m

and

the

total

redistribution

payment

is

This

corresponds

to

redistribution,

which

is

contrary

to

our

assumption

that

ˆk

k∗

Now,

consider

j

min{i|ti

(which

is

well-defined

because

If

j

m,

the

property

is

satisfied.

If

j

m,

consider

the

bid

vector

where

ˆvi

for

i

j

and

ˆvi

for

all

other

i.

Under

this

bid

vector,

the

first

j

agents

each

get

redistribution

payment

and

the

remaining

n

j

agents

each

get

tj.

Thus,

the

total

redistribution

payment

is

(n

j)tj.

Because

the

total

VCG

payment

for

this

bid

vector

is

we

must

have

(n

j)tj

So

tj

(j

m

n).

But

this

is

contrary

to

the

definition

of

j.

Hence

if

the

number

of

is

less

than

or

equal

to

m.

Claim

f

satisfies

the

following

inequalities:

ˆkm

(n

m

m

ˆkm

(m

(n

m

i)tm+i

m

for

i

n

m

ˆkm

m

Here

ti

is

defined

as

in

the

proof

of

Claim

Proof

of

claim.

For

j

m

n,

consider

the

bid

vectors

where

ˆvi

for

i

j

and

ˆvi

for

all

other

i.

These

bid

vectors

together

with

the

non-deficit

constraint

and

worst-case

constraint

produce

the

above

set

of

inequalities:

for

example,

when

j

m

we

consider

the

bid

vector

ˆvi

for

i

m

and

ˆvi

for

all

other

i.

The

first

agents

each

receive

a

redistribution

payment

of

tm

and

all

other

agents

each

receive

Thus,

the

total

VCG

redistribution

is

(n

m

The

nondeficit

constraint

gives

(n

m

m

(because

the

total

VCG

payment

is

m).

The

worst-case

constraint

gives

(n

m

ˆkm.

Combining

these

two,

we

get

the

first

inequality.

The

other

inequalities

can

be

obtained

in

the

same

way.

We

now

observe

that

the

inequalities

in

Claim

together

with

ˆk

k∗

are

the

same

as

those

in

Claim

(where

the

ti

are

replaced

by

the

ˆxi).

Thus,

we

can

conclude

that

ˆk

k∗

which

is

contrary

to

our

assumption

ˆk

k∗

Hence

no

mechanism

satisfying

all

the

listed

properties

has

a

redistribution

percentage

greater

than

k∗

in

the

worst

case.

So

far

we

have

only

talked

about

the

case

where

n

For

the

purpose

of

completeness,

we

provide

the

following

claim

for

the

n

m

case.

Claim

For

any

m

and

n

with

n

m

the

original

VCG

mechanism

(that

is,

redistributing

nothing)

is

(uniquely)

worst-case

optimal

among

all

redistribution

mechanisms

that

are

deterministic,

anonymous,

strategy-proof,

efficient

and

satisfy

the

non-deficit

constraint.

We

recall

that

when

n

Claim

tells

us

that

the

only

mechanism

inside

the

family

of

linear

redistribution

mechanisms

is

the

original

VCG

mechanism,

so

that

this

mechanism

is

automatically

worst-case

optimal

inside

this

family.

However,

to

prove

the

above

claim,

we

need

to

show

that

it

is

worst-case

optimal

among

all

redistribution

mechanisms

that

have

the

desired

properties.

Proof.

Suppose

a

redistribution

mechanism

exists

that

satisfies

all

of

the

above

properties

and

has

a

worst-case

performance

as

good

as

the

original

VCG

mechanism,

that

is,

its

worst-case

redistribution

percentage

is

greater

than

or

equal

to

This

implies

that

the

total

redistribution

payment

of

this

mechanism

is

always

nonnegative.

By

Lemma

for

this

mechanism,

there

is

a

function

f

R

so

that

zi

ˆvn)

for

all

i

and

all

bid

vectors.

We

will

prove

that

for

all

First,

consider

the

bid

vector

where

ˆvi

for

all

i.

Here,

each

agent

receives

a

redistribution

payment

The

total

redistribution

payment

is

then

which

should

be

both

greater

than

or

equal

to

(by

the

above

observation)

as

well

less

than

or

equal

to

(using

the

nondeficit

criterion

and

the

fact

that

the

total

VCG

payment

is

It

follows

that

Now,

let

us

consider

the

bid

vector

where

and

ˆvi

for

all

other

i.

For

this

bid

vector,

the

agent

with

the

highest

bid

receives

a

redistribution

payment

of

and

the

other

n

agents

each

receive

By

the

same

reasoning

as

above,

the

total

redistribution

payment

should

be

both

greater

than

or

equal

to

and

less

than

or

equal

to

hence

for

all

Proceeding

by

induction,

let

us

assume

xk,

for

all

xk

for

some

k

n

Consider

the

bid

vector

where

ˆvi

xi

for

i

k

and

ˆvi

for

all

other

i,

where

the

xi

are

arbitrary

numbers

satisfying

xk

For

the

agents

with

the

highest

k

bids,

their

redistribution

payment

is

specified

by

f

acting

on

an

input

with

only

k

non-zero

variables.

Hence

they

all

receive

by

induction

assumption.

The

other

n

k

agents

each

receive

xk,

The

total

redistribution

payment

is

then

xk,

which

should

be

both

greater

than

or

equal

to

and

less

than

or

equal

to

the

total

VCG

payment.

Now,

in

this

bid

vector,

the

lowest

bid

is

because

k

n.

But

since

n

m

the

total

VCG

payment

is

mˆvn

So

we

have

xk,

for

all

xk

By

induction,

this

statement

holds

for

all

k

n

when

k

n

we

have

for

all

Hence,

in

this

mechanism,

the

redistribution

payment

is

always

that

is,

the

mechanism

is

just

the

original

VCG

mechanism.

Incidentally,

we

obtain

the

following

corollary:

Corollary

No

VCG

redistribution

mechanism

satisfies

all

of

the

following:

determinism,

anonymity,

strategyproofness,

efficiency,

and

(strong)

budget

balance.

This

holds

for

any

n

m

Proof.

For

the

case

n

m

If

such

a

mechanism

exists,

its

worst-case

performance

would

be

better

than

that

of

the

worst-case

optimal

linear

VCG

redistribution

mechanism,

which

by

Theorem

obtains

a

redistribution

percentage

strictly

less

than

But

Theorem

shows

that

it

is

impossible

to

outperform

this

mechanism

in

the

worst

case.

For

the

case

n

m

If

such

a

mechanism

exists,

it

would

perform

as

well

as

the

original

VCG

mechanism

in

the

worst

case,

which

implies

that

it

is

identical

to

the

VCG

mechanism

by

Claim

But

the

VCG

mechanism

is

not

(strongly)

budget

balanced.

CONCLUSIONS

For

allocation

problems

with

one

or

more

items,

the

wellknown

Vickrey-Clarke-Groves

(VCG)

mechanism

is

efficient,

strategy-proof,

individually

rational,

and

does

not

incur

a

deficit.

However,

the

VCG

mechanism

is

not

(strongly)

budget

balanced:

generally,

the

agents"

payments

will

sum

to

more

than

If

there

is

an

auctioneer

who

is

selling

the

items,

this

may

be

desirable,

because

the

surplus

payment

corresponds

to

revenue

for

the

auctioneer.

However,

if

the

items

do

not

have

an

owner

and

the

agents

are

merely

interested

in

allocating

the

items

efficiently

among

themselves,

any

surplus

payment

is

undesirable,

because

it

will

have

to

flow

out

of

the

system

of

agents.

In

Cavallo

proposed

a

mechanism

that

redistributes

some

of

the

VCG

payment

back

to

the

agents,

while

maintaining

efficiency,

strategy-proofness,

individual

rationality,

and

the

non-deficit

property.

In

this

paper,

we

extended

this

result

in

a

restricted

setting.

We

studied

allocation

settings

where

there

are

multiple

indistinguishable

units

of

a

single

good,

and

agents

have

unit

demand.

(For

this

specific

setting,

Cavallo"s

mechanism

coincides

with

a

mechanism

proposed

by

Bailey

in

Here

we

proposed

a

family

of

mechanisms

that

redistribute

some

of

the

VCG

payment

back

to

the

agents.

All

mechanisms

in

the

family

are

efficient,

strategy-proof,

individually

rational,

and

never

incur

a

deficit.

The

family

includes

the

Bailey-Cavallo

mechanism

as

a

special

case.

We

then

provided

an

optimization

model

for

finding

the

optimal

mechanism-that

is,

the

mechanism

that

maximizes

redistribution

in

the

worst

case-inside

the

family,

and

showed

how

to

cast

this

model

as

a

linear

program.

We

gave

both

numerical

and

analytical

solutions

of

this

linear

program,

and

the

(unique)

resulting

mechanism

shows

significant

improvement

over

the

Bailey-Cavallo

mechanism

(in

the

worst

case).

Finally,

we

proved

that

the

obtained

mechanism

is

optimal

among

all

anonymous

deterministic

mechanisms

that

satisfy

the

above

properties.

One

important

direction

for

future

research

is

to

try

to

extend

these

results

beyond

multi-unit

auctions

with

unit

demand.

However,

it

turns

out

that

in

sufficiently

general

settings,

the

worst-case

optimal

redistribution

percentage

is

In

such

settings,

the

worst-case

criterion

provides

no

guidance

in

determining

a

good

redistribution

mechanism

(even

redistributing

nothing

achieves

the

optimal

worst-case

percentage),

so

it

becomes

necessary

to

pursue

other

criteria.

Alternatively,

one

can

try

to

identify

other

special

settings

in

which

positive

redistribution

in

the

worst

case

is

possible.

Another

direction

for

future

research

is

to

consider

whether

this

mechanism

has

applications

to

collusion.

For

example,

in

a

typical

collusive

scheme,

there

is

a

bidding

ring

consisting

of

a

number

of

colluders,

who

submit

only

a

single

bid

If

this

bid

wins,

the

colluders

must

allocate

the

item

amongst

themselves,

perhaps

using

payments-but

of

course

they

do

not

want

payments

to

flow

out

of

the

ring.

This

work

is

part

of

a

growing

literature

on

designing

mechanisms

that

obtain

good

results

in

the

worst

case.

Traditionally,

economists

have

mostly

focused

either

on

designing

mechanisms

that

always

obtain

certain

properties

(such

as

the

VCG

mechanism),

or

on

designing

mechanisms

that

are

optimal

with

respect

to

some

prior

distribution

over

the

agents"

preferences

(such

as

the

Myerson

auction

and

the

Maskin-Riley

auction

for

maximizing

expected

revenue).

Some

more

recent

papers

have

focused

on

designing

mechanisms

for

profit

maximization

using

worst-case

competitive

analysis

(e.g.

There

has

also

been

growing

interest

in

the

design

of

online

mechanisms

where

the

agents

arrive

over

time

and

decisions

must

be

taken

before

all

the

agents

have

arrived.

Such

work

often

also

takes

a

worst-case

competitive

analysis

approach

It

does

not

appear

that

there

are

direct

connections

between

our

work

and

these

other

works

that

focus

on

designing

mechanisms

that

perform

well

in

the

worst

case.

Nevertheless,

it

seems

likely

that

future

research

will

continue

to

investigate

mechanism

design

for

the

worst

case,

and

hopefully

a

coherent

framework

will

emerge.

REFERENCES

G.

Aggarwal,

A.

Fiat,

A.

Goldberg,

J.

Hartline,

N.

Immorlica,

and

M.

Sudan.

Derandomization

of

auctions.

STOC,

M.

J.

Bailey.

The

demand

revealing

process:

to

distribute

the

surplus.

Public

Choice,

R.

Cavallo.

Optimal

decision-making

with

minimal

waste:

Strategyproof

redistribution

of

VCG

payments.

AAMAS,

E.

H.

Clarke.

Multipart

pricing

of

public

goods.

Public

Choice,

B.

Faltings.

A

budget-balanced,

incentive-compatible

scheme

for

social

choice.

AMEC,

J.

Feigenbaum,

C.

Papadimitriou,

and

S.

Shenker.

Sharing

the

cost

of

muliticast

transmissions.

JCSS,

E.

Friedman

and

D.

Parkes.

Pricing

WiFi

at

Starbucks

Issues

in

online

mechanism

design.

EC,

A.

Goldberg,

J.

Hartline,

A.

Karlin,

M.

Saks,

and

A.

Wright.

Competitive

auctions.

Games

and

Economic

Behavior,

A.

Goldberg,

J.

Hartline,

and

A.

Wright.

Competitive

auctions

and

digital

goods.

SODA,

D.

A.

Graham

and

R.

C.

Marshall.

Collusive

bidder

behavior

at

single-object

second-price

and

English

auctions.

Journal

of

Political

Economy,

J.

Green

and

J.-J.

Laffont.

Characterization

of

satisfactory

mechanisms

for

the

revelation

of

preferences

for

public

goods.

Econometrica,

T.

Groves.

Incentives

in

teams.

Econometrica,

M.

T.

Hajiaghayi,

R.

Kleinberg,

M.

Mahdian,

and

D.

C.

Parkes.

Online

auctions

with

re-usable

goods.

EC,

M.

T.

Hajiaghayi,

R.

Kleinberg,

and

D.

C.

Parkes.

Adaptive

limited-supply

online

auctions.

EC,

J.

Hartline

and

R.

McGrew.

From

optimal

limited

to

unlimited

supply

auctions.

EC,

L.

Hurwicz.

On

the

existence

of

allocation

systems

whose

manipulative

Nash

equilibria

are

Pareto

optimal,

Presented

at

the

World

Congress

of

the

Econometric

Society.

K.

Leyton-Brown,

Y.

Shoham,

and

M.

Tennenholtz.

Bidding

clubs

in

first-price

auctions.

AAAI,

E.

Maskin

and

J.

Riley.

Optimal

multi-unit

auctions.

In

F.

Hahn,

editor,

The

Economics

of

Missing

Markets,

Information,

and

Games,

chapter

Clarendon

Press,

Oxford,

H.

Moulin.

Efficient

and

strategy-proof

assignment

with

a

cheap

residual

claimant.

Working

paper,

March

R.

Myerson.

Optimal

auction

design.

Mathematics

of

Operations

Research,

R.

Myerson

and

M.

Satterthwaite.

Efficient

mechanisms

for

bilateral

trading.

Journal

of

Economic

Theory,

D.

Parkes,

J.

Kalagnanam,

and

M.

Eso.

Achieving

budget-balance

with

Vickrey-based

payment

schemes

in

exchanges.

IJCAI,

W.

Vickrey.

Counterspeculation,

auctions,

and

competitive

sealed

tenders.

Journal

of

Finance,

vickrey-clarke-grove
efficient mechanism
strategy-proofness
individually rational mechanism
linear vcg redistribution mechanism
worst-case optimal mechanism
vickrey-clarke-grove mechanism
payment redistribution

mechanism design
redistribution payment
mechanism
transformation to linear programming
analytical characterization