Towards

Truthful

Mechanisms

for

Binary

Demand

Games:

A

General

Framework

Ming-Yang

Kao

Dept.

of

Computer

Science

Northwestern

University

Evanston,

IL,

USA

kao@cs.northwestern.edu

Xiang-Yang

Li

Dept.

of

Computer

Science

Illinois

Institute

of

Technology

Chicago,

IL,

USA

xli@cs.iit.edu

WeiZhao

Wang

Dept.

of

Computer

Science

Illinois

Institute

of

Technology

Chicago,

IL,

USA

ABSTRACT

The

family

of

Vickrey-Clarke-Groves

(VCG)

mechanisms

is

arguably

the

most

celebrated

achievement

in

truthful

mechanism

design.

However,

VCG

mechanisms

have

their

limitations.

They

only

apply

to

optimization

problems

with

a

utilitarian

(or

affine)

objective

function,

and

their

output

should

optimize

the

objective

function.

For

many

optimization

problems,

finding

the

optimal

output

is

computationally

intractable.

If

we

apply

VCG

mechanisms

to

polynomial-time

algorithms

that

approximate

the

optimal

solution,

the

resulting

mechanisms

may

no

longer

be

truthful.

In

light

of

these

limitations,

it

is

useful

to

study

whether

we

can

design

a

truthful

non-VCG

payment

scheme

that

is

computationally

tractable

for

a

given

allocation

rule

O.

In

this

paper,

we

focus

our

attention

on

binary

demand

games

in

which

the

agents"

only

available

actions

are

to

take

part

in

the

a

game

or

not

to.

For

these

problems,

we

prove

that

a

truthful

mechanism

M

(O,

P)

exists

with

a

proper

payment

method

P

iff

the

allocation

rule

O

satisfies

a

certain

monotonicity

property.

We

provide

a

general

framework

to

design

such

P.

We

further

propose

several

general

composition-based

techniques

to

compute

P

efficiently

for

various

types

of

output.

In

particular,

we

show

how

P

can

be

computed

through

or/and

combinations,

round-based

combinations,

and

some

more

complex

combinations

of

the

outputs

from

subgames.

Categories

and

Subject

Descriptors

[Analysis

of

Algorithms

and

Problem

Complexity]:

General;

[Social

and

Behavioral

Sciences]:

Economics;

[Computer

and

Society]:

Electronic

Commerce

General

Terms

Algorithms,

Economics,

Theory

INTRODUCTION

In

recent

years,

with

the

rapid

development

of

the

Internet,

many

protocols

and

algorithms

have

been

proposed

to

make

the

Internet

more

efficient

and

reliable.

The

Internet

is

a

complex

distributed

system

where

a

multitude

of

heterogeneous

agents

cooperate

to

achieve

some

common

goals,

and

the

existing

protocols

and

algorithms

often

assume

that

all

agents

will

follow

the

prescribed

rules

without

deviation.

However,

in

some

settings

where

the

agents

are

selfish

instead

of

altruistic,

it

is

more

reasonable

to

assume

these

agents

are

rational

maximize

their

own

profits

according

to

the

neoclassic

economics,

and

new

models

are

needed

to

cope

with

the

selfish

behavior

of

such

agents.

Towards

this

end,

Nisan

and

Ronen

proposed

the

framework

of

algorithmic

mechanism

design

and

applied

VCG

mechanisms

to

some

fundamental

problems

in

computer

science,

including

shortest

paths,

minimum

spanning

trees,

and

scheduling

on

unrelated

machines.

The

VCG

mechanisms

are

applicable

to

mechanism

design

problems

whose

outputs

optimize

the

utilitarian

objective

function,

which

is

simply

the

sum

of

all

agents"

valuations.

Unfortunately,

some

objective

functions

are

not

utilitarian;

even

for

those

problems

with

a

utilitarian

objective

function,

sometimes

it

is

impossible

to

find

the

optimal

output

in

polynomial

time

unless

P=NP.

Some

mechanisms

other

than

VCG

mechanism

are

needed

to

address

these

issues.

Archer

and

Tardos

studied

a

scheduling

problem

where

it

is

NP-Hard

to

find

the

optimal

output.

They

pointed

out

that

a

certain

monotonicity

property

of

the

output

work

load

is

a

necessary

and

sufficient

condition

for

the

existence

of

a

truthful

mechanism

for

their

scheduling

problem.

Auletta

et

al.

studied

a

similar

scheduling

problem.

They

provided

a

family

of

deterministic

truthful

)-approximation

mechanisms

for

any

fixed

number

of

machines

and

several

)-truthful

mechanisms

for

some

NP-hard

restrictions

of

their

scheduling

problem.

Lehmann

et

al.

studied

the

single-minded

combinatorial

auction

and

gave

a√

m-approximation

truthful

mechanism,

where

m

is

the

number

of

goods.

They

also

pointed

out

that

a

certain

monotonicity

in

the

allocation

rule

can

lead

to

a

truthful

mechanism.

The

work

of

Mu"alem

and

Nisan

is

the

closest

in

spirit

to

our

work.

They

characterized

all

truthful

mechanisms

based

on

a

certain

monotonicity

property

in

a

single-minded

auction

setting.

They

also

showed

how

to

used

MAX

and

IF-THEN-ELSE

to

combine

outputs

from

subproblems.

As

shown

in

this

paper,

the

MAX

and

IF-THEN-ELSE

combinations

are

special

cases

of

the

composition-based

techniques

that

we

present

in

this

paper

for

computing

the

payments

in

polynomial

time

under

mild

assumptions.

More

generally,

we

study

how

to

design

truthful

mechanisms

for

binary

demand

games

where

the

allocation

of

an

agent

is

either

selected

or

not

selected.

We

also

assume

that

the

valuations

of

agents

are

uncorrelated,

i.e.,

the

valuation

of

an

agent

only

depends

on

its

own

allocation

and

type.

Recall

that

a

mechanism

M

(O,

P)

consists

of

two

parts,

an

allocation

rule

O

and

a

payment

scheme

P.

Previously,

it

is

often

assumed

that

there

is

an

objective

function

g

and

an

allocation

rule

O,

that

either

optimizes

g

exactly

or

approximately.

In

contrast

to

the

VCG

mechanisms,

we

do

not

require

that

the

allocation

should

optimize

the

objective

function.

In

fact,

we

do

not

even

require

the

existence

of

an

objective

function.

Given

any

allocation

rule

O

for

a

binary

demand

game,

we

showed

that

a

truthful

mechanism

M

(O,

P)

exists

for

the

game

if

and

only

if

O

satisfies

a

certain

monotonicity

property.

The

monotonicity

property

only

guarantees

the

existence

of

a

payment

scheme

P

such

that

(O,

P)

is

truthful.

We

complement

this

existence

theorem

with

a

general

framework

to

design

such

a

payment

scheme

P.

Furthermore,

we

present

general

techniques

to

compute

the

payment

when

the

output

is

a

composition

of

the

outputs

of

subgames

through

the

operators

or

and

and;

through

round-based

combinations;

or

through

intermediate

results,

which

may

be

themselves

computed

from

other

subproblems.

The

remainder

of

the

paper

is

organized

as

follows.

In

Section

we

discuss

preliminaries

and

previous

works,

define

binary

demand

games

and

discuss

the

basic

assumptions

about

binary

demand

games.

In

Section

we

show

that

O

satisfying

a

certain

monotonicity

property

is

a

necessary

and

sufficient

condition

for

the

existence

of

a

truthful

mechanism

M

(O,

P).

A

framework

is

then

proposed

in

Section

to

compute

the

payment

P

in

polynomial

time

for

several

types

of

allocation

rules

O.

In

Section

we

provide

several

examples

to

demonstrate

the

effectiveness

of

our

general

framework.

We

conclude

our

paper

in

Section

with

some

possible

future

directions.

PRELIMINARIES

Mechanism

Design

As

usually

done

in

the

literatures

about

the

designing

of

algorithms

or

protocols

with

inputs

from

individual

agents,

we

adopt

the

assumption

in

neoclassic

economics

that

all

agents

are

rational,

i.e.,

they

respond

to

well-defined

incentives

and

will

deviate

from

the

protocol

only

if

the

deviation

improves

their

gain.

A

standard

model

for

mechanism

design

is

as

follows.

There

are

n

agents

n

and

each

agent

i

has

some

private

information

ti,

called

its

type,

only

known

to

itself.

For

example,

the

type

ti

can

be

the

cost

that

agent

i

incurs

for

forwarding

a

packet

in

a

network

or

can

be

a

payment

that

the

agent

is

willing

to

pay

for

a

good

in

an

auction.

The

agents"

types

define

the

type

vector

t

tn).

Each

agent

i

has

a

set

of

strategies

Ai

from

which

it

can

choose.

For

each

input

vector

a

an)

where

agent

i

plays

strategy

ai

Ai,

the

mechanism

M

(O,

P)

computes

an

output

o

O(a)

and

a

payment

vector

p(a)

pn(a)).

Here

the

payment

pi(·)

is

the

money

given

to

agent

i

and

depends

on

the

strategies

used

by

the

agents.

A

game

is

defined

as

G

(S,

M),

where

S

is

the

setting

for

the

game

G.

Here,

S

consists

the

parameters

of

the

game

that

are

set

before

the

game

starts

and

do

not

depend

on

the

players"

strategies.

For

example,

in

a

unicast

routing

game

the

setting

consists

of

the

topology

of

the

network,

the

source

node

and

the

destination

node.

Throughout

this

paper,

unless

explicitly

mentioned

otherwise,

the

setting

S

of

the

game

is

fixed

and

we

are

only

interested

in

how

to

design

P

for

a

given

allocation

rule

O.

A

valuation

function

v(ti,

o)

assigns

a

monetary

amount

to

agent

i

for

each

possible

output

o.

Everything

about

a

game

S,

M

including

the

setting

S,

the

allocation

rule

O

and

the

payment

scheme

P,

is

public

knowledge

except

the

agent

i"s

actual

type

ti,

which

is

private

information

to

agent

i.

Let

ui(ti,

o)

denote

the

utility

of

agent

i

at

the

outcome

of

the

game

o,

given

its

preferences

ti.

Here,

following

a

common

assumption

in

the

literature,

we

assume

the

utility

for

agent

i

is

quasi-linear,

i.e.,

ui(ti,

o)

v(ti,

o)

Pi(a).

Let

a|i

ai

ai,

an),

i.e.,

each

agent

j

i

plays

an

action

aj

except

that

the

agent

i

plays

ai.

Let

a−i

an)

denote

the

actions

of

all

agents

except

i.

Sometimes,

we

write

(a−i,

bi)

as

a|i

bi.

An

action

ai

is

called

dominant

for

i

if

it

(weakly)

maximizes

the

utility

of

i

for

all

possible

strategies

b−i

of

other

agents,

i.e.,

ui(ti,

O(b−i,

ai))

ui(ti,

O(b−i,

ai))

for

all

ai

ai

and

b−i.

A

direct-revelation

mechanism

is

a

mechanism

in

which

the

only

actions

available

to

each

agent

are

to

report

its

private

type

either

truthfully

or

falsely

to

the

mechanism.

An

incentive

compatible

(IC)

mechanism

is

a

direct-revelation

mechanism

in

which

if

an

agent

reports

its

type

ti

truthfully,

then

it

will

maximize

its

utility.

Then,

in

a

direct-revelation

mechanism

satisfying

IC,

the

payment

scheme

should

satisfy

the

property

that,

for

each

agent

i,

v(ti,

O(t))

pi(t)

v(ti,

O(t|i

ti))

pi(t|i

ti).

Another

common

requirement

in

the

literature

for

mechanism

design

is

so

called

individual

rationality

or

voluntary

participation:

the

agent"s

utility

of

participating

in

the

output

of

the

mechanism

is

not

less

than

the

utility

of

the

agent

of

not

participating.

A

direct-revelation

mechanism

is

strategproof

if

it

satisfies

both

IC

and

IR

properties.

Arguably

the

most

important

positive

result

in

mechanism

design

is

the

generalized

Vickrey-Clarke-Groves

(VCG)

mechanism

by

Vickrey

Clarke

and

Groves

The

VCG

mechanism

applies

to

(affine)

maximization

problems

where

the

objective

function

is

utilitarian

g(o,

t)

P

i

v(ti,

o)

(i.e.,

the

sum

of

all

agents"

valuations)

and

the

set

of

possible

outputs

is

assumed

to

be

finite.

A

direct

revelation

mechanism

M

(O(t),

P(t))

belongs

to

the

VCG

family

if

the

allocation

O(t)

maximizesP

i

v(ti,

o),

and

the

payment

to

agent

i

is

pi(t)

P

j=i

vj(tj,

O(t))+

hi

(t−i),

where

hi

is

an

arbitrary

function

of

t−i.

Under

mild

assumptions,

VCG

mechanisms

are

the

only

truthful

implementations

for

utilitarian

problems

The

allocation

rule

of

a

VCG

mechanism

is

required

to

maximize

the

objective

function

in

the

range

of

the

allocation

function.

This

makes

the

mechanism

computationally

intractable

in

many

cases.

Furthermore,

replacing

an

optimal

algorithm

for

computing

the

output

with

an

approximation

algorithm

usually

leads

to

untruthful

mechanisms

if

a

VCG

payment

scheme

is

used.

In

this

paper,

we

study

how

to

design

a

truthful

mechanism

that

does

not

optimize

a

utilitarian

objective

function.

Binary

Demand

Games

A

binary

demand

game

is

a

game

G

(S,

M),

where

M

(O,

P)

and

the

range

of

O

is

In

other

words,

the

output

is

a

n-tuple

vector

O(t)

On(t)),

where

Oi(t)

(respectively,

means

that

agent

i

is

(respectively,

is

not)

selected.

Examples

of

binary

demand

games

include:

unicast

and

multicast

(generally

subgraph

construction

by

selecting

some

links/nodes

to

satisfy

some

property),

facility

location

and

a

certain

auction

Hereafter,

we

make

the

following

further

assumptions.

The

valuation

of

the

agents

are

not

correlated,

i.e.,

v(ti,

o)

is

a

function

of

v(ti,

oi)

only

is

denoted

as

v(ti,

oi).

The

valuation

v(ti,

oi)

is

a

publicly

known

value

and

is

normalized

to

This

assumption

is

needed

to

guarantee

the

IR

property.

Thus,

throughout

his

paper,

we

only

consider

these

direct-revelation

mechanisms

in

which

every

agent

only

needs

to

reveal

its

valuation

vi

v(ti,

Notice

that

in

applications

where

agents

providing

service

and

receiving

payment,

e.g.,

unicast

and

job

scheduling,

the

valuation

vi

of

an

agent

i

is

usually

negative.

For

the

convenience

of

presentation,

we

define

the

cost

of

agent

as

ci

−v(ti,

i.e.,

it

costs

agent

i

ci

to

provide

the

service.

Throughout

this

paper,

we

will

use

ci

instead

of

vi

in

our

analysis.

All

our

results

can

apply

to

the

case

where

the

agents

receive

the

service

rather

than

provide

by

setting

ci

to

negative,

as

in

auction.

In

a

binary

demand

game,

if

we

want

to

optimize

an

objective

function

g(o,

t),

then

we

call

it

a

binary

optimization

demand

game.

The

main

differences

between

the

binary

demand

games

and

those

problems

that

can

be

solved

by

VCG

mechanisms

are:

The

objective

function

is

utilitarian

(or

affine

maximization

problem)

for

a

problem

solvable

by

VCG

while

there

is

no

restriction

on

the

objective

function

for

a

binary

demand

game.

The

allocation

rule

O

studied

here

does

not

necessarily

optimize

an

objective

function,

while

a

VCG

mechanism

only

uses

the

output

that

optimizes

the

objective

function.

We

even

do

not

require

the

existence

of

an

objective

function.

We

assume

that

the

agents"

valuations

are

not

correlated

in

a

binary

demand

game,

while

the

agents"

valuations

may

be

correlated

in

a

VCG

mechanism.

In

this

paper,

we

assume

for

technical

convenience

that

the

objective

function

g(o,

c),

if

exists,

is

continuous

with

respect

to

the

cost

ci,

but

most

of

our

results

are

directly

applicable

to

the

discrete

case

without

any

modification.

Previous

Work

Lehmann

et

al.

studied

how

to

design

an

efficient

truthful

mechanism

for

single-minded

combinatorial

auction.

In

a

singleminded

combinatorial

auction,

each

agent

i

i

n)

only

wants

to

buy

a

subset

Si

S

with

private

price

ci.

A

single-minded

bidder

i

declares

a

bid

bi

Si,

ai

with

Si

S

and

ai

R+

In

it

is

assumed

that

the

set

of

goods

allocated

to

an

agent

i

is

either

Si

or

which

is

known

as

exactness.

Lehmann

et

al.

gave

a

greedy

round-based

allocation

algorithm,

based

on

the

rank

ai

that

has

an

approximation

ratio

m,

where

m

is

the

number

of

goods

in

S.

Based

on

the

approximation

algorithm,

they

gave

a

truthful

payment

scheme.

For

an

allocation

rule

satisfying

exactness:

the

set

of

goods

allocated

to

an

agent

i

is

either

Si

or

monotonicity:

proposing

more

money

for

fewer

goods

cannot

cause

a

bidder

to

lose

its

bid,

they

proposed

a

truthful

payment

scheme

as

follows:

charge

a

winning

bidder

a

certain

amount

that

does

not

depend

on

its

own

bidding;

charge

a

losing

bidder

Notice

the

assumption

of

exactness

reveals

that

the

single

minded

auction

is

indeed

a

binary

demand

game.

Their

payment

scheme

inspired

our

payment

scheme

for

binary

demand

game.

In

Archer

et

al.

studied

the

combinatorial

auctions

where

multiple

copies

of

many

different

items

are

on

sale,

and

each

bidder

i

desires

only

one

subset

Si.

They

devised

a

randomized

rounding

method

that

is

incentive

compatible

and

gave

a

truthful

mechanism

for

combinatorial

auctions

with

single

parameter

agents

that

approximately

maximizes

the

social

value

of

the

auction.

As

they

pointed

out,

their

method

is

strongly

truthful

in

sense

that

it

is

truthful

with

high

probability

where

is

an

error

probability.

On

the

contrary,

in

this

paper,

we

study

how

to

design

a

deterministic

mechanism

that

is

truthful

based

on

some

given

allocation

rules.

In

Archer

and

Tardos

showed

how

to

design

truthful

mechanisms

for

several

combinatorial

problems

where

each

agent"s

private

information

is

naturally

expressed

by

a

single

positive

real

number,

which

will

always

be

the

cost

incurred

per

unit

load.

The

mechanism"s

output

could

be

arbitrary

real

number

but

their

valuation

is

a

quasi-linear

function

t

w,

where

t

is

the

private

per

unit

cost

and

w

is

the

work

load.

Archer

and

Tardos

characterized

that

all

truthful

mechanism

should

have

decreasing

work

curves

w

and

that

the

truthful

payment

should

be

Pi(bi)

biwi(bi)

R

bi

wi(u)du

Using

this

model,

Archer

and

Tardos

designed

truthful

mechanisms

for

several

scheduling

related

problems,

including

minimizing

the

span,

maximizing

flow

and

minimizing

the

weighted

sum

of

completion

time

problems.

Notice

when

the

load

of

the

problems

is

w

it

is

indeed

a

binary

demand

game.

If

we

apply

their

characterization

of

the

truthful

mechanism,

their

decreasing

work

curves

w

implies

exactly

the

monotonicity

property

of

the

output.

But

notice

that

their

proof

is

heavily

based

on

the

assumption

that

the

output

is

a

continuous

function

of

the

cost,

thus

their

conclusion

can"t

directly

apply

to

binary

demand

games.

The

paper

of

Ahuva

Mu"alem

and

Noam

Nisan

is

closest

in

spirit

to

our

work.

They

clearly

stated

that

we

only

discussed

a

limited

class

of

bidders,

single

minded

bidders,

that

was

introduced

by

They

proved

that

all

truthful

mechanisms

should

have

a

monotonicity

output

and

their

payment

scheme

is

based

on

the

cut

value.

With

a

simple

generalization,

we

get

our

conclusion

for

general

binary

demand

game.

They

proposed

several

combination

methods

including

MAX,

IF-THEN-ELSE

construction

to

perform

partial

search.

All

of

their

methods

required

the

welfare

function

associated

with

the

output

satisfying

bitonic

property.

Distinction

between

our

contributions

and

previous

results:

It

has

been

shown

in

that

for

the

single

minded

combinatorial

auction,

there

exists

a

payment

scheme

which

results

in

a

truthful

mechanism

if

the

allocation

rule

satisfies

a

certain

monotonicity

property.

Theorem

also

depends

on

the

monotonicity

property,

but

it

is

applicable

to

a

broader

setting

than

the

single

minded

combinatorial

auction.

In

addition,

the

binary

demand

game

studied

here

is

different

from

the

traditional

packing

IP"s:

we

only

require

that

the

allocation

to

each

agent

is

binary

and

the

allocation

rule

satisfies

a

certain

monotonicity

property;

we

do

not

put

any

restrictions

on

the

objective

function.

Furthermore,

the

main

focus

of

this

paper

is

to

design

some

general

techniques

to

find

the

truthful

payment

scheme

for

a

given

allocation

rule

O

satisfying

a

certain

monotonicity

property.

GENERAL

APPROACHES

Properties

of

Strategyproof

Mechanisms

We

discuss

several

properties

that

mechanisms

need

to

satisfy

in

order

to

be

truthful.

THEOREM

If

a

mechanism

M

(O,

P)

satisfies

IC,

then

∀i,

if

Oi(t|i

Oi(t|i

then

pi(t|i

pi(t|i

COROLLARY

For

any

strategy-proof

mechanism

for

a

binary

demand

game

G

with

setting

S,

if

we

fix

the

cost

c−i

of

all

agents

other

than

i,

the

payment

to

agent

i

is

a

constant

i

if

Oi(c)

and

it

is

another

constant

i

if

Oi(c)

THEOREM

Fixed

the

setting

S

for

a

binary

demand

game,

if

mechanism

M

(O,

P)

satisfies

IC,

then

mechanism

M

(O,

P

with

the

same

output

method

O

and

pi(c)

pi(c)

δi(c−i)

for

any

function

δi(c−i)

also

satisfies

IC.

The

proofs

of

above

theorems

are

straightforward

and

thus

omitted

due

to

space

limit.

This

theorem

implies

that

for

the

binary

demand

games

we

can

always

normalize

the

payment

to

an

agent

i

such

that

the

payment

to

the

agent

is

when

it

is

not

selected.

Hereafter,

we

will

only

consider

normalized

payment

schemes.

Existence

of

Strategyproof

Mechanisms

Notice,

given

the

setting

S,

a

mechanism

design

problem

is

composed

of

two

parts:

the

allocation

rule

O

and

a

payment

scheme

P.

In

this

paper,

given

an

allocation

rule

O

we

focus

our

attention

on

how

to

design

a

truthful

payment

scheme

based

on

O.

Given

an

allocation

rule

O

for

a

binary

demand

game,

we

first

present

a

sufficient

and

necessary

condition

for

the

existence

of

a

truthful

payment

scheme

P.

DEFINITION

(MONOTONE

NON-INCREASING

PROPERTY

(MP)).

An

output

method

O

is

said

to

satisfy

the

monotone

non-increasing

property

if

for

every

agent

i

and

two

of

its

possible

costs

Oi(c|i

Oi(c|i

This

definition

is

not

restricted

only

to

binary

demand

games.

For

binary

demand

games,

this

definition

implies

that

if

Oi(c|i

then

Oi(c|i

THEOREM

Fix

the

setting

S,

c−i

in

a

binary

demand

game

G

with

the

allocation

rule

O,

the

following

three

conditions

are

equivalent:

There

exists

a

value

κi(O,

c−i)(which

we

will

call

a

cut

value,

such

that

Oi(c)

if

ci

κi(O,

c−i)

and

Oi(c)

if

ci

κi(O,

c−i).

When

ci

κi(O,

c−i),

Oi(c)

can

be

either

or

depending

on

the

tie-breaker

of

the

allocation

rule

O.

Hereafter,

we

will

not

consider

the

tie-breaker

scenario

in

our

proofs.

The

allocation

rule

O

satisfies

MP.

There

exists

a

truthful

payment

scheme

P

for

this

binary

demand

game.

PROOF.

The

proof

that

Condition

implies

Condition

is

straightforward

and

is

omitted

here.

We

then

show

Condition

implies

Condition

The

proof

of

this

is

similar

to

a

proof

in

To

prove

this

direction,

we

assume

there

exists

an

agent

i

and

two

valuation

vectors

c|i

and

c|i

where

Oi(c|i

and

Oi(c|i

From

corollary

we

know

that

pi(c|i

i

and

pi(c|i

i

Now

fix

c−i,

the

utility

for

i

when

ci

is

i

When

agent

i

lies

its

valuation

to

its

utility

is

i

Since

M

(O,

P)

is

truthful,

we

have

i

i

Now

consider

the

scenario

when

the

actual

valuation

of

agent

i

is

ci

Its

utility

is

i

when

it

reports

its

true

valuation.

Similarly,

if

it

lies

its

valuation

to

its

utility

is

i

Since

M

(O,

P)

is

truthful,

we

have

i

i

Consequently,

we

have

i

i

i

This

inequality

implies

that

which

is

a

contradiction.

We

then

show

Condition

implies

Condition

We

prove

this

by

constructing

a

payment

scheme

and

proving

that

this

payment

scheme

is

truthful.

The

payment

scheme

is:

If

Oi(c)

then

agent

i

gets

payment

pi(c)

κi(O,

c−i);

else

it

gets

payment

pi(c)

From

condition

if

Oi(c)

then

ci

κi(O,

c−i).

Thus,

its

utility

is

κi(O,

c−i)

ci

which

implies

that

the

payment

scheme

satisfies

the

IR.

In

the

following

we

prove

that

this

payment

scheme

also

satisfies

IC

property.

There

are

two

cases

here.

Case

ci

κ(O,

c−i).

In

this

case,

when

i

declares

its

true

cost

ci,

its

utility

is

κi(O,

c−i)

ci

Now

consider

the

situation

when

i

declares

a

cost

di

ci.

If

di

κi(O,

c−i),

then

i

gets

the

same

payment

and

utility

since

it

is

still

selected.

If

di

κi(O,

c−i),

then

its

utility

becomes

since

it

is

not

selected

anymore.

Thus,

it

has

no

incentive

to

lie

in

this

case.

Case

ci

κ(O,

c−i).

In

this

case,

when

i

reveals

its

true

valuation,

its

payment

is

and

the

utility

is

Now

consider

the

situation

when

i

declares

a

valuation

di

ci.

If

di

κi(O,

c−i),

then

i

gets

the

same

payment

and

utility

since

it

is

still

not

selected.

If

di

κi(O,

c−i),

then

its

utility

becomes

κi(O,

c−i)

ci

since

it

is

selected

now.

Thus,

it

has

no

incentive

to

lie.

The

equivalence

of

the

monotonicity

property

of

the

allocation

rule

O

and

the

existence

of

a

truthful

mechanism

using

O

can

be

extended

to

games

beyond

binary

demand

games.

The

details

are

omitted

here

due

to

space

limit.

We

now

summarize

the

process

to

design

a

truthful

payment

scheme

for

a

binary

demand

game

based

on

an

output

method

O.

General

Framework

Truthful

mechanism

design

for

a

binary

demand

game

Stage

Check

whether

the

allocation

rule

O

satisfies

MP.

If

it

does

not,

then

there

is

no

payment

scheme

P

such

that

mechanism

M

(O,

P)

is

truthful.

Otherwise,

define

the

payment

scheme

P

as

follows.

Stage

Based

on

the

allocation

rule

O,

find

the

cut

value

κi(O,

c−i)

for

agent

i

such

that

Oi(c|i

di)

when

di

κi(O,

c−i),

and

Oi(c|i

di)

when

di

κi(O,

c−i).

Stage

The

payment

for

agent

i

is

if

Oi(c)

the

payment

is

κi(O,

c−i)

if

Oi(c)

THEOREM

The

payment

defined

by

our

general

framework

is

minimum

among

all

truthful

payment

schemes

using

O

as

output.

COMPUTING

CUT

VALUE

FUNCTIONS

To

find

the

truthful

payment

scheme

by

using

General

Framework

the

most

difficult

stage

seems

to

be

the

stage

Notice

that

binary

search

does

not

work

generally

since

the

valuations

of

agents

may

be

continuous.

We

give

some

general

techniques

that

can

help

with

finding

the

cut

value

function

under

certain

circumstances.

Our

basic

approach

is

as

follows.

First,

we

decompose

the

allocation

rule

into

several

allocation

rules.

Next

find

the

cut

value

function

for

each

of

these

new

allocation

rules.

Then,

we

compute

the

original

cut

value

function

by

combining

these

cut

value

functions

of

the

new

allocation

rules.

Simple

Combinations

In

this

subsection,

we

introduce

techniques

to

compute

the

cut

value

function

by

combining

multiple

allocation

rules

with

conjunctions

or

disconjunctions.

For

simplicity,

given

an

allocation

rule

O,

we

will

use

κ(O,

c)

to

denote

a

n-tuple

vector

κn(O,

c−n)).

Here,

κi(O,

c−i)

is

the

cut

value

for

agent

i

when

the

allocation

rule

is

O

and

the

costs

c−i

of

all

other

agents

are

fixed.

THEOREM

With

a

fixed

setting

S

of

a

binary

demand

game,

assume

that

there

are

m

allocation

rules

Om

satisfying

the

monotonicity

property,

and

κ(Oi

c)

is

the

cut

value

vector

for

Oi

Then

the

allocation

rule

O(c)

Wm

Oi

(c)

satisfies

the

monotonicity

property.

Moreover,

the

cut

value

for

O

is

κ(O,

c)

maxm

c)}

Here

κ(O,

c)

maxm

c)}

means,

∀j

n],

κj(O,

c−j)

maxm

c−j)}

and

O(c)

=Wm

Oi

(c)

means,

∀j

n],

Oj(c)

j

(c)

j

(c)

Om

j

(c).

PROOF.

Assume

that

ci

ci

and

Oi(c)

Without

loss

of

generality,

we

assume

that

Ok

i

(c)

for

some

k,

k

m.

From

the

assumption

that

Ok

i

(c)

satisfies

MP,

we

obtain

that

Ok

i

(c|i

ci)

Thus,

Oi(c|i

ci)

Wm

Oj

(c)

This

proves

that

O(c)

satisfies

MP.

The

correctness

of

the

cut

value

function

follows

directly

from

Theorem

Many

algorithms

indeed

fall

into

this

category.

To

demonstrate

the

usefulness

of

Theorem

we

discuss

a

concrete

example

here.

In

a

network,

sometimes

we

want

to

deliver

a

packet

to

a

set

of

nodes

instead

of

one.

This

problem

is

known

as

multicast.

The

most

commonly

used

structure

in

multicast

routing

is

so

called

shortest

path

tree

(SPT).

Consider

a

network

G

(V,

E,

c),

where

V

is

the

set

of

nodes,

and

vector

c

is

the

actual

cost

of

the

nodes

forwarding

the

data.

Assume

that

the

source

node

is

s

and

the

receivers

are

Q

V

For

each

receiver

qi

Q,

we

compute

the

shortest

path

(least

cost

path),

denoted

by

LCP(s,

qi,

d),

from

the

source

s

to

qi

under

the

reported

cost

profile

d.

The

union

of

all

such

shortest

paths

forms

the

shortest

path

tree.

We

then

use

General

Framework

to

design

the

truthful

payment

scheme

P

when

the

SPT

structure

is

used

as

the

output

for

multicast,

i.e.,

we

design

a

mechanism

M

(SPT,

P).

Notice

that

VCG

mechanisms

cannot

be

applied

here

since

SPT

is

not

an

affine

maximization.

We

define

LCP(s,qi)

as

the

allocation

corresponds

to

the

path

LCP(s,

qi,

d),

i.e.,

LCP

(s,qi)

k

(d)

if

and

only

if

node

vk

is

in

LCP(s,

qi,

d).

Then

the

output

SPT

is

defined

as

W

qi∈Q

LCP(s,qi)

In

other

words,

SPTk(d)

if

and

only

if

qk

is

selected

in

some

LCP(s,

qi,

d).

The

shortest

path

allocation

rule

is

a

utilitarian

and

satisfies

MP.

Thus,

from

Theorem

SPT

also

satisfies

MP,

and

the

cut

value

function

vector

for

SPT

can

be

calculated

as

κ(SPT,

c)

maxqi∈Q

κ(LCP(s,qi)

c),

where

κ(LCP(s,qi)

c)

is

the

cut

value

function

vector

for

the

shortest

path

LCP(s,

qi,

c).

Consequently,

the

payment

scheme

above

is

truthful

and

the

minimum

among

all

truthful

payment

schemes

when

the

allocation

rule

is

SPT.

THEOREM

Fixed

the

setting

S

of

a

binary

demand

game,

assume

that

there

are

m

output

methods

Om

satisfying

MP,

and

κ(Oi

c)

are

the

cut

value

functions

respectively

for

Oi

where

i

m.

Then

the

allocation

rule

O(c)

=Vm

Oi

(c)

satisfies

MP.

Moreover,

the

cut

value

function

for

O

is

κ(O,

c)

minm

c)}.

We

show

that

our

simple

combination

generalizes

the

IF-THENELSE

function

defined

in

For

an

agent

i,

assume

that

there

are

two

allocation

rules

and

satisfying

MP.

Let

c−i),

c−i)

be

the

cut

value

functions

for

respectively.

Then

the

IF-THEN-ELSE

function

Oi(c)

is

actually

Oi(c)

[(ci

c−i)

(c−i,

ci)]

(ci

c−i)

where

and

are

two

positive

functions.

By

applying

Theorems

and

we

know

that

the

allocation

rule

O

satisfies

MP

and

consequently

κi(O,

c−i)

c−i)+

c−i)),

c−i)

Round-Based

Allocations

Some

approximation

algorithms

are

round-based,

where

each

round

of

an

algorithm

selects

some

agents

and

updates

the

setting

and

the

cost

profile

if

necessary.

For

example,

several

approximation

algorithms

for

minimum

weight

vertex

cover

maximum

weight

independent

set,

minimum

weight

set

cover

and

minimum

weight

Steiner

tree

fall

into

this

category.

As

an

example,

we

discuss

the

minimum

weighted

vertex

cover

problem

(MWVC)

to

show

how

to

compute

the

cut

value

for

a

round-based

output.

Given

a

graph

G

(V,

E),

where

the

nodes

vn

are

the

agents

and

each

agent

vi

has

a

weight

ci,

we

want

to

find

a

node

set

V

V

such

that

for

every

edge

(u,

v)

E

at

least

one

of

u

and

v

is

in

V

Such

V

is

called

a

vertex

cover

of

G.

The

valuation

of

a

node

i

is

−ci

if

it

is

selected;

otherwise

its

valuation

is

For

a

subset

of

nodes

V

V

we

define

its

weight

as

c(V

P

i∈V

ci.

We

want

to

find

a

vertex

cover

with

the

minimum

weight.

Hence,

the

objective

function

to

be

implemented

is

utilitarian.

To

use

the

VCG

mechanism,

we

need

to

find

the

vertex

cover

with

the

minimum

weight,

which

is

NP-hard

Since

we

are

interested

in

mechanisms

that

can

be

computed

in

polynomial

time,

we

must

use

polynomial-time

computable

allocation

rules.

Many

algorithms

have

been

proposed

in

the

literature

to

approximate

the

optimal

solution.

In

this

paper,

we

use

a

algorithm

given

in

For

the

sake

of

completeness,

we

briefly

review

this

algorithm

here.

The

algorithm

is

round-based.

Each

round

selects

some

vertices

and

discards

some

vertices.

For

each

node

i,

w(i)

is

initialized

to

its

weight

ci,

and

when

w(i)

drops

to

i

is

included

in

the

vertex

cover.

To

make

the

presentation

clear,

we

say

an

edge

is

lexicographically

smaller

than

edge

if

or

and

Algorithm

Approximate

Minimum

Weighted

Vertex

Cover

Input:

A

node

weighted

graph

G

(V,

E,

c).

Output:

A

vertex

cover

V

Set

V

For

each

i

V

set

w(i)

ci.

while

V

is

not

a

vertex

cover

do

Pick

an

uncovered

edge

(i,

j)

with

the

least

lexicographic

order

among

all

uncovered

edges.

Let

m

min(w(i),

w(j)).

Update

w(i)

to

w(i)

m

and

w(j)

to

w(j)

m.

If

w(i)

add

i

to

V

If

w(j)

add

j

to

V

Notice,

selecting

an

edge

using

the

lexicographic

order

is

crutial

to

guarantee

the

monotonicity

property.

Algorithm

outputs

a

vertex

cover

V

whose

weight

is

within

times

of

the

optimum.

For

convenience,

we

use

VC(c)

to

denote

the

vertex

cover

computed

by

Algorithm

when

the

cost

vector

of

vertices

is

c.

Below

we

generalize

Algorithm

to

a

more

general

scenario.

Typically,

a

round-based

output

can

be

characterized

as

follows

(Algorithm

DEFINITION

An

updating

rule

Ur

is

said

to

be

crossingindependent

if,

for

any

agent

i

not

selected

in

round

r,

and

−i

do

not

depend

on

cr

j

for

fixed

cr

−i,

cr

cr

implies

that

We

have

the

following

theorem

about

the

existence

of

a

truthful

payment

using

a

round

based

allocation

rule

A.

THEOREM

A

round-based

output

A,

with

the

framework

defined

in

Algorithm

satisfies

MP

if

the

output

methods

Or

satisfy

MP

and

all

updating

rules

Ur

are

crossing-independent.

PROOF.

Consider

an

agent

i

and

fixed

c−i.

We

prove

that

when

an

agent

i

is

selected

with

cost

ci,

then

it

is

also

selected

with

cost

di

ci.

Assume

that

i

is

selected

in

round

r

with

cost

ci.

Then

under

cost

di,

if

agent

i

is

selected

in

a

round

before

r,

our

claim

holds.

Otherwise,

consider

in

round

r.

Clearly,

the

setting

Sr

and

the

costs

of

all

other

agents

are

the

same

as

what

if

agent

i

had

cost

ci

since

i

is

not

selected

in

the

previous

rounds

due

to

the

crossindependent

property.

Since

i

is

selected

in

round

r

with

cost

ci,

i

is

also

selected

in

round

r

with

di

ci

due

to

the

reason

that

Or

satisfies

MP.

This

finishes

the

proof.

Algorithm

A

General

Round-Based

Allocation

Rule

A

Set

r

c,

and

G

initially.

repeat

Compute

an

output

or

using

a

deterministic

algorithm

Or

Sr

cr

Here

Or

cr

and

Sr

are

allocation

rule,

cost

vector

and

game

setting

in

game

Gr

respectively.

Remark:

Or

is

often

a

simple

greedy

algorithm

such

as

selecting

the

agents

that

minimize

some

utilitarian

function.

For

the

example

of

vertex

cover,

Or

will

always

select

the

light-weighted

node

on

the

lexicographically

least

uncovered

edge

(i,

j).

Let

r

r

Update

the

game

to

obtain

a

new

game

Gr

with

setting

Sr

and

cost

vector

cr

according

to

some

rule

Ur

(Sr

cr

Here

we

updates

the

cost

and

setting

of

the

game.

Remark:

For

the

example

of

vertex

cover,

the

updating

rule

will

decrease

the

weight

of

vertices

i

and

j

by

min(w(i),

w(j)).

until

a

valid

output

is

found

Return

the

union

of

the

set

of

selected

players

of

each

round

as

the

final

output.

For

the

example

of

vertex

cover,

it

is

the

union

of

nodes

selected

in

all

rounds.

Algorithm

Compute

Cut

Value

for

Round-Based

Algorithms

Input:

A

round-based

output

A,

a

game

G,

and

a

updating

function

vector

U.

Output:

The

cut

value

x

for

agent

k.

Set

r

and

ck

ζ.

Recall

that

ζ

is

a

value

that

can

guarantee

Ak

when

an

agent

reports

the

cost

ζ.

repeat

Compute

an

output

or

using

a

deterministic

algorithm

based

on

setting

Sr

using

allocation

rule

Or

Sr

×cr

Find

the

cut

value

for

agent

k

based

on

the

allocation

rule

Or

for

costs

cr

−k.

Let

r

κk(Or

cr

−k)

be

the

cut

value.

Set

r

r

and

obtain

a

new

game

Gr

from

and

or

according

to

the

updating

rule

Ur

Let

cr

be

the

new

cost

vector

for

game

Gr

until

a

valid

output

is

found.

Let

gi(x)

be

the

cost

of

ci

k

when

the

original

cost

vector

is

c|k

x.

Find

the

minimum

value

x

such

that

gt(x)

t.

Here,

t

is

the

total

number

of

rounds.

Output

the

value

x

as

the

cut

value.

If

the

round-based

output

satisfies

monotonicity

property,

the

cut-value

always

exists.

We

then

show

how

to

find

the

cut

value

for

a

selected

agent

k

in

Algorithm

The

correctness

of

Algorithm

is

straightforward.

To

compute

the

cut

value,

we

assume

that

the

cut

value

r

for

each

round

r

can

be

computed

in

polynomial

time;

we

can

solve

the

equation

gr(x)

r

to

find

x

in

polynomial

time

when

the

cost

vector

c−i

and

b

are

given.

Now

we

consider

the

vertex

cover

problem.

For

each

round

r,

we

select

a

vertex

with

the

least

weight

and

that

is

incident

on

the

lexicographically

least

uncovered

edge.

The

output

satisfies

MP.

For

agent

i,

we

update

its

cost

to

cr

i

cr

j

iff

edge

(i,

j)

is

selected.

It

is

easy

to

verify

this

updating

rule

is

crossing-independent,

thus

we

can

apply

Algorithm

to

compute

the

cut

value

for

the

set

cover

game

as

shown

in

Algorithm

Algorithm

Compute

Cut

Value

for

MVC.

Input:

A

node

weighted

graph

G

(V,

E,

c)

and

a

node

k

selected

by

Algorithm

Output:

The

cut

value

κk(V

C,

c−k).

For

each

i

V

set

w(i)

ci.

Set

w(k)

pk

and

V

while

V

is

not

a

vertex

cover

do

Pick

an

uncovered

edge

(i,

j)

with

the

least

lexicographic

order

among

all

uncovered

edges.

Set

m

min(w(i),

w(j)).

Update

w(i)

w(i)

m

and

w(j)

w(j)

m.

If

w(i)

add

i

to

V

else

add

j

to

V

If

i

k

or

j

k

then

set

pk

pk

m.

Output

pk

as

the

cut

value

κk(V

C,

c−k).

Complex

Combinations

In

subsection

we

discussed

how

to

find

the

cut

value

function

when

the

output

of

the

binary

demand

game

is

a

simple

combination

of

some

outputs,

whose

cut

values

can

be

computed

through

other

means

(typically

VCG).

However,

some

algorithms

cannot

be

decomposed

in

the

way

described

in

subsection

Next

we

present

a

more

complex

way

to

combine

allocation

rules,

and

as

we

may

expected,

the

way

to

find

the

cut

value

is

also

more

complicated.

Assume

that

there

are

n

agents

i

n

with

cost

vector

c,

and

there

are

m

binary

demand

games

Gi

with

objective

functions

fi(o,

c),

setting

Si

and

allocation

rule

ψi

where

i

m.

There

is

another

binary

demand

game

with

setting

S

and

allocation

rule

O,

whose

input

is

a

cost

vector

d

dm).

Let

f

be

the

function

vector

fm),

ψ

be

the

allocation

rule

vector

ψ2

ψm

and

be

the

setting

vector

Sm).

For

notation

simplicity,

we

define

Fi(c)

fi(ψi

(c),

c),

for

each

i

m,

and

F(c)

Fm(c)).

Let

us

see

a

concrete

example

of

these

combinations.

Consider

a

link

weighted

graph

G

(V,

E,

c),

and

a

subset

of

q

nodes

Q

V

The

Steiner

tree

problem

is

to

find

a

set

of

links

with

minimum

total

cost

to

connect

Q.

One

way

to

find

an

approximation

of

the

Steiner

tree

is

as

follows:

we

build

a

virtual

complete

graph

H

using

Q

as

its

vertices,

and

the

cost

of

each

edge

(i,

j)

is

the

cost

of

LCP(i,

j,

c)

in

graph

G;

build

the

minimum

spanning

tree

of

H,

denoted

as

MST(H);

an

edge

of

G

is

selected

iff

it

is

selected

in

some

LCP(i,

j,

c)

and

edge

(i,

j)

of

H

is

selected

to

MST(H).

In

this

game,

we

define

q(q

games

Gi,j,

where

i,

j

Q,

with

objective

functions

fi,j(o,

c)

being

the

minimum

cost

of

connecting

i

and

j

in

graph

G,

setting

Si

being

the

original

graph

G

and

allocation

rule

is

LCP(i,

j,

c).

The

game

G

corresponds

to

the

MST

game

on

graph

H.

The

cost

of

the

pair-wise

q(q

shortest

paths

defines

the

input

vector

d

dm)

for

game

MST.

More

details

will

be

given

in

Section

DEFINITION

Given

an

allocation

rule

O

and

setting

S,

an

objective

function

vector

f,

an

allocation

rule

vector

ψ

and

setting

vector

we

define

a

compound

binary

demand

game

with

setting

S

and

output

O

F

as

(O

F)i(c)

Wm

ψj

i

(c)).

The

allocation

rule

of

the

above

definition

can

be

interpreted

as

follows.

An

agent

i

is

selected

if

and

only

if

there

is

a

j

such

that

i

is

selected

in

ψj

(c),

and

the

allocation

rule

O

will

select

index

j

under

cost

profile

F(c).

For

simplicity,

we

will

use

O

F

to

denote

the

output

of

this

compound

binary

demand

game.

Notice

that

a

truthful

payment

scheme

using

O

F

as

output

exists

if

and

only

if

it

satisfies

the

monotonicity

property.

To

study

when

O

◦F

satisfies

MP,

several

necessary

definitions

are

in

order.

DEFINITION

Function

Monotonicity

Property

(FMP)

Given

an

objective

function

g

and

an

allocation

rule

O,

a

function

H(c)

g(O(c),

c)

is

said

to

satisfy

the

function

monotonicity

property,

if,

given

fixed

c−i,

it

satisfies:

When

Oi(c)

H(c)

does

not

increase

over

ci.

When

Oi(c)

H(c)

does

not

decrease

over

ci.

DEFINITION

Strong

Monotonicity

Property

(SMP)

An

allocation

rule

O

is

said

to

satisfy

the

strong

monotonicity

property

if

O

satisfies

MP,

and

for

any

agent

i

with

Oi(c)

and

agent

j

i,

Oi(c|j

cj)

if

cj

cj

or

Oj(c|j

cj)

LEMMA

For

a

given

allocation

rule

O

satisfying

SMP

and

cost

vectors

c,

c

with

ci

ci,

if

Oi(c)

and

Oi(c

then

there

must

exist

j

i

such

that

cj

cj

and

Oj(c

From

the

definition

of

the

strong

monotonicity

property,

we

have

Lemma

directly.

We

now

can

give

a

sufficient

condition

when

O

F

satisfies

the

monotonicity

property.

THEOREM

If

∀i

m],

Fi

satisfies

FMP,

ψi

satisfies

MP,

and

the

output

O

satisfies

SMP,

then

O

F

satisfies

MP.

PROOF.

Assuming

for

cost

vector

c

we

have

(O

F)i(c)

we

should

prove

for

any

cost

vector

c

c|i

ci

with

ci

ci,

(O

F)i(c

Noticing

that

(O

F)i(c)

without

loss

of

generality,

we

assume

that

Ok(F(c))

and

ψk

i

(c)

for

some

index

k

m.

Now

consider

the

output

O

with

the

cost

vector

F(c

)|k

Fk(c).

There

are

two

scenarios,

which

will

be

studied

one

by

one

as

follows.

One

scenario

is

that

index

k

is

not

chosen

by

the

output

function

O.

From

Lemma

there

must

exist

j

k

such

that

Fj(c

Fj(c)

Oj(F(c

)|k

Fk(c))

We

then

prove

that

agent

i

will

be

selected

in

the

output

ψj

(c

i.e.,

ψj

i

(c

If

it

is

not,

since

ψj

(c)

satisfies

MP,

we

have

ψj

i

(c)

ψj

i

(c

from

ci

ci.

Since

Fj

satisfies

FMP,

we

know

Fj(c

Fj(c),

which

is

a

contradiction

to

the

inequality

Consequently,

we

have

ψj

i

(c

From

Equation

the

fact

that

index

k

is

not

selected

by

allocation

rule

O

and

the

definition

of

SMP,

we

have

Oj(F(c

Thus,

agent

i

is

selected

by

O

F

because

of

Oj(F(c

and

ψj

i

(c

The

other

scenario

is

that

index

k

is

chosen

by

the

output

function

O.

First,

agent

i

is

chosen

in

ψk

(c

since

the

output

ψk

(c)

satisfies

the

monotonicity

property

and

ci

ci

and

ψk

i

(c)

Secondly,

since

the

function

Fk

satisfies

FMP,

we

know

that

Fk(c

Fk(c).

Remember

that

output

O

satisfies

the

SMP,

thus

we

can

obtain

Ok(F(c

from

the

fact

that

Ok(F(c

)|k

Fk(c))

and

Fk(c

Fk(c).

Consequently,

agent

i

will

also

be

selected

in

the

final

output

O

F.

This

finishes

our

proof.

This

theorem

implies

that

there

is

a

cut

value

for

the

compound

output

O

F.

We

then

discuss

how

to

find

the

cut

value

for

this

output.

Below

we

will

give

an

algorithm

to

calculate

κi(O

F)

when

O

satisfies

SMP,

ψj

satisfies

MP,

and

for

fixed

c−i,

Fj(c)

is

a

constant,

say

hj,

when

ψj

i

(c)

and

Fj(c)

increases

when

ψj

i

(c)

Notice

that

here

hj

can

be

easily

computed

by

setting

ci

since

ψj

satisfies

the

monotonicity

property.

When

given

i

and

fixed

c−i,

we

define

(Fi

j

(y)

as

the

smallest

x

such

that

Fj(c|i

x)

y.

For

simplicity,

we

denote

(Fi

j

as

j

if

no

confusion

is

caused

when

i

is

a

fixed

agent.

In

this

paper,

we

assume

that

given

any

y,

we

can

find

such

x

in

polynomial

time.

Algorithm

Find

Cut

Value

for

Compound

Method

O

F

Input:

allocation

rule

O,

objective

function

vector

F

and

inverse

function

vector

m

allocation

rule

vector

ψ

and

fixed

c−i.

Output:

Cut

value

for

agent

i

based

on

O

F.

for

j

m

do

Compute

the

outputs

ψj

(ci).

Compute

hj

Fj(c|i

Use

h

hm)

as

the

input

for

the

output

function

O.

Denote

τj

κj(O,

h−j)

as

the

cut

value

function

of

output

O

based

on

input

h.

for

j

m

do

Set

κi,j

j

(min{τj,

hj}).

The

cut

value

for

i

is

κi(O

F,

c−i)

maxm

κi,j.

THEOREM

Algorithm

computes

the

correct

cut

value

for

agent

i

based

on

the

allocation

rule

O

F.

PROOF.

In

order

to

prove

the

correctness

of

the

cut

value

function

calculated

by

Algorithm

we

prove

the

following

two

cases.

For

our

convenience,

we

will

use

κi

to

represent

κi(O

F,

c−i)

if

no

confusion

caused.

First,

if

di

κi

then

(O

F)i(c|i

di)

Without

loss

of

generality,

we

assume

that

κi

κi,j

for

some

j.

Since

function

Fj

satisfies

FMP

and

ψj

i

(c|i

di)

we

have

Fj(c|i

di)

Fj(κi).

Notice

di

κi,j,

from

the

definition

of

κi,j

j

(min{τj,

hj})

we

have

ψj

i

(c|i

di)

Fj(c|i

di)

τj

due

to

the

fact

that

Fj(x)

is

a

non-decreasing

function

when

j

is

selected.

Thus,

from

the

monotonicity

property

of

O

and

τj

is

the

cut

value

for

output

O,

we

have

Oj(h|j

Fj(c|i

di))

If

Oj(F(c|i

di))

then

(O◦F)i(c|i

di)

Otherwise,

since

O

satisfies

SMP,

Lemma

and

equation

imply

that

there

exists

at

least

one

index

k

such

that

Ok(F(c|i

di))

and

Fk(c|i

di)

hk.

Note

Fk(c|i

di)

hk

implies

that

i

is

selected

in

ψk

(c|i

di)

since

hk

Fk(ci|i

In

other

words,

agent

i

is

selected

in

O◦F.

Second,

if

di

κi(O

F,

c−i)

then

(O

F)i(c|i

di)

Assume

for

the

sake

of

contradiction

that

(O

F)i(c|i

di)

Then

there

exists

an

index

j

m

such

that

Oj(F(c|i

di))

and

ψj

i

(c|i

di)

Remember

that

hk

Fk(c|i

di)

for

any

k.

Thus,

from

the

fact

that

O

satisfies

SMP,

when

changing

the

cost

vector

from

F(c|i

di)

to

h|j

Fj(c|i

di),

we

still

have

Oj(h|j

Fj(c|i

di))

This

implies

that

Fj(c|i

di)

τj.

Combining

the

above

inequality

and

the

fact

that

Fj(c|i

c|i

di)

hj,

we

have

Fj(c|i

di)

min{hj,

τj}.

This

implies

di

j

(min{hj,

τj})

κi,j

κi(O

F,

c−i).

which

is

a

contradiction.

This

finishes

our

proof.

In

most

applications,

the

allocation

rule

ψj

implements

the

objective

function

fj

and

fj

is

utilitarian.

Thus,

we

can

compute

the

inverse

of

j

efficiently.

Another

issue

is

that

it

seems

the

conditions

when

we

can

apply

Algorithm

are

restrictive.

However,

lots

of

games

in

practice

satisfy

these

properties

and

here

we

show

how

to

deduct

the

MAX

combination

in

Assume

and

are

two

allocation

rules

for

single

minded

combinatorial

auction,

then

the

combination

returns

the

allocation

with

the

larger

welfare.

If

algorithm

and

satisfy

MP

and

FMP,

the

operation

max(x,

y)

which

returns

the

larger

element

of

x

and

y

satisfies

SMP.

From

Theorem

we

obtain

that

combination

also

satisfies

MP.

Further,

the

cut

value

of

the

MAX

combination

can

be

found

by

Algorithm

As

we

will

show

in

Section

the

complex

combination

can

apply

to

some

more

complicated

problems.

CONCRETE

EXAMPLES

Set

Cover

In

the

set

cover

problem,

there

is

a

set

U

of

m

elements

needed

to

be

covered,

and

each

agent

i

n

can

cover

a

subset

of

elements

Si

with

a

cost

ci.

Let

S

Sn}

and

c

cn).

We

want

to

find

a

subset

of

agents

D

such

that

U

S

i∈D

Si.

The

selected

subsets

is

called

the

set

cover

for

U.

The

social

efficiency

of

the

output

D

is

defined

as

P

i∈D

ci,

which

is

the

objective

function

to

be

minimized.

Clearly,

this

is

a

utilitarian

and

thus

VCG

mechanism

can

be

applied

if

we

can

find

the

subset

of

S

that

covers

U

with

the

minimum

cost.

It

is

well-known

that

finding

the

optimal

solution

is

NP-hard.

In

an

algorithm

of

approximation

ratio

of

Hm

has

been

proposed

and

it

has

been

proved

that

this

is

the

best

ratio

possible

for

the

set

cover

problem.

For

the

completeness

of

presentation,

we

review

their

method

here.

Algorithm

Greedy

Set

Cover

(GSC)

Input:

Agent

i"s

subset

Si

covered

and

cost

ci.

i

n).

Output:

A

set

of

agents

that

can

cover

all

elements.

Initialize

r

and

R

while

R

U

do

Find

the

set

Sj

with

the

minimum

density

cj

|Sj

−Tr|

Set

Tr

S

Sj

and

R

R

S

j.

r

r

Output

R.

Let

GSC(S)

be

the

sets

selected

by

the

Algorithm

that

the

output

set

is

a

function

of

S

and

c.

Some

works

assume

that

the

type

of

an

agent

could

be

ci,

i.e.,

Si

is

assumed

to

be

a

public

knowledge.

Here,

we

consider

a

more

general

case

in

which

the

type

of

an

agent

is

(Si,

ci).

In

other

words,

we

assume

that

every

agent

i

can

not

only

lie

about

its

cost

ci

but

also

can

lie

about

the

set

Si.

This

problem

now

looks

similar

to

the

combinatorial

auction

with

single

minded

bidder

studied

in

but

with

the

following

differences:

in

the

set

cover

problem

we

want

to

cover

all

the

elements

and

the

sets

chosen

can

have

some

overlap

while

in

combinatorial

auction

the

chosen

sets

are

disjoint.

We

can

show

that

the

mechanism

M

(GSC,

PV

CG

using

Algorithm

to

find

a

set

cover

and

apply

VCG

mechanism

to

compute

the

payment

to

the

selected

agents,

is

not

truthful.

Obviously,

the

set

cover

problem

is

a

binary

demand

game.

For

the

moment,

we

assume

that

agent

i

won"t

be

able

to

lie

about

Si.

We

will

drop

this

assumption

later.

We

show

how

to

design

a

truthful

mechanism

by

applying

our

general

framework.

Check

the

monotonicity

property:

The

output

of

Algorithm

is

a

round-based

output.

Thus,

for

an

agent

i,

we

first

focus

on

the

output

of

one

round

r.

In

round

r,

if

i

is

selected

by

Algorithm

then

it

has

the

minimum

ratio

ci

|Si−Tr|

among

all

remaining

agents.

Now

consider

the

case

when

i

lies

its

cost

to

ci

ci,

obviously

ci

|Si−Tr|

is

still

minimum

among

all

remaining

agents.

Consequently,

agent

i

is

still

selected

in

round

r,

which

means

the

output

of

round

r

satisfies

MP.

Now

we

look

into

the

updating

rules.

For

every

round,

we

only

update

the

Tr

S

Sj

and

R

R

S

j,

which

is

obviously

cross-independent.

Thus,

by

applying

Theorem

we

know

the

output

by

Algorithm

satisfies

MP.

Find

the

cut

value:

To

calculate

the

cut

value

for

agent

i

with

fixed

cost

vector

c−i,

we

follow

the

steps

in

Algorithm

First,

we

set

ci

and

apply

Algorithm

Let

ir

be

the

agent

selected

in

round

r

and

T−i

be

the

corresponding

set.

Then

the

cut

value

of

round

r

is

r

cir

|Sir

T−i

r

|Si

T−i

r

Remember

the

updating

rule

only

updates

the

game

setting

but

not

the

cost

of

the

agent,

thus

we

have

gr(x)

x

r

for

r

t.

Therefore,

the

final

cut

value

for

agent

i

is

κi(GSC,

c−i)

max

r

cir

|Sir

T−i

r

|Si

T−i

r

The

payment

to

an

agent

i

is

κi

if

i

is

selected;

otherwise

its

payment

is

We

now

consider

the

scenario

when

agent

i

can

lie

about

Si.

Assume

that

agent

i

cannot

lie

upward,

i.e.,

it

can

only

report

a

set

Si

Si.

We

argue

that

agent

i

will

not

lie

about

its

elements

Si.

Notice

that

the

cut

value

computed

for

round

r

is

r

cir

|Sir

−T

−i

r

|Si

T−i

r

Obviously

|Si

T−i

r

|Si

T−i

r

for

any

Si

Si.

Thus,

lying

its

set

as

Si

will

not

increase

the

cut

value

for

each

round.

Thus

lying

about

Si

will

not

improve

agent

i"s

utility.

Link

Weighted

Steiner

Trees

Consider

any

link

weighted

network

G

(V,

E,

c),

where

E

em}

are

the

set

of

links

and

ci

is

the

weight

of

the

link

ei.

The

link

weighted

Steiner

tree

problem

is

to

find

a

tree

rooted

at

source

node

s

spanning

a

given

set

of

nodes

Q

qk}

V

For

simplicity,

we

assume

that

qi

vi,

for

i

k.

Here

the

links

are

agents.

The

total

cost

of

links

in

a

graph

H

G

is

called

the

weight

of

H,

denoted

as

ω(H).

It

is

NP-hard

to

find

the

minimum

cost

multicast

tree

when

given

an

arbitrary

link

weighted

graph

G

The

currently

best

polynomial

time

method

has

approximation

ratio

ln

Here,

we

review

and

discuss

the

first

approximation

method

by

Takahashi

and

Matsuyama

Algorithm

Find

LinkWeighted

SteinerTree

(LST)

Input:

Network

G

(V,

E,

c)

where

c

is

the

cost

vector

for

link

set

E.

Source

node

s

and

receiver

set

Q.

Output:

A

tree

LST

rooted

at

s

and

spanned

all

receivers.

Set

r

G,

Q

and

s.

repeat

In

graph

Gr,

find

the

receiver,

say

qi,

that

is

closest

to

the

source

s,

i.e.,

LCP(s,

qi,

c)

has

the

least

cost

among

the

shortest

paths

from

s

to

all

receivers

in

Qr

Select

all

links

on

LCP(s,

qi,

c)

as

relay

links

and

set

their

cost

to

The

new

graph

is

denoted

as

Set

tr

as

qi

and

Pr

LCP(s,

qi,

c).

Set

Qr

\qi

and

r

r

until

all

receivers

are

spanned.

Hereafter,

let

LST(G)

be

the

final

tree

constructed

using

the

above

method.

It

is

shown

in

that

mechanism

M

(LST,

pV

CG

is

not

truthful,

where

pV

CG

is

the

payment

calculated

based

on

VCG

mechanism.

We

then

show

how

to

design

a

truthful

payment

scheme

using

our

general

framework.

Observe

that

the

output

Pr,

for

any

round

r,

satisfies

MP,

and

the

update

rule

for

every

round

satisfies

crossing-independence.

Thus,

from

Theorem

the

roundbased

output

LST

satisfies

MP.

In

round

r,

the

cut

value

for

a

link

ei

can

be

obtained

by

using

the

VCG

mechanism.

Now

we

set

ci

and

execute

Algorithm

Let

w−i

r

(ci)

be

the

cost

of

the

path

Pr(ci)

selected

in

the

rth

round

and

Πi

r(ci)

be

the

shortest

path

selected

in

round

r

if

the

cost

of

ci

is

temporarily

set

to

Then

the

cut

value

for

round

r

is

r

wi

r(c−i)

|Πi

r(c−i)|

where

|Πi

r(c−i)|

is

the

cost

of

the

path

Πi

r(c−i)

excluding

node

vi.

Using

Algorithm

we

obtain

the

final

cut

value

for

agent

i:

κi(LST,

c−i)

maxr{

r}.

Thus,

the

payment

to

a

link

ei

is

κi(LST,

c−i)

if

its

reported

cost

is

di

κi(LST,

d−i);

otherwise,

its

payment

is

Virtual

Minimal

Spanning

Trees

To

connect

the

given

set

of

receivers

to

the

source

node,

besides

the

Steiner

tree

constructed

by

the

algorithms

described

before,

a

virtual

minimum

spanning

tree

is

also

often

used.

Assume

that

Q

is

the

set

of

receivers,

including

the

sender.

Assume

that

the

nodes

in

a

node-weighted

graph

are

all

agents.

The

virtual

minimum

spanning

tree

is

constructed

as

follows.

Algorithm

Construct

VMST

for

all

pairs

of

receivers

qi,

qj

Q

do

Calculate

the

least

cost

path

LCP(qi,

qj,

d).

Construct

a

virtual

complete

link

weighted

graph

K(d)

using

Q

as

its

node

set,

where

the

link

qiqj

corresponds

to

the

least

cost

path

LCP(qi,

qj,

d),

and

its

weight

is

w(qiqj)

|LCP(qi,

qj,

d)|.

Build

the

minimum

spanning

tree

on

K(d),

denoted

as

V

MST(d).

for

every

virtual

link

qiqj

in

V

MST(d)

do

Find

the

corresponding

least

cost

path

LCP(qi,

qj,

d)

in

the

original

network.

Mark

the

agents

on

LCP(qi,

qj,

d)

selected.

The

mechanism

M

(V

MST,

pV

CG

is

not

truthful

where

the

payment

pV

CG

to

a

node

is

based

on

the

VCG

mechanism.

We

then

show

how

to

design

a

truthful

mechanism

based

on

the

framework

we

described.

Check

the

monotonicity

property:

Remember

that

in

the

complete

graph

K(d),

the

weight

of

a

link

qiqj

is

|LCP(qi,

qj,

d)|.

In

other

words,

we

implicitly

defined

|Q|(|Q|

functions

fi,j,

for

all

i

j

and

qi

Q

and

qj

Q,

with

fi,j(d)

|LCP(qi,

qj,

d)|.

We

can

show

that

the

function

fi,j(d)

|LCP(qi,

qj,

d)|

satisfies

FMP,

LCP

satisfies

MP,

and

the

output

MST

satisfies

SMP.

From

Theorem

the

allocation

rule

VMST

satisfies

the

monotonicity

property.

Find

the

cut

value:

Notice

VMST

is

the

combination

of

MST

and

function

fi,j,

so

cut

value

for

VMST

can

be

computed

based

on

Algorithm

as

follows.

(a)

Given

a

link

weighted

complete

graph

K(d)

on

Q,

we

should

find

the

cut

value

function

for

edge

ek

(qi,

qj)

based

on

MST.

Given

a

spanning

tree

T

and

a

pair

of

terminals

p

and

q,

clearly

there

is

a

unique

path

connecting

them

on

T.

We

denote

this

path

as

ΠT

(p,

q),

and

the

edge

with

the

maximum

length

on

this

path

as

LE(p,

q,

T).

Thus,

the

cut

value

can

be

represented

as

κk(MST,

d)

LE(qi,

qj,

MST(d|k

(b)

We

find

the

value-cost

function

for

LCP.

Assume

vk

LCP(qi,

qj,

d),

then

the

value-cost

function

is

xk

yk

|LCPvk

(qi,

qj,

d|k

Here,

LCPvk

(qi,

qj,

d)

is

the

least

cost

path

between

qi

and

qj

with

node

vk

on

this

path.

(c)

Remove

vk

and

calculate

the

value

K(d|k

Set

h(i,j)

|LCP(qi,

qj,

d|∞

for

every

pair

of

node

i

j

and

let

h

{h(i,j)}

be

the

vector.

Then

it

is

easy

to

show

that

τ(i,j)

|LE(qi,

qj,

MST(h|(i,j)

is

the

cut

value

for

output

VMST.

It

easy

to

verify

that

min{h(i,j),

τ(i,j)}

|LE(qi,

qj,

MST(h)|.

Thus,

we

know

κ

(i,j)

k

(V

MST,

d)

is

|LE(qi,

qj,

MST(h)|−

|LCPvk

(qi,

qj,

d|k

The

cut

value

for

agent

k

is

κk(V

MST,

d−k)

κij

k

(V

MST,

d−k).

We

pay

agent

k

κk(V

MST,

d−k)

if

and

only

if

k

is

selected

in

V

MST(d);

else

we

pay

it

Combinatorial

Auctions

Lehmann

et

al.

studied

how

to

design

an

efficient

truthful

mechanism

for

single-minded

combinatorial

auction.

In

a

singleminded

combinatorial

auction,

there

is

a

set

of

items

S

to

be

sold

and

there

is

a

set

of

agents

i

n

who

wants

to

buy

some

of

the

items:

agent

i

wants

to

buy

a

subset

Si

S

with

maximum

price

mi.

A

single-minded

bidder

i

declares

a

bid

bi

Si,

ai

with

Si

S

and

ai

R+

Two

bids

Si,

ai

and

Sj,

aj

conflict

if

Si

Sj

Given

the

bids

bn,

they

gave

a

greedy

round-based

algorithm

as

follows.

First

the

bids

are

sorted

by

some

criterion

ai

is

used

in

an

increasing

order

and

let

L

be

the

list

of

sorted

bids.

The

first

bid

is

granted.

Then

the

algorithm

exams

each

bid

of

L

in

order

and

grants

the

bid

if

it

does

not

conflict

with

any

of

the

bids

previously

granted.

If

it

does,

it

is

denied.

They

proved

that

this

greedy

allocation

scheme

using

criterion

ai

approximates

the

optimal

allocation

within

a

factor

of

m,

where

m

is

the

number

of

goods

in

S.

In

the

auction

settings,

we

have

ci

−ai.

It

is

easy

to

verify

the

output

of

the

greedy

algorithm

is

a

round-based

output.

Remember

after

bidder

j

is

selected

for

round

r,

every

bidder

has

conflict

with

j

will

not

be

selected

in

the

rounds

after.

This

equals

to

update

the

cost

of

every

bidder

having

conflict

with

j

to

which

satisfies

crossing-independence.

In

addition,

in

any

round,

if

bidder

i

is

selected

with

ai

then

it

will

still

be

selected

when

it

declares

ai

ai.

Thus,

for

every

round,

it

satisfies

MP

and

the

cut

value

is

ajr

|Sjr

where

jr

is

the

bidder

selected

in

round

r

if

we

did

not

consider

the

agent

i

at

all.

Notice

ajr

|Sjr

does

not

increase

when

round

r

increases,

so

the

final

cut

value

is

aj

|Sj

where

bj

is

the

first

bid

that

has

been

denied

but

would

have

been

selected

were

it

not

only

for

the

presence

of

bidder

i.

Thus,

the

payment

by

agent

i

is

aj

|Sj

if

ai

aj

|Sj

and

otherwise.

This

payment

scheme

is

exactly

the

same

as

the

payment

scheme

in

CONCLUSIONS

In

this

paper,

we

have

studied

how

to

design

a

truthful

mechanism

M

(O,

P)

for

a

given

allocation

rule

O

for

a

binary

demand

game.

We

first

showed

that

the

allocation

rule

O

satisfying

the

MP

is

a

necessary

and

sufficient

condition

for

a

truthful

mechanism

M

to

exist.

We

then

formulate

a

general

framework

for

designing

payment

P

such

that

the

mechanism

M

(O,

P)

is

truthful

and

computable

in

polynomial

time.

We

further

presented

several

general

composition-based

techniques

to

compute

P

efficiently

for

various

allocation

rules

O.

Several

concrete

examples

were

discussed

to

demonstrate

our

general

framework

for

designing

P

and

for

composition-based

techniques

of

computing

P

in

polynomial

time.

In

this

paper,

we

have

concentrated

on

how

to

compute

P

in

polynomial

time.

Our

algorithms

do

not

necessarily

have

the

optimal

running

time

for

computing

P

given

O.

It

would

be

of

interest

to

design

algorithms

to

compute

P

in

optimal

time.

We

have

made

some

progress

in

this

research

direction

in

by

providing

an

algorithm

to

compute

the

payments

for

unicast

in

a

node

weighted

graph

in

optimal

O(n

log

n

m)

time.

Another

research

direction

is

to

design

an

approximation

allocation

rule

O

satisfying

MP

with

a

good

approximation

ratio

for

a

given

binary

demand

game.

Many

works

in

the

mechanism

design

literature

are

in

this

direction.

We

point

out

here

that

the

goal

of

this

paper

is

not

to

design

a

better

allocation

rule

for

a

problem,

but

to

design

an

algorithm

to

compute

the

payments

efficiently

when

O

is

given.

It

would

be

of

significance

to

design

allocation

rules

with

good

approximation

ratios

such

that

a

given

binary

demand

game

has

a

computationally

efficient

payment

scheme.

In

this

paper,

we

have

studied

mechanism

design

for

binary

demand

games.

However,

some

problems

cannot

be

directly

formulated

as

binary

demand

games.

The

job

scheduling

problem

in

is

such

an

example.

For

this

problem,

a

truthful

payment

scheme

P

exists

for

an

allocation

rule

O

if

and

only

if

the

workload

assigned

by

O

is

monotonic

in

a

certain

manner.

It

wound

be

of

interest

to

generalize

our

framework

for

designing

a

truthful

payment

scheme

for

a

binary

demand

game

to

non-binary

demand

games.

Towards

this

research

direction,

Theorem

can

be

extended

to

a

general

allocation

rule

O,

whose

range

is

R+

The

remaining

difficulty

is

then

how

to

compute

the

payment

P

under

mild

assumptions

about

the

valuations

if

a

truthful

mechanism

M

(O,

P)

does

exist.

Acknowledgements

We

would

like

to

thank

Rakesh

Vohra,

Tuomas

Sandholm,

and

anonymous

reviewers

for

helpful

comments

and

discussions.

REFERENCES

A.

ARCHER,

C.

PAPADIMITRIOU,

K.

T.,

AND

TARDOS,

E.

An

approximate

truthful

mechanism

for

combinatorial

auctions

with

single

parameter

agents.

In

ACM-SIAM

SODA

pp.

ARCHER,

A.,

AND

TARDOS,

E.

Truthful

mechanisms

for

one-parameter

agents.

In

Proceedings

of

the

IEEE

FOCS

IEEE

Computer

Society,

p.

AULETTA,

V.,

PRISCO,

R.

D.,

PENNA,

P.,

AND

PERSIANO,

P.

Deterministic

truthful

approximation

schemes

for

scheduling

related

machines.

CHVATAL,

V.

A

greedy

heuristic

for

the

set

covering

problem.

Mathematics

of

Operations

Research

CLARKE,

E.

H.

Multipart

pricing

of

public

goods.

Public

Choice

R.

Muller,

and

R.

V.

Vohra.

On

Dominant

Strategy

Mechanisms.

Working

paper,

DEVANUR,

N.

R.,

MIHAIL,

M.,

AND

VAZIRANI,

V.

V.

Strategyproof

cost-sharing

mechanisms

for

set

cover

and

facility

location

games.

In

ACM

Electronic

Commerce

FEIGENBAUM,

J.,

KRISHNAMURTHY,

A.,

SAMI,

R.,

AND

SHENKER,

S.

Approximation

and

collusion

in

multicast

cost

sharing

(abstract).

In

ACM

Economic

Conference

FEIGENBAUM,

J.,

PAPADIMITRIOU,

C.,

SAMI,

R.,

AND

SHENKER,

S.

A

BGP-based

mechanism

for

lowest-cost

routing.

In

Proceedings

of

the

ACM

Symposium

on

Principles

of

Distributed

Computing.

pp.

GREEN,

J.,

AND

LAFFONT,

J.

J.

Characterization

of

satisfactory

mechanisms

for

the

revelation

of

preferences

for

public

goods.

Econometrica

GROVES,

T.

Incentives

in

teams.

Econometrica

LEHMANN,

D.,

OCALLAGHAN,

L.

I.,

AND

SHOHAM,

Y.

Truth

revelation

in

approximately

efficient

combinatorial

auctions.

Journal

of

ACM

MU"ALEM,

A.,

AND

NISAN,

N.

Truthful

approximation

mechanisms

for

restricted

combinatorial

auctions:

extended

abstract.

In

National

Conference

on

Artificial

intelligence

American

Association

for

Artificial

Intelligence,

pp.

NISAN,

N.,

AND

RONEN,

A.

Algorithmic

mechanism

design.

In

Proc.

Annual

ACM

STOC

pp.

E.

Halperin.

Improved

approximation

algorithms

for

the

vertex

cover

problem

in

graphs

and

hypergraphs.

In

Proceedings

of

the

Annual

ACM-SIAM

Symposium

on

Discrete

Algorithms,

pages

R.

Bar-Yehuda

and

S.

Even.

A

local

ratio

theorem

for

approximating

the

weighted

vertex

cover

problem.

Annals

of

Discrete

Mathematics,

Volume

Analysis

and

Design

of

Algorithms

for

Combinatorial

Problems,

pages

Editor:

G.

Ausiello

and

M.

Lucertini

ROBINS,

G.,

AND

ZELIKOVSKY,

A.

Improved

steiner

tree

approximation

in

graphs.

In

Proceedings

of

the

annual

ACM-SIAM

SODA

pp.

A.

Zelikovsky.

An

algorithm

for

the

network

Steiner

problem.

Algorithmica,

D.

S.

Hochbaum.

Efficient

bounds

for

the

stable

set,

vertex

cover,

and

set

packing

problems,

Discrete

Applied

Mathematics,

TAKAHASHI,

H.,

AND

MATSUYAMA,

A.

An

approximate

solution

for

the

steiner

problem

in

graphs.

Math.

Japonica

VICKREY,

W.

Counterspeculation,

auctions

and

competitive

sealed

tenders.

Journal

of

Finance

WANG,

W.,

AND

LI,

X.-Y.

Truthful

low-cost

unicast

in

selfish

wireless

networks.

In

IEEE

Transactions

on

Mobile

Computing

to

appear.

WANG,

W.,

LI,

X.-Y.,

AND

SUN,

Z.

Design

multicast

protocols

for

non-cooperative

networks.

IEEE

INFOCOM

to

appear.

WANG,

W.,

LI,

X.-Y.,

AND

WANG,

Y.

Truthful

multicast

in

selfish

wireless

networks.

ACM

MobiCom,

vickrey-clarke-grove
composition-based technique
selfish wireless network
selfish agent

truthful mechanism
binary demand game
objective function
combination
mechanism design
pricing
monotonicity property
cut value function
price
demand game