ICE:

An

Iterative

Combinatorial

Exchange

David

C.

Parkes∗

Ruggiero

Cavallo†

Nick

Elprin†

Adam

Juda†

S´ebastien

Lahaie†

Benjamin

Lubin†

Loizos

Michael†

Jeffrey

Shneidman†

Hassan

Sultan†

ABSTRACT

We

present

the

first

design

for

an

iterative

combinatorial

exchange

(ICE).

The

exchange

incorporates

a

tree-based

bidding

language

that

is

concise

and

expressive

for

CEs.

Bidders

specify

lower

and

upper

bounds

on

their

value

for

different

trades.

These

bounds

allow

price

discovery

and

useful

preference

elicitation

in

early

rounds,

and

allow

termination

with

an

efficient

trade

despite

partial

information

on

bidder

valuations.

All

computation

in

the

exchange

is

carefully

optimized

to

exploit

the

structure

of

the

bid-trees

and

to

avoid

enumerating

trades.

A

proxied

interpretation

of

a

revealedpreference

activity

rule

ensures

progress

across

rounds.

A

VCG-based

payment

scheme

that

has

been

shown

to

mitigate

opportunities

for

bargaining

and

strategic

behavior

is

used

to

determine

final

payments.

The

exchange

is

fully

implemented

and

in

a

validation

phase.

Categories

and

Subject

Descriptors:

[Artificial

Intelligence]:

Distributed

Artificial

Intelligence;

[Computer

Applications]:

Social

and

Behavioral

Sciences

-Economics

General

Terms:

Algorithms,

Economics,

Theory.

INTRODUCTION

Combinatorial

exchanges

combine

and

generalize

two

different

mechanisms:

double

auctions

and

combinatorial

auctions.

In

a

double

auction

(DA),

multiple

buyers

and

sellers

trade

units

of

an

identical

good

In

a

combinatorial

auction

(CA),

a

single

seller

has

multiple

heterogeneous

items

up

for

sale

Buyers

may

have

complementarities

or

substitutabilities

between

goods,

and

are

provided

with

an

expressive

bidding

language.

A

common

goal

in

both

market

designs

is

to

determine

the

efficient

allocation,

which

is

the

allocation

that

maximizes

total

value.

A

combinatorial

exchange

(CE)

is

a

combinatorial

double

auction

that

brings

together

multiple

buyers

and

sellers

to

trade

multiple

heterogeneous

goods.

For

example,

in

an

exchange

for

wireless

spectrum,

a

bidder

may

declare

that

she

is

willing

to

pay

million

for

a

trade

where

she

obtains

licenses

for

New

York

City,

Boston,

and

Philadelphia,

and

loses

her

license

for

Washington

DC.

Thus,

unlike

a

DA,

a

CE

allows

all

participants

to

express

complex

valuations

via

expressive

bids.

Unlike

a

CA,

a

CE

allows

for

fragmented

ownership,

with

multiple

buyers

and

sellers

and

agents

that

are

both

buying

and

selling.

CEs

have

received

recent

attention

both

in

the

context

of

wireless

spectrum

allocation

and

for

airport

takeoff

and

landing

slot

allocation

In

both

of

these

domains

there

are

incumbents

with

property

rights,

and

it

is

important

to

facilitate

a

complex

multi-way

reallocation

of

resources.

Another

potential

application

domain

for

CEs

is

to

resource

allocation

in

shared

distributed

systems,

such

as

PlanetLab

The

instantiation

of

our

general

purpose

design

to

specific

domains

is

a

compelling

next

step

in

our

research.

This

paper

presents

the

first

design

for

an

iterative

combinatorial

exchange

(ICE).

The

genesis

of

this

project

was

a

class,

CS

Topics

at

the

Interface

between

Economics

and

Computer

Science,

taught

at

Harvard

University

in

Spring

The

entire

class

was

dedicated

to

the

design

and

prototyping

of

an

iterative

CE.

The

ICE

design

problem

is

multi-faceted

and

quite

hard.

The

main

innovation

in

our

design

is

an

expressive

yet

concise

tree-based

bidding

language

(which

generalizes

known

languages

such

as

XOR/OR

and

the

tight

coupling

of

this

language

with

efficient

algorithms

for

price-feedback

to

guide

bidding,

winner-determination

to

determine

trades,

and

revealed-preference

activity

rules

to

ensure

progress

across

rounds.

The

exchange

is

iterative:

bidders

express

upper

and

lower

valuations

on

trades

by

annotating

their

bid-tree,

and

then

tighten

these

bounds

in

response

to

price

feedback

in

each

round.

The

Threshold

payment

rule,

introduced

by

Parkes

et

al.

is

used

to

determine

final

payments.

The

exchange

has

a

number

of

interesting

theoretical

properties.

For

instance,

when

there

exist

linear

prices

we

establish

soundness

and

completeness:

for

straightforward

bidders

that

adjust

their

bounds

to

meet

activity

rules

while

keeping

their

true

value

within

the

bounds,

the

exchange

will

terminate

with

the

efficient

allocation.

In

addition,

the

Truth

Agent

Act

Rule

WD

ACC

FAIR

BALClosing

RuleVickreyThreshold

DONE

DONE

+A

+B

BUYER

-A

-B

SELLER

+A

+B

BUYER

-A

-B

SELLER

BUYER,

buy

AB

SELLER,

sell

AB

PA+PB

PBUYER

PSELLER

PBUYER

PSELLER

Pessim

istic

O

ptim

istic

Figure

ICE

System

Flow

of

Control

efficient

allocation

can

often

be

determined

without

bidders

revealing,

or

even

knowing,

their

exact

value

for

all

trades.

This

is

essential

in

complex

domains

where

the

valuation

problem

can

itself

be

very

challenging

for

a

participant

While

we

cannot

claim

that

straightforward

bidding

is

an

equilibrium

of

the

exchange

(and

indeed,

should

not

expect

to

by

the

Myerson-Satterthwaite

impossibility

theorem

the

Threshold

payment

rule

minimizes

the

ex

post

incentive

to

manipulate

across

all

budget-balanced

payment

rules.

The

exchange

is

implemented

in

Java

and

is

currently

in

validation.

In

describing

the

exchange

we

will

first

provide

an

overview

of

the

main

components

and

introduce

several

working

examples.

Then,

we

introduce

the

basic

components

for

a

simple

one-shot

variation

in

which

bidders

state

their

exact

values

for

trades

in

a

single

round.

We

then

describe

the

full

iterative

exchange,

with

upper

and

lower

values,

price-feedback,

activity

rules,

and

termination

conditions.

We

state

some

theoretical

properties

of

the

exchange,

and

end

with

a

discussion

to

motivate

our

main

design

decisions,

and

suggest

some

next

steps.

AN

OVERVIEW

OF

THE

ICE

DESIGN

The

design

has

four

main

components,

which

we

will

introduce

in

order

through

the

rest

of

the

paper:

Expressive

and

concise

tree-based

bidding

language.

The

language

describes

values

for

trades,

such

as

my

value

for

selling

AB

and

buying

C

is

or

my

value

for

selling

ABC

is

with

negative

values

indicating

that

a

bidder

must

receive

a

payment

for

the

trade

to

be

acceptable.

The

language

allows

bidders

to

express

upper

and

lower

bounds

on

value,

which

can

be

tightened

across

rounds.

Winner

Determination.

Winner-determination

(WD)

is

formulated

as

a

mixed-integer

program

(MIP),

with

the

structure

of

the

bid-trees

captured

explicitly

in

the

formulation.

Comparing

the

solution

at

upper

and

lower

values

allows

for

a

determination

to

be

made

about

termination,

with

progress

in

intermediate

rounds

driven

by

an

intermediate

valuation

and

the

lower

values

adopted

on

termination.

Payments.

Payments

are

computed

using

the

Threshold

payment

rule

with

the

intermediate

valuations

adopted

in

early

rounds

and

lower

values

adopted

on

termination.

Price

feedback.

An

approximate

price

is

computed

for

each

item

in

the

exchange

in

each

round,

in

terms

of

the

intermediate

valuations

and

the

provisional

trade.

The

prices

are

optimized

to

approximate

competitive

equilibrium

prices,

and

further

optimized

to

best

approximate

the

current

Threshold

payments

with

remaining

ties

broken

to

favor

prices

that

are

balanced

across

different

items.

In

computing

the

prices,

we

adopt

the

methods

of

constraint-generation

to

exploit

the

structure

of

the

bidding

language

and

avoid

enumerating

all

feasible

trades.

The

subproblem

to

generate

new

constraints

is

a

variation

of

the

WD

problem.

Activity

rule.

A

revealed-preference

activity

rule

ensures

progress

across

rounds.

In

order

to

remain

active,

a

bidder

must

tighten

bounds

so

that

there

is

enough

information

to

define

a

trade

that

maximizes

surplus

at

the

current

prices.

Another

variation

on

the

WD

problem

is

formulated,

both

to

verify

that

the

activity

rule

is

met

and

also

to

provide

feedback

to

a

bidder

to

explain

how

to

meet

the

rule.

An

outline

of

the

ICE

system

flow

of

control

is

provided

in

Figure

We

will

return

to

this

example

later

in

the

paper.

For

now,

just

observe

in

this

two-agent

example

that

the

agents

state

lower

and

upper

bounds

that

are

checked

in

the

activity

rule,

and

then

passed

to

winner-determination

(WD),

and

then

through

three

stages

of

pricing

(accuracy,

fairness,

balance).

On

passing

the

closing

rule

(in

which

parameters

αeff

and

αthresh

are

checked

for

convergence

of

the

trade

and

payments),

the

exchange

goes

to

a

last-and-final

round.

At

the

end

of

this

round,

the

trade

and

payments

are

finally

determined,

based

on

the

lower

valuations.

Related

Work

Many

ascending-price

one-sided

CAs

are

known

in

the

literature

Direct

elicitation

approaches

have

also

been

proposed

for

one-sided

CAs

in

which

agents

respond

to

explicit

queries

about

their

valuations

A

number

of

ascending

CAs

are

designed

to

work

with

simple

prices

on

items

The

price

generation

methods

that

we

use

in

ICE

generalize

the

methods

in

these

earlier

papers.

Parkes

et

al.

studied

sealed-bid

combinatorial

exchanges

and

introduced

the

Threshold

payment

rule.

Subsequently,

Krych

demonstrated

experimentally

that

the

Threshold

rule

promotes

efficient

allocations.

We

are

not

aware

of

any

previous

studies

of

iterative

CEs.

Dominant

strategy

DAs

are

known

for

unit

demand

and

also

for

single-minded

agents

No

dominant

strategy

mechanisms

are

known

for

the

general

CE

problem.

ICE

is

a

hybrid

auction

design,

in

that

it

couples

simple

item

prices

to

drive

bidding

in

early

rounds

with

combinatorial

WD

and

payments,

a

feature

it

shares

with

the

clock-proxy

design

of

Ausubel

et

al.

for

one-sided

CAs.

We

adopt

a

variation

on

the

clock-proxy

auctions"s

revealedpreference

activity

rule.

The

bidding

language

shares

some

structural

elements

with

the

LGB

language

of

Boutilier

and

Hoos

but

has

very

different

semantics.

Rothkopf

et

al.

also

describe

a

restricted

tree-based

bidding

language.

In

LGB,

the

semantics

are

those

of

propositional

logic,

with

the

same

items

in

an

allocation

able

to

satisfy

a

tree

in

multiple

places.

Although

this

can

make

LGB

especially

concise

in

some

settings,

the

semantics

that

we

propose

appear

to

provide

useful

locality,

so

that

the

value

of

one

component

in

a

tree

can

be

understood

independently

from

the

rest

of

the

tree.

The

idea

of

capturing

the

structure

of

our

bidding

language

explicitly

within

a

mixed-integer

programming

formulation

follows

the

developments

in

Boutilier

PRELIMINARIES

In

our

model,

we

consider

a

set

of

goods,

indexed

m}

and

a

set

of

bidders,

indexed

n}.

The

initial

allocation

of

goods

is

denoted

n),

with

i

im)

and

ij

for

good

j

indicating

the

number

of

units

of

good

j

held

by

bidder

i.

A

trade

λ

λn)

denotes

the

change

in

allocation,

with

λi

λim)

where

λij

is

the

change

in

the

number

of

units

of

item

j

to

bidder

i.

So,

the

final

allocation

is

λ.

Each

bidder

has

a

value

vi(λi)

for

a

trade

λi.

This

value

can

be

positive

or

negative,

and

represents

the

change

in

value

between

the

final

allocation

i

+λi

and

the

initial

allocation

i

Utility

is

quasi-linear,

with

ui(λi,

p)

vi(λi)−p

for

trade

λi

and

payment

p

Price

p

can

be

negative,

indicating

the

bidder

receives

a

payment

for

the

trade.

We

use

the

term

payoff

interchangeably

with

utility.

Our

goal

in

the

ICE

design

is

to

implement

the

efficient

trade.

The

efficient

trade,

λ∗

maximizes

the

total

increase

in

value

across

bidders.

Definition

(Efficient

trade).

The

efficient

trade

λ∗

solves

max

i

vi(λi)

s.t.

λij

ij

∀i,

∀j

i

λij

∀j

λij

Constraints

ensure

that

no

agent

sells

more

items

than

it

has

in

its

initial

allocation.

Constraints

provide

free

disposal,

and

allows

feasible

trades

to

sell

more

items

than

are

purchased

(but

not

vice

versa).

Later,

we

adopt

to

denote

the

set

of

feasible

trades,

given

these

constraints

and

given

an

initial

allocation

n).

Working

Examples

In

this

section,

we

provide

three

simple

examples

of

instances

that

we

will

use

to

illustrate

various

components

of

the

exchange.

All

three

examples

have

only

one

seller,

but

this

is

purely

illustrative.

Example

One

seller

and

one

buyer,

two

goods

{A,

B},

with

the

seller

having

an

initial

allocation

of

AB.

Changes

in

values

for

trades:

seller

buyer

AND(−A,

−B)

AND(+A,

+B)

The

AND

indicates

that

both

the

buyer

and

the

seller

are

only

interested

in

trading

both

goods

as

a

bundle.

Here,

the

efficient

(value-maximizing)

trade

is

for

the

seller

to

sell

AB

to

the

buyer,

denoted

λ∗

Example

One

seller

and

four

buyers,

four

goods

{A,

B,

C,

D},

with

the

seller

having

an

initial

allocation

of

ABCD.

Changes

in

values

for

trades:

seller

buyer

buyer

buyer

OR(−A,

−B,

AND(+A,

XOR(+A,

AND(+C,

XOR(+C,

−C,

−D)

+B)

+B)

+D)

+D)

The

OR

indicates

that

the

seller

is

willing

to

sell

any

number

of

goods.

The

XOR

indicates

that

buyers

and

are

willing

to

buy

at

most

one

of

the

two

goods

in

which

they

are

interested.

The

efficient

trade

is

for

bundle

AB

to

go

to

buyer

and

bundle

CD

to

buyer

denoted

λ∗

+A

+B

BUYER

-A

-B

SELLER

Example

Example

+C

+D

BUYER

+A

+B

BUYER

-B

SELLER

-A

-C

-D

Example

+A

+B

BUYER

+A

+B

BUYER

-B

SELLER

-C

-D-A

+C

+D

BUYER

+C

+D

BUYER

Figure

Example

Bid

Trees.

Example

One

seller

and

two

buyers,

four

goods

{A,

B,

C,

D},

with

the

seller

having

an

initial

allocation

of

ABCD.

Changes

in

values

for

trades:

seller

buyer

AND(−A,

−B,

−C,

−D)

AND(+A,

+B)

AND(+C,

+D)

The

efficient

trade

is

for

bundle

AB

to

go

to

buyer

and

bundle

CD

to

go

to

buyer

denoted

λ∗

A

ONE-SHOT

EXCHANGE

DESIGN

The

description

of

ICE

is

broken

down

into

two

sections:

one-shot

(sealed-bid)

and

iterative.

In

this

section

we

abstract

away

the

iterative

aspect

and

introduce

a

specialization

of

the

tree-based

language

that

supports

only

exact

values

on

nodes.

Tree-Based

Bidding

Language

The

bidding

language

is

designed

to

be

expressive

and

concise,

entirely

symmetric

with

respect

to

buyers

and

sellers,

and

to

extend

to

capture

bids

from

mixed

buyers

and

sellers,

ranging

from

simple

swaps

to

highly

complex

trades.

Bids

are

expressed

as

annotated

bid

trees,

and

define

a

bidder"s

value

for

all

possible

trades.

The

language

defines

changes

in

values

on

trades,

with

leaves

annotated

with

traded

items

and

nodes

annotated

with

changes

in

values

(either

positive

or

negative).

The

main

feature

is

that

it

has

a

general

interval-choose

logical

operator

on

internal

nodes,

and

that

it

defines

careful

semantics

for

propagating

values

within

the

tree.

We

illustrate

the

language

on

each

of

Examples

in

Figure

The

language

has

a

tree

structure,

with

trades

on

items

defined

on

leaves

and

values

annotated

on

nodes

and

leaves.

The

nodes

have

zero

values

where

no

value

is

indicated.

Internal

nodes

are

also

labeled

with

interval-choose

(IC)

ranges.

Given

a

trade,

the

semantics

of

the

language

define

which

nodes

in

the

tree

can

be

satisfied,

or

switched-on.

First,

if

a

child

is

on

then

its

parent

must

be

on.

Second,

if

a

parent

node

is

on,

then

the

number

of

children

that

are

on

must

be

within

the

IC

range

on

the

parent

node.

Finally,

leaves

in

which

the

bidder

is

buying

items

can

only

be

on

if

the

items

are

provided

in

the

trade.

For

instance,

in

Example

we

can

consider

the

efficient

trade,

and

observe

that

in

this

trade

all

nodes

in

the

trees

of

buyers

and

(and

also

the

seller),

but

of

the

nodes

in

the

trees

of

buyers

and

can

be

on.

On

the

other

hand,

in

the

trade

in

which

A

goes

to

buyer

and

D

to

buyer

then

the

root

and

appropriate

leaf

nodes

can

be

on

for

buyers

and

but

no

nodes

can

be

on

for

buyers

and

Given

a

trade

there

is

often

a

number

of

ways

to

choose

the

set

of

satisfied

nodes.

The

semantics

of

the

language

require

that

the

nodes

that

maximize

the

summed

value

across

satisfied

nodes

be

activated.

Consider

bid

tree

Ti

from

bidder

i.

This

defines

nodes

β

Ti,

of

which

some

are

leaves,

Leaf

(i)

Ti.

Let

Child(β)

Ti

denote

the

children

of

a

node

β

(that

is

not

itself

a

leaf).

All

nodes

except

leaves

are

labeled

with

the

interval-choose

operator

[IC

x

i

(β),

ICy

i

(β)].

Every

node

is

also

labeled

with

a

value,

viβ

Each

leaf

β

is

labeled

with

a

trade,

qiβ

m

(i.e.,

leaves

can

define

a

bundled

trade

on

more

than

one

type

of

item.)

Given

a

trade

λi

to

bidder

i,

the

interval-choose

operators

and

trades

on

leaves

define

which

nodes

can

be

satisfied.

There

will

often

be

a

choice.

Ties

are

broken

to

maximize

value.

Let

satiβ

denote

whether

node

β

is

satisfied.

Solution

sati

is

valid

given

tree

Ti

and

trade

λi,

written

sati

valid(Ti,

λi),

if

and

only

if:

β∈Leaf

(i)

qiβj

satiβ

λij

∀i,

∀j

ICx

i

(β)satiβ

β

∈Child(β)

satiβ

ICy

i

(β)satiβ,

∀β

Leaf

(i)

In

words,

a

set

of

leaves

can

only

be

considered

satisfied

given

trade

λi

if

the

total

increase

in

quantity

summed

across

all

such

leaves

is

covered

by

the

trade,

for

all

goods

(Eq.

This

works

for

sellers

as

well

as

buyers:

for

sellers

a

trade

is

negative

and

this

requires

that

the

total

number

of

items

indicated

sold

in

the

tree

is

at

least

the

total

number

sold

as

defined

in

the

trade.

We

also

need

upwards-propagation:

any

time

a

node

other

than

the

root

is

satisfied

then

its

parent

must

be

satisfied

(by

β

∈Child(β)

satiβ

ICy

i

(β)satiβ

in

Eq.

Finally,

we

need

downwards-propagation:

any

time

an

internal

node

is

satisfied

then

the

appropriate

number

of

children

must

also

be

satisfied

(Eq.

The

total

value

of

trade

λi,

given

bid-tree

Ti,

is

defined

as:

vi(Ti,

λi)

max

sat∈valid(Ti,λi)

β∈T

vβ

satβ

The

tree-based

language

generalizes

existing

languages.

For

instance:

on

a

node

with

children

is

equivalent

to

an

AND

operator;

on

a

node

with

children

is

equivalent

to

an

OR

operator;

and

on

a

node

with

children

is

equivalent

to

an

XOR

operator.

Similarly,

the

XOR/OR

bidding

languages

can

be

directly

expressed

as

a

bid

tree

in

our

Winner

Determination

This

section

defines

the

winner

determination

problem,

which

is

formulated

as

a

MIP

and

solved

in

our

implementation

with

a

commercial

The

solver

uses

branchand-bound

search

with

dynamic

cut

generation

and

branching

heuristics

to

solve

large

MIPs

in

economically

feasible

run

times.

The

OR*

language

is

the

OR

language

with

dummy

items

to

provide

additional

structure.

OR*

is

known

to

be

expressive

and

concise.

However,

it

is

not

known

whether

OR*

dominates

XOR/OR

in

terms

of

conciseness

CPLEX,

In

defining

the

MIP

representation

we

are

careful

to

avoid

an

XOR-based

enumeration

of

all

bundles.

A

variation

on

the

WD

problem

is

reused

many

times

within

the

exchange,

e.g.

for

column

generation

in

pricing

and

for

checking

revealed

preference.

Given

bid

trees

T

Tn)

and

initial

allocation

the

mixed-integer

formulation

for

WD

is:

WD(T,

max

λ,sat

i

β∈Ti

viβ

satiβ

s.t.

satiβ

λij

sati

valid(Ti,

λi),

∀i

Some

goods

may

go

unassigned

because

free

disposal

is

allowed

within

the

clearing

rules

of

winner

determination.

These

items

can

be

allocated

back

to

agents

that

sold

the

items,

i.e.

for

which

λij

Computing

Threshold

Payments

The

Threshold

payment

rule

is

based

on

the

payments

in

the

Vickrey-Clarke-Groves

(VCG)

mechanism

which

itself

is

truthful

and

efficient

but

does

not

satisfy

budget

balance.

Budget-balance

requires

that

the

total

payments

to

the

exchange

are

equal

to

the

total

payments

made

by

the

exchange.

In

VCG,

the

payment

paid

by

agent

i

is

pvcg,i

ˆv(λ∗

i

(V

V−i)

where

λ∗

is

the

efficient

trade,

V

is

the

reported

value

of

this

trade,

and

V−i

is

the

reported

value

of

the

efficient

trade

that

would

be

implemented

without

bidder

i.

We

call

∆vcg,i

V

V−i

the

VCG

discount.

For

instance,

in

Example

pvcg,seller

and

pvcg,buyer

and

the

exchange

would

run

at

a

budget

deficit

of

The

Threshold

payment

rule

determines

budgetbalanced

payments

to

minimize

the

maximal

error

across

all

agents

to

the

VCG

outcome.

Definition

The

Threshold

payment

scheme

implements

the

efficient

trade

λ∗

given

bids,

and

sets

payments

pthresh,i

ˆvi(λ∗

i

∆i,

where

∆n)

is

set

to

minimize

maxi(∆vcg,i

∆i)

subject

to

∆i

∆vcg,i

and

i

∆i

V

(this

gives

budget-balance).

Example

In

Example

the

VCG

discounts

are

to

the

seller

and

four

buyers

respectively,

VCG

payments

are

and

the

exchange

runs

at

a

deficit

of

In

Threshold,

the

discounts

are

and

the

payments

are

This

minimizes

the

worst-case

error

to

VCG

discounts

across

all

budget-balanced

payment

schemes.

Threshold

payments

are

designed

to

minimize

the

maximal

ex

post

incentive

to

manipulate.

Krych

confirmed

that

Threshold

promotes

allocative

efficiency

in

restricted

and

approximate

Bayes-Nash

equilibrium.

THE

ICE

DESIGN

We

are

now

ready

to

introduce

the

iterative

combinatorial

exchange

(ICE)

design.

Several

new

components

are

introduced,

relative

to

the

design

for

the

one-shot

exchange.

Rather

than

provide

precise

valuations,

bidders

can

provide

lower

and

upper

valuations

and

revise

this

bid

information

across

rounds.

The

exchange

provides

price-based

feedback

to

guide

bidders

in

this

process,

and

terminates

with

an

efficient

(or

approximately-efficient)

trade

with

respect

to

reported

valuations.

In

each

round

t

the

current

lower

and

upper

bounds,

vt

and

vt

are

used

to

define

a

provisional

valuation

profile

vα

(the

α-valuation),

together

with

a

provisional

trade

λt

and

provisional

prices

pt

(pt

pt

m)

on

items.

The

α-valuation

is

a

linear

combination

of

the

current

upper

and

lower

valuations,

with

αEFF

chosen

endogenously

based

on

the

closeness

of

the

optimistic

trade

(at

v)

and

the

pessimistic

trade

(at

v).

Prices

pt

are

used

to

inform

an

activity

rule,

and

drive

progress

towards

an

efficient

trade.

Upper

and

Lower

Valuations

The

bidding

language

is

extended

to

allow

a

bidder

i

to

report

a

lower

and

upper

value

(viβ,

viβ)

on

each

node.

These

take

the

place

of

the

exact

value

viβ

defined

in

Section

Based

on

these

labels,

we

can

define

the

valuation

functions

vi(Ti,

λi)

and

vi(Ti,

λi),

using

the

exact

same

semantics

as

in

Eq.

We

say

that

such

a

bid-tree

is

well-formed

if

viβ

viβ

for

all

nodes.

The

following

lemma

is

useful:

Lemma

Given

a

well-formed

tree,

T,

then

vi(Ti,

λi)

vi(Ti,

λi)

for

all

trades.

Proof.

Suppose

there

is

some

λi

for

which

vi(Ti,

λi)

vi(Ti,

λi).

Then,

maxsat∈valid(Ti,λi)

β∈Ti

viβ

satβ

maxsat∈valid(Ti,λi)

β∈Ti

viβ

satβ.

But,

this

is

a

contradiction

because

the

trade

λ

that

defines

vi(Ti,

λi)

is

still

feasible

with

upper

bounds

vi,

and

viβ

viβ

for

all

nodes

β

in

a

well-formed

tree.

Price

Feedback

In

each

round,

approximate

competitive-equilibrium

(CE)

prices,

pt

(pt

pt

m),

are

determined.

Given

these

provisional

prices,

the

price

on

trade

λi

for

bidder

i

is

pt

(λi)

j≤m

pt

j

λij.

Definition

(CE

prices).

Prices

p∗

are

competitive

equilibrium

prices

if

the

efficient

trade

λ∗

is

supported

at

prices

p∗

so

that

for

each

bidder:

λ∗

i

arg

max

{vi(λi)

p∗

(λi)}

CE

prices

will

not

always

exist

and

we

will

often

need

to

compute

approximate

prices

We

extend

ideas

due

to

Rassenti

et

al.

Kwasnica

et

al.

and

Dunford

et

al.

and

select

approximate

prices

as

follows:

I:

Accuracy.

First,

we

compute

prices

that

minimize

the

maximal

error

in

the

best-response

constraints

across

all

bidders.

II:

Fairness.

Second,

we

break

ties

to

prefer

prices

that

minimize

the

maximal

deviation

from

Threshold

payments

across

all

bidders.

III:

Balance.

Third,

we

break

ties

to

prefer

prices

that

minimize

the

maximal

price

across

all

items.

Taken

together,

these

steps

are

designed

to

promote

the

informativeness

of

the

prices

in

driving

progress

across

rounds.

In

computing

prices,

we

explain

how

to

compute

approximate

(or

otherwise)

prices

for

structured

bidding

languages,

and

without

enumerating

all

possible

trades.

For

this,

we

adopt

constraint

generation

to

efficient

handle

an

exponential

number

of

constraints.

Each

step

is

described

in

detail

below.

I:

Accuracy.

We

adopt

a

definition

of

price

accuracy

that

generalizes

the

notions

adopted

in

previous

papers

for

unstructured

bidding

languages.

Let

λt

denote

the

current

provisional

trade

and

suppose

the

provisional

valuation

is

vα

To

compute

accurate

CE

prices,

we

consider:

min

p,δ

δ

s.t.

vα

i

(λ)

p(λ)

vα

i

(λt

i)

p(λt

i)

δ,

∀i,

∀λ

δ

∀j.

This

linear

program

(LP)

is

designed

to

find

prices

that

minimize

the

worst-case

error

across

all

agents.

From

the

definition

of

CE

prices,

it

follows

that

CE

prices

would

have

δ

as

a

solution

to

at

which

point

trade

λt

i

would

be

in

the

best-response

set

of

every

agent

(with

λt

i

i.e.

no

trade,

for

all

agents

with

no

surplus

for

trade

at

the

prices.)

Example

We

can

illustrate

the

formulation

on

Example

assuming

for

simplicity

that

vα

v

(i.e.

truth).

The

efficient

trade

allocates

AB

to

buyer

and

CD

to

buyer

Accuracy

will

seek

prices

p(A),

p(B),

p(C)

and

p(D)

to

minimize

the

δ

required

to

satisfy

constraints:

p(A)

p(B)

p(C)

p(D)

(seller)

p(A)

p(B)

δ

(buyer

p(A)

δ

p(B)

δ

(buyer

p(C)

p(D)

(buyer

p(C)

δ

p(D)

δ

(buyer

An

optimal

solution

requires

p(A)

p(B)

with

δ

with

p(C)

and

p(D)

taking

values

such

as

p(C)

p(D)

But,

has

an

exponential

number

of

constraints

(Eq.

Rather

than

solve

it

explicitly

we

use

constraint

generation

and

dynamically

generate

a

sufficient

subset

of

constraints.

Let

i

denote

a

manageable

subset

of

all

possible

feasible

trades

to

bidder

i.

Then,

a

relaxed

version

of

(written

ACC)

is

formulated

by

substituting

with

vα

i

(λ)

p(λ)

vα

i

(λt

i)

p(λt

i)

δ,

∀i,

∀λ

i

where

i

is

a

set

of

trades

that

are

feasible

for

bidder

i

given

the

other

bids.

Fixing

the

prices

p∗

we

then

solve

n

subproblems

(one

for

each

bidder),

max

λ

vα

i

(λi)

p∗

(λi)

[R-WD(i)]

s.t.

λ

to

check

whether

solution

(p∗

δ∗

to

ACC

is

feasible

in

problem

In

R-WD(i)

the

objective

is

to

determine

a

most

preferred

trade

for

each

bidder

at

these

prices.

Let

ˆλi

denote

the

solution

to

R-WD(i).

Check

condition:

vα

i

(ˆλi)

p∗

(ˆλ)

vα

i

(λt

i)

p∗

(λt

i)

δ∗

and

if

this

condition

holds

for

all

bidders

i,

then

solution

(p∗

δ∗

is

optimal

for

problem

Otherwise,

trade

ˆλi

is

added

to

i

for

all

bidders

i

for

which

this

constraint

is

violated

and

we

re-solve

the

LP

with

the

new

set

of

II:

Fairness.

Second,

we

break

remaining

ties

to

prefer

fair

prices:

choosing

prices

that

minimize

the

worst-case

error

with

respect

to

Threshold

payoffs

(i.e.

utility

to

bidders

with

Threshold

payments),

but

without

choosing

prices

that

are

less

Example

For

example,

accuracy

in

Example

(depicted

in

Figure

requires

pA

+pB

(for

vα

v).

At

these

valuations

the

Threshold

payoffs

would

be

to

both

the

seller

and

the

buyer.

This

can

be

exactly

achieved

in

pricing

with

pA

pB

The

fairness

tie-breaking

method

is

formulated

as

the

following

LP:

min

p,π

π

[FAIR]

s.t.

vα

i

(λ)

p(λ)

vα

i

(λt

i)

p(λt

i)

δ∗

i

∀i,

∀λ

i

π

πvcg,i

(vα

i

(λt

i)

p(λt

i)),

∀i

π

∀j,

where

δ∗

represents

the

error

in

the

optimal

solution,

from

ACC.

The

objective

here

is

the

same

as

in

the

Threshold

payment

rule

(see

Section

minimize

the

maximal

error

between

bidder

payoff

(at

vα

for

the

provisional

trade

and

the

VCG

payoff

(at

vα

Problem

FAIR

is

also

solved

through

constraint

generation,

using

R-WD(i)

to

add

additional

violated

constraints

as

necessary.

III:

Balance.

Third,

we

break

remaining

ties

to

prefer

balanced

prices:

choosing

prices

that

minimize

the

maximal

price

across

all

items.

Returning

again

to

Example

depicted

in

Figure

we

see

that

accuracy

and

fairness

require

p(A)

p(B)

Finally,

balance

sets

p(A)

p(B)

Balance

is

justified

when,

all

else

being

equal,

items

are

more

likely

to

have

similar

than

dissimilar

The

LP

for

balance

is

formulated

as

follows:

min

p,Y

Y

[BAL]

s.t.

vα

i

(λ)

p(λ)

vα

i

(λt

i)

p(λt

i)

δ∗

i

∀i,

∀λ

i

π∗

i

πvcg,i

(vα

i

(λt

i)

p(λt

i)),

∀i,

Y

pj,

∀j

Y

pj

∀j,

where

δ∗

represents

the

error

in

the

optimal

solution

from

ACC

and

π∗

represents

the

error

in

the

optimal

solution

from

FAIR.

Constraint

generation

is

also

used

to

solve

BAL,

generating

new

trades

for

i

as

necessary.

Problem

R-WD(i)

is

a

specialization

of

the

WD

problem,

in

which

the

objective

is

to

maximize

the

payoff

of

a

single

bidder,

rather

than

the

total

value

across

all

bidders.

It

is

solved

as

a

MIP,

by

rewriting

the

objective

in

WD(T,

as

max{viβ

satiβ

j

p∗

j

λij

for

agent

i.

Thus,

the

structure

of

the

bid-tree

language

is

exploited

in

generating

new

constraints,

because

this

is

solved

as

a

concise

MIP.

The

other

bidders

are

kept

around

in

the

MIP

(but

do

not

appear

in

the

objective),

and

are

used

to

define

the

space

of

feasible

trades.

The

methods

of

Dunford

et

al.

that

use

a

nucleolus

approach,

are

also

closely

related.

The

use

of

balance

was

advocated

by

Kwasnica

et

al.

Dunford

et

al.

prefer

to

smooth

prices

across

rounds.

Comment

Lexicographical

Refinement.

For

all

three

sub-problems

we

also

perform

lexicographical

refinement

(with

respect

to

bidders

in

ACC

and

FAIR,

and

with

respect

to

goods

in

BAL).

For

instance,

in

ACC

we

successively

minimize

the

maximal

error

across

all

bidders.

Given

an

initial

solution

we

first

pin

down

the

error

on

all

bidders

for

whom

a

constraint

is

binding.

For

such

a

bidder

i,

the

constraint

is

replaced

with

vα

i

(λ)

p(λ)

vα

i

(λt

i)

p(λt

i)

δ∗

i

∀λ

i

and

the

error

to

bidder

i

no

longer

appears

explicitly

in

the

objective.

ACC

is

then

re-solved,

and

makes

progress

by

further

minimizing

the

maximal

error

across

all

bidders

yet

to

be

pinned

down.

This

continues,

pinning

down

any

new

bidders

for

whom

one

of

constraints

is

binding,

until

the

error

is

lexicographically

optimized

for

all

The

exact

same

process

is

repeated

for

FAIR

and

BAL,

with

bidders

pinned

down

and

constraints

replaced

with

π∗

i

πvcg,i

(vα

i

(λt

i)

p(λt

i)),

∀λ

i

(where

π∗

i

is

the

current

objective)

in

FAIR,

and

items

pinned

down

and

constraints

replaced

with

p∗

j

pj

(where

p∗

j

represents

the

target

for

the

maximal

price

on

that

item)

in

BAL.

Comment

Computation.

All

constraints

in

i

are

retained,

and

this

set

grows

across

all

stages

and

across

all

rounds

of

the

exchange.

Thus,

the

computational

effort

in

constraint

generation

is

re-used.

In

implementation

we

are

careful

to

address

a

number

of

-issues

that

arise

due

to

floating-point

issues.

We

prefer

to

err

on

the

side

of

being

conservative

in

determining

whether

or

not

to

add

another

constraint

in

performing

check

This

avoids

later

infeasibility

issues.

In

addition,

when

pinning-down

bidders

for

the

purpose

of

lexicographical

refinement

we

relax

the

associated

bidder-constraints

with

a

small

on

the

righthand

side.

Revealed-Preference

Activity

Rules

The

role

of

activity

rules

in

the

auction

is

to

ensure

both

consistency

and

progress

across

rounds

Consistency

in

our

exchange

requires

that

bidders

tighten

bounds

as

the

exchange

progresses.

Activity

rules

ensure

that

bidders

are

active

during

early

rounds,

and

promote

useful

elicitation

throughout

the

exchange.

We

adopt

a

simple

revealed-preference

(RP)

activity

rule.

The

idea

is

loosely

based

around

the

RP-rule

in

Ausubel

et

al.

where

it

is

used

for

one-sided

CAs.

The

motivation

is

to

require

more

than

simply

consistency:

we

need

bidders

to

provide

enough

information

for

the

system

to

be

able

to

to

prove

that

an

allocation

is

(approximately)

efficient.

It

is

helpful

to

think

about

the

bidders

interacting

with

proxy

agents

that

will

act

on

their

behalf

in

responding

to

provisional

prices

determined

at

the

end

of

round

t

The

only

knowledge

that

such

a

proxy

has

of

the

valuation

of

a

bidder

is

through

the

bid-tree.

Suppose

a

proxy

was

queried

by

the

exchange

and

asked

which

trade

the

bidder

was

most

interested

in

at

the

provisional

prices.

The

RP

rule

says

the

following:

the

proxy

must

have

enough

For

example,

applying

this

to

accuracy

on

Example

we

solve

once

and

find

bidders

and

are

binding,

for

error

δ∗

We

pin

these

down

and

then

minimize

the

error

to

bidders

and

Finally,

this

gives

p(A)

p(B)

and

p(C)

p(D)

with

accuracy

to

bidders

and

and

to

bidders

and

information

to

be

able

to

determine

this

surplus-maximizing

trade

at

current

prices.

Consider

the

following

examples:

Example

A

bidder

has

XOR(+A,

+B)

and

a

value

of

on

the

leaf

+A

and

a

value

range

of

on

leaf

+B.

Suppose

prices

are

currently

for

each

of

A

and

B.

The

RP

rule

is

satisfied

because

the

proxy

knows

that

however

the

remaining

value

uncertainty

on

+B

is

resolved

the

bidder

will

always

(weakly)

prefer

+B

to

+A.

Example

A

bidder

has

XOR(+A,

+B)

and

value

bounds

on

the

root

node

and

a

value

of

on

leaf

+A.

Suppose

prices

are

currently

for

each

of

A

and

B.

The

RP

rule

is

satisfied

because

the

bidder

will

always

prefer

+A

to

+B

at

equal

prices,

whichever

way

the

uncertain

value

on

the

root

node

is

ultimately

resolved.

Overloading

notation,

let

vi

Ti

denote

a

valuation

that

is

consistent

with

lower

and

upper

valuations

in

bid

tree

Ti.

Definition

Bid

tree

Ti

satisfies

RP

at

prices

if

and

only

if

there

exists

some

feasible

trade

L∗

for

which,

vi(L∗

i

(L∗

i

max

vi(λi)

(λi),

∀vi

Ti.

To

make

this

determination

for

bidder

i

we

solve

a

sequence

of

problems,

each

of

which

is

a

variation

on

the

WD

problem.

First,

we

construct

a

candidate

lower-bound

trade,

which

is

a

feasible

trade

that

solves:

max

λ

vi(λi)

(λi)

s.t.

λ

The

solution

π∗

l

to

represents

the

maximal

payoff

that

bidder

i

can

achieve

across

all

feasible

trades,

given

its

pessimistic

valuation.

Second,

we

break

ties

to

find

a

trade

with

maximal

value

uncertainty

across

all

possible

solutions

to

max

λ

vi(λi)

vi(λi)

s.t.

λ

vi(λi)

(λi)

π∗

l

We

adopt

solution

L∗

i

as

our

candidate

for

the

trade

that

may

satisfy

RP.

To

understand

the

importance

of

this

tiebreaking

rule

consider

Example

The

proxy

can

prove

+B

but

not

+A

is

a

best-response

for

all

vi

Ti,

and

should

choose

+B

as

its

candidate.

Notice

that

+B

is

a

counterexample

to

+A,

but

not

the

other

way

round.

Now,

we

construct

a

modified

valuation

˜vi,

by

setting

˜viβ

viβ

if

β

sat(L∗

i

viβ

otherwise.

where

sat(L∗

i

is

the

set

of

nodes

that

are

satisfied

in

the

lower-bound

tree

for

trade

L∗

i

Given

this

modified

valuation,

we

find

U∗

to

solve:

max

λ

˜vi(λi)

(λi)

s.t.

λ

Let

π∗

u

denote

the

payoff

from

this

optimal

trade

at

modified

values

˜v.

We

call

trade

U∗

i

the

witness

trade.

We

show

in

Proposition

that

the

RP

rule

is

satisfied

if

and

only

if

π∗

l

π∗

u.

Constructing

the

modified

valuation

as

˜vi

recognizes

that

there

is

shared

uncertainty

across

trades

that

satisfy

the

same

nodes

in

a

bid

tree.

Example

helps

to

illustrate

this.

Just

using

vi

in

we

would

find

L∗

i

is

buy

A

with

payoff

π∗

l

but

then

find

U∗

i

is

buy

B

with

π∗

u

and

fail

RP.

We

must

recognize

that

however

the

uncertainty

on

the

root

node

is

resolved

it

will

affect

+A

and

+B

in

exactly

the

same

way.

For

this

reason,

we

set

˜viβ

viβ

on

the

root

node,

which

is

exactly

the

same

value

that

was

adopted

in

determining

π∗

l

Then,

applied

to

U∗

i

gives

buy

A

and

the

RP

test

is

judged

to

be

passed.

Proposition

Bid

tree

Ti

satisfies

RP

given

prices

if

and

only

if

any

lower-bound

trade

L∗

i

that

solves

and

satisfies:

vi(Ti,

L∗

i

(L∗

i

˜vi(Ti,

U∗

i

(U∗

i

where

˜vi

is

the

modified

valuation

in

Eq.

Proof.

For

sufficiency,

notice

that

the

difference

in

payoff

between

trade

L∗

i

and

another

trade

λi

is

unaffected

by

the

way

uncertainty

is

resolved

on

any

node

that

is

satisfied

in

both

L∗

i

and

λi.

Fixing

the

values

in

˜vi

on

nodes

satisfied

in

L∗

i

has

the

effect

of

removing

this

consideration

when

a

trade

U∗

i

is

selected

that

satisfies

one

of

these

nodes.

On

the

other

hand,

fixing

the

values

on

these

nodes

has

no

effect

on

trades

considered

in

that

do

not

share

a

node

with

L∗

i

For

the

necessary

direction,

we

first

show

that

any

trade

that

satisfies

RP

must

solve

Suppose

otherwise,

that

some

λi

with

payoff

greater

than

π∗

l

satisfies

RP.

But,

valuation

vi

Ti

together

with

L∗

i

presents

a

counterexample

to

RP

(Eq.

Now,

suppose

(for

contradiction)

that

some

λi

with

maximal

payoff

π∗

l

but

uncertainty

less

than

L∗

i

satisfies

RP.

Proceed

by

case

analysis.

Case

a):

only

one

solution

to

has

uncertain

value

and

so

λi

has

certain

value.

But,

this

cannot

satisfy

RP

because

L∗

i

with

uncertain

value

would

be

a

counterexample

to

RP

(Eq.

Case

b):

two

or

more

solutions

to

have

uncertain

value.

Here,

we

first

argue

that

one

of

these

trades

must

satisfy

a

(weak)

superset

of

all

the

nodes

with

uncertain

value

that

are

satisfied

by

all

other

trades

in

this

set.

This

is

by

RP.

Without

this,

then

for

any

choice

of

trade

that

solves

there

is

another

trade

with

a

disjoint

set

of

uncertain

but

satisfied

nodes

that

provides

a

counterexample

to

RP

(Eq.

Now,

consider

the

case

that

some

trade

contains

a

superset

of

all

the

uncertain

satisfied

nodes

of

the

other

trades.

Clearly

will

choose

this

trade,

L∗

i

and

λi

must

satisfy

a

subset

of

these

nodes

(by

assumption).

But,

we

now

see

that

λi

cannot

satisfy

RP

because

L∗

i

would

be

a

counterexample

to

RP.

Failure

to

meet

the

activity

rule

must

have

some

consequence.

In

the

current

rules,

the

default

action

we

choose

is

to

set

the

upper

bounds

in

valuations

down

to

the

maximal

value

of

the

provisional

price

on

a

and

the

lowerbound

value

on

that

Such

a

bidder

can

remain

active

The

provisional

price

on

a

node

is

defined

as

the

minimal

total

price

across

all

feasible

trades

for

which

the

subtree

rooted

at

the

tree

is

satisfied.

This

is

entirely

analogous

to

when

a

bidder

in

an

ascending

clock

auction

stops

bidding

at

a

price:

she

is

not

permitted

to

bid

at

a

higher

price

again

in

future

rounds.

within

the

exchange,

but

only

with

valuations

that

are

consistent

with

these

new

bounds.

Bidder

Feedback

In

each

round,

our

default

design

provides

every

bidder

with

the

provisional

trade

and

also

with

the

current

provisional

prices.

See

for

an

additional

discussion.

We

also

provide

guidance

to

help

a

bidder

meet

the

RP

rule.

Let

sat(L∗

i

and

sat(U∗

i

denote

the

nodes

that

are

satisfied

in

trades

L∗

i

and

U∗

i

as

computed

in

Lemma

When

RP

fails,

a

bidder

must

increase

a

lower

bound

on

at

least

one

node

in

sat(L∗

i

sat(U∗

i

or

decrease

an

upper

bound

on

at

least

one

node

in

sat(U∗

i

sat(L∗

i

in

order

to

meet

the

activity

rule.

Proof.

Changing

the

upper-

or

lower-

values

on

nodes

that

are

not

satisfied

by

either

trade

does

not

change

L∗

i

or

U∗

i

and

does

not

change

the

payoff

from

these

trades.

Thus,

the

RP

condition

will

continue

to

fail.

Similarly,

changing

the

bounds

on

nodes

that

are

satisfied

in

both

trades

has

no

effect

on

revealed

preference.

A

change

to

a

lower

bound

on

a

shared

node

affects

both

L∗

i

and

U∗

i

identically

because

of

the

use

of

the

modified

valuation

to

determine

U∗

i

A

change

to

an

upper

bound

on

a

shared

node

has

no

effect

in

determining

either

L∗

i

or

U∗

i

Note

that

when

sat(U∗

i

sat(L∗

i

then

condition

is

always

trivially

satisfied,

and

so

the

guidance

in

the

lemma

is

always

well-defined

when

RP

fails.

This

is

an

elegant

feedback

mechanism

because

it

is

adaptive.

Once

a

bidder

makes

some

changes

on

some

subset

of

these

nodes,

the

bidder

can

query

the

exchange.

The

exchange

can

then

respond

yes,

or

can

revise

the

set

of

nodes

sat(λ∗

l

and

sat(λ∗

u)

as

necessary.

Termination

Conditions

Once

each

bidder

has

committed

its

new

bids

(and

either

met

the

RP

rule

or

suffered

the

penalty)

then

round

t

closes.

At

this

point,

the

task

is

to

determine

the

new

α-valuation,

and

in

turn

the

provisional

allocation

λt

and

provisional

prices

pt

A

termination

condition

is

also

checked,

to

determine

whether

to

move

the

exchange

to

a

last-and-final

round.

To

define

the

α-valuation

we

compute

the

following

two

quantities:

Pessimistic

at

Pessimistic

(PP)

Determine

an

efficient

trade,

λ∗

l

at

pessimistic

values,

i.e.

to

solve

maxλ

i

vi(λi),

and

set

PP=

i

vi(λ∗

li).

Pessimistic

at

Optimistic

(PO)

Determine

an

efficient

trade,

λ∗

u,

at

optimistic

values,

i.e.

to

solve

maxλ

i

vi(λi),

and

set

PO=

i

vi(λ∗

ui).

First,

note

that

PP

PO

and

PP

by

definition,

for

all

bid-trees,

although

PO

can

be

negative

(because

the

right

trade

at

v

is

not

currently

a

useful

trade

at

v).

Recognizing

this,

define

γeff

(PP,

PO)

PP

PO

PP

when

PP

and

observe

that

γeff

(PP,

PO)

when

this

is

defined,

and

that

γeff

(PP,

PO)

will

start

large

and

then

trend

towards

as

the

optimistic

allocation

converges

towards

the

pessimistic

allocation.

In

each

round,

we

define

αeff

as:

αeff

when

PP

is

otherwise

which

is

while

PP

is

and

then

trends

towards

once

PP>

in

some

round.

This

is

used

to

define

α-valuation

vα

i

αeff

vi

αeff

)vi,

∀i,

which

is

used

to

define

the

provisional

allocation

and

provisional

prices.

The

effect

is

to

endogenously

define

a

schedule

for

moving

from

optimistic

to

pessimistic

values

across

rounds,

based

on

how

close

the

trades

are

to

one

another.

Termination

Condition.

In

moving

to

the

last-and-final

round,

and

finally

closing,

we

also

care

about

the

convergence

of

payments,

in

addition

to

the

convergence

towards

an

efficient

trade.

For

this

we

introduce

another

parameter,

αthresh

that

trends

from

to

as

the

Threshold

payments

at

lower

and

upper

valuations

converge.

Consider

the

following

parameter:

γthresh

||pthresh(v)

(PP/Nactive)

which

is

defined

for

PP

where

pthresh(v)

denotes

the

Threshold

payments

at

valuation

profile

v,

Nactive

is

the

number

of

bidders

that

are

actively

engaged

in

trade

in

the

PP

trade,

and

is

the

Note

that

γthresh

is

defined

for

payments

and

not

payoffs.

This

is

appropriate

because

it

is

the

accuracy

of

the

outcome

of

the

exchange

that

matters:

i.e.

the

trade

and

the

payments.

Given

this,

we

define

αthresh

when

PP

is

otherwise

which

is

while

PP

is

and

then

trends

towards

as

progress

is

made.

Definition

(termination).

ICE

transitions

to

a

lastand-final

round

when

one

of

the

following

holds:

αeff

CUTOFFeff

and

αthresh

CUTOFFthresh,

there

is

no

trade

at

the

optimistic

values,

where

CUTOFFeff

CUTOFFthresh

determine

the

accuracy

required

for

termination.

At

the

end

of

the

last-and-final

round

vα

v

is

used

to

define

the

final

trade

and

the

final

Threshold

payments.

Example

Consider

again

Example

and

consider

the

upper

and

lower

bounds

as

depicted

in

Figure

First,

if

the

seller"s

bounds

were

then

there

is

an

optimistic

trade

but

no

pessimistic

trade,

and

PO

−4

and

PP

and

αeff

At

the

bounds

depicted,

both

the

optimistic

and

the

pessimistic

trades

occur

and

PO

PP

and

αeff

However,

we

can

see

the

Threshold

payments

are

at

v

but

at

v.

Evaluating

γthresh

we

have

γthresh

and

αthresh

For

CUTOFFthresh

the

exchange

would

remain

open.

On

the

other

hand,

if

the

buyer"s

value

for

+AB

was

between

and

the

seller"s

value

for

−AB

was

between

the

Threshold

payments

are

at

both

upper

and

lower

bounds,

and

αthresh

Component

Purpose

Lines

Agent.

Captures

strategic

behavior

and

information

revelation

decisions

Model

Support

Provides

XML

support

to

load

goods

and

valuations

into

world

World

Keeps

track

of

all

agent,

good,

and

valuation

details

Exchange

Driver

Communication

Controls

exchange,

and

coordinates

remote

agent

behavior

Bidding

Language

Implements

the

tree-based

bidding

language

Activity

Rule

Engine

Implements

the

revealed

preference

rule

with

range

support

Closing

Rule

Engine

Checks

if

auction

termination

condition

reached

WD

Engine

Provides

WD-related

logic

Pricing

Engine

Provides

Pricing-related

logic

MIP

Builders

Translates

logic

used

by

engines

into

our

general

optimizer

formulation

Pricing

Builders

Used

by

three

pricing

stages

Winner

Determination

Builders

Used

by

WD,

activity

rule,

closing

rule,

and

pricing

constraint

generation

Framework

Support

code;

eases

modular

replacement

of

above

components

Table

Exchange

Component

and

Code

Breakdown.

SYSTEMS

INFRASTRUCTURE

ICE

is

approximately

lines

of

Java

code,

broken

up

into

the

functional

packages

described

in

Table

The

prototype

is

modular

so

that

researchers

may

easily

replace

components

for

experimentation.

In

addition

to

the

core

exchange

discussed

in

this

paper,

we

have

developed

an

agent

component

that

allows

a

user

to

simulate

the

behavior

and

knowledge

of

other

players

in

the

system,

better

allowing

a

user

to

formulate

their

strategy

in

advance

of

actual

play.

A

user

specifies

a

valuation

model

in

an

XMLinterpretation

of

our

bidding

language,

which

is

revealed

to

the

exchange

via

the

agent"s

strategy.

Major

exchange

tasks

are

handled

by

engines

that

dictate

the

non-optimizer

specific

logic.

These

engines

drive

the

appropriate

MIP/LP

builders.

We

realized

that

all

of

our

optimization

formulations

boil

down

to

two

classes

of

optimization

problem.

The

first,

used

by

winner

determination,

activity

rule,

closing

rule,

and

constraint

generation

in

pricing,

is

a

MIP

that

finds

trades

that

maximize

value,

holding

prices

and

slacks

constant.

The

second,

used

by

the

three

pricing

stages,

is

an

LP

that

holds

trades

constant,

seeking

to

minimize

slack,

profit,

or

prices.

We

take

advantage

of

the

commonality

of

these

problems

by

using

common

LP/MIP

builders

that

differ

only

by

a

few

functional

hooks

to

provide

the

correct

variables

for

optimization.

We

have

generalized

our

back-end

optimization

solver

(we

currently

support

CPLEX

and

the

LGPL-

licensed

LPSolve),

and

can

take

advantage

of

the

load-balancing

and

parallel

MIP/LP

solving

capability

that

this

library

provides.

DISCUSSION

The

bidding

language

was

defined

to

allow

for

perfect

symmetry

between

buyers

and

sellers

and

provide

expressiveness

in

an

exchange

domain,

for

instance

for

mixed

bidders

interested

in

executing

trades

such

as

swaps.

This

proved

especially

challenging.

The

breakthrough

came

when

we

focused

on

changes

in

value

for

trades

rather

than

providing

absolute

values

for

allocations.

For

simplicity,

we

require

the

same

tree

structure

for

both

the

upper

and

lower

valuations.

Code

size

is

measured

in

physical

source

line

of

code

(SLOC),

as

generated

using

David

A.

Wheeler"s

SLOC

Count.

The

total

of

includes

for

instrumentation

(not

shown

in

the

table).

The

JOpt

solver

interface

is

another

lines,

and

Castor

automatically

generates

around

lines

of

code

for

XML

file

manipulation.

This

allows

the

language

itself

to

ensure

consistency

(with

the

upper

value

at

least

the

lower

value

on

all

trades)

and

enforce

monotonic

tightening

of

these

bounds

for

all

trades

across

rounds.

It

also

provides

for

an

efficient

method

to

check

the

RP

activity

rule,

because

it

makes

it

simple

to

reason

about

shared

uncertainty

between

trades.

The

decision

to

adopt

a

direct

and

proxied

approach

in

which

bidders

express

their

upper

and

lower

values

to

a

trusted

proxy

agent

that

interacts

with

the

exchange

was

made

early

in

the

design

process.

In

many

ways

this

is

the

clearest

and

most

immediate

way

to

generalize

the

design

in

Parkes

et

al.

and

make

it

iterative.

In

addition,

this

removes

much

opportunity

for

strategic

manipulation:

bidders

are

restricted

to

making

(incremental)

statements

about

their

valuations.

Another

advantage

is

that

it

makes

the

activity

rule

easy

to

explain:

bidders

can

always

meet

the

activity

rule

by

tightening

bounds

such

that

their

true

value

remains

in

the

Perhaps

most

importantly,

having

explicit

information

on

upper

and

lower

values

permits

progress

in

early

rounds,

even

while

there

is

no

efficient

trade

at

pessimistic

values.

Upper

and

lower

bound

information

also

provides

guidance

about

when

to

terminate.

Note

that

taken

by

itself,

PP

PO

does

not

imply

that

the

current

provisional

trade

is

efficient

with

respect

to

all

values

consistent

with

current

value

information.

The

difference

in

values

between

different

trades,

aggregated

across

all

bidders,

could

be

similar

at

lower

and

upper

bounds

but

quite

different

at

intermediate

values

(including

truth).

Nevertheless,

we

conjecture

that

PP

PO

will

prove

an

excellent

indicator

of

efficiency

in

practical

settings

where

the

shape

of

the

upper

and

lower

valuations

does

convey

useful

information.

This

is

worthy

of

experimental

investigation.

Moreover,

the

use

of

price

and

RP

activity

provides

additional

guarantees.

We

adopted

linear

prices

(prices

on

individual

items)

rather

than

non-linear

prices

(with

prices

on

a

trade

not

equal

to

the

sum

of

the

prices

on

the

component

items)

early

in

the

design

process.

The

conciseness

of

this

price

representation

is

very

important

for

computational

tractability

within

the

exchange

and

also

to

promote

simplicity

and

transparency

for

bidders.

The

RP

activity

rule

was

adopted

later,

and

is

a

good

choice

because

of

its

excellent

theoretical

properties

when

coupled

with

CE

prices.

The

following

can

be

easily

established:

given

exact

CE

prices

for

provisional

trade

This

is

in

contrast

to

indirect

price-based

approaches,

such

as

clock-proxy

in

which

bidders

must

be

able

to

reason

about

the

RP-constraints

implied

by

bids

in

each

round.

λt−1

at

valuations

vα

then

if

the

upper

and

lower

values

at

the

start

of

round

t

already

satisfy

the

RP

rule

(and

without

the

need

for

any

tie-breaking),

the

provisional

trade

is

efficient

for

all

valuations

consistent

with

the

current

bid

trees.

When

linear

CE

prices

exist,

this

provides

for

a

soundness

and

completeness

statement:

if

PP

PO,

linear

CE

prices

exist,

and

the

RP

rule

is

satisfied,

the

provisional

trade

is

efficient

(soundness);

if

prices

are

exact

CE

prices

for

the

provisional

trade

at

vα

but

the

trade

is

inefficient

with

respect

to

some

valuation

profile

consistent

with

the

current

bid

trees,

then

at

least

one

bidder

must

fail

RP

with

her

current

bid

tree

and

progress

will

be

made

(completeness).

Future

work

must

study

convergence

experimentally,

and

extend

this

theory

to

allow

for

approximate

prices.

Some

strategic

aspects

of

our

ICE

design

deserve

comment,

and

further

study.

First,

we

do

not

claim

that

truthfully

responding

to

the

RP

rule

is

an

ex

post

However,

the

exchange

is

designed

to

mimic

the

Threshold

rule

in

its

payment

scheme,

which

is

known

to

have

useful

incentive

properties

We

must

be

careful,

though.

For

instance

we

do

not

suggest

to

provide

αeff

to

bidders,

because

as

αeff

approaches

it

would

inform

bidders

that

bid

values

are

becoming

irrelevant

to

determining

the

trade

but

merely

used

to

determine

payments

(and

bidders

would

become

increasingly

reluctant

to

increase

their

lower

valuations).

Also,

no

consideration

has

been

given

in

this

work

to

collusion

by

bidders.

This

is

an

issue

that

deserves

some

attention

in

future

work.

CONCLUSIONS

In

this

work

we

designed

and

prototyped

a

scalable

and

highly-expressive

iterative

combinatorial

exchange.

The

design

includes

many

interesting

features,

including:

a

new

bid-tree

language

for

exchanges,

a

new

method

to

construct

approximate

linear

prices

from

expressive

languages,

and

a

proxied

elicitation

method

with

optimistic

and

pessimistic

valuations

with

a

new

method

to

evaluate

a

revealed-

preference

activity

rule.

The

exchange

is

fully

implemented

in

Java

and

is

in

a

validation

phase.

The

next

steps

for

our

work

are

to

allow

bidders

to

refine

the

structure

of

the

bid

tree

in

addition

to

values

on

the

tree.

We

intend

to

study

the

elicitation

properties

of

the

exchange

and

we

have

put

together

a

test

suite

of

exchange

problem

instances.

In

addition,

we

are

beginning

to

engage

in

collaborations

to

apply

the

design

to

airline

takeoff

and

landing

slot

scheduling

and

to

resource

allocation

in

widearea

network

distributed

computational

systems.

Acknowledgments

We

would

like

to

dedicate

this

paper

to

all

of

the

participants

in

CS

at

Harvard

University

in

Spring

This

work

is

supported

in

part

by

NSF

grant

REFERENCES

L.

Ausubel,

P.

Cramton,

and

P.

Milgrom.

The

clock-proxy

auction:

A

practical

combinatorial

auction

design.

In

Cramton

et

al.

chapter

M.

Babaioff,

N.

Nisan,

and

E.

Pavlov.

Mechanisms

for

a

spatially

distributed

market.

In

Proc.

ACM

Conf.

on

Electronic

Commerce,

pages

ACM

Press,

Given

the

Myerson-Satterthwaite

impossibility

theorem

and

the

method

by

which

we

determine

the

trade

we

should

not

expect

this.

M.

Ball,

G.

Donohue,

and

K.

Hoffman.

Auctions

for

the

safe,

efficient,

and

equitable

allocation

of

airspace

system

resources.

In

S.

Cramton,

Shoham,

editor,

Combinatorial

Auctions.

Forthcoming.

D.

Bertsimas

and

J.

Tsitsiklis.

Introduction

to

Linear

Optimization.

Athena

Scientific,

S.

Bikhchandani

and

J.

M.

Ostroy.

The

package

assignment

model.

Journal

of

Economic

Theory,

C.

Boutilier.

A

pomdp

formulation

of

preference

elicitation

problems.

In

Proc.

National

Conference

on

Artificial

Intelligence

C.

Boutilier

and

H.

Hoos.

Bidding

languages

for

combinatorial

auctions.

In

Proc.

International

Joint

Conference

on

Artificial

Intelligence

W.

Conen

and

T.

Sandholm.

Preference

elicitation

in

combinatorial

auctions.

In

Proc.

ACM

Conf.

on

Electronic

Commerce

pages

ACM

Press,

New

York,

P.

Cramton,

Y.

Shoham,

and

R.

Steinberg,

editors.

Combinatorial

Auctions.

MIT

Press,

S.

de

Vries,

J.

Schummer,

and

R.

V.

Vohra.

On

ascending

Vickrey

auctions

for

heterogeneous

objects.

Technical

report,

MEDS,

Kellogg

School,

Northwestern

University,

S.

de

Vries

and

R.

V.

Vohra.

Combinatorial

auctions:

A

survey.

Informs

Journal

on

Computing,

M.

Dunford,

K.

Hoffman,

D.

Menon,

R.

Sultana,

and

T.

Wilson.

Testing

linear

pricing

algorithms

for

use

in

ascending

combinatorial

auctions.

Technical

report,

SEOR,

George

Mason

University,

Y.

Fu,

J.

Chase,

B.

Chun,

S.

Schwab,

and

A.

Vahdat.

Sharp:

an

architecture

for

secure

resource

peering.

In

Proceedings

of

the

nineteenth

ACM

symposium

on

Operating

systems

principles,

pages

ACM

Press,

B.

Hudson

and

T.

Sandholm.

Effectiveness

of

query

types

and

policies

for

preference

elicitation

in

combinatorial

auctions.

In

Proc.

Int.

Joint.

Conf.

on

Autonomous

Agents

and

Multi

Agent

Systems,

pages

V.

Krishna.

Auction

Theory.

Academic

Press,

D.

Krych.

Calculation

and

analysis

of

Nash

equilibria

of

Vickrey-based

payment

rules

for

combinatorial

exchanges,

Harvard

College,

April

A.

M.

Kwasnica,

J.

O.

Ledyard,

D.

Porter,

and

C.

DeMartini.

A

new

and

improved

design

for

multi-object

iterative

auctions.

Management

Science,

To

appear.

E.

Kwerel

and

J.

Williams.

A

proposal

for

a

rapid

transition

to

market

allocation

of

spectrum.

Technical

report,

FCC

Office

of

Plans

and

Policy,

Nov

S.

M.

Lahaie

and

D.

C.

Parkes.

Applying

learning

algorithms

to

preference

elicitation.

In

Proc.

ACM

Conf.

on

Electronic

Commerce,

pages

R.

P.

McAfee.

A

dominant

strategy

double

auction.

J.

of

Economic

Theory,

P.

Milgrom.

Putting

auction

theory

to

work:

The

simultaneous

ascending

auction.

J.Pol.

Econ.,

R.

B.

Myerson

and

M.

A.

Satterthwaite.

Efficient

mechanisms

for

bilateral

trading.

Journal

of

Economic

Theory,

N.

Nisan.

Bidding

and

allocation

in

combinatorial

auctions.

In

Proc.

ACM

Conf.

on

Electronic

Commerce

pages

D.

C.

Parkes,

J.

R.

Kalagnanam,

and

M.

Eso.

Achieving

budget-balance

with

Vickrey-based

payment

schemes

in

exchanges.

In

Proc.

International

Joint

Conference

on

Artificial

Intelligence

pages

D.

C.

Parkes

and

L.

H.

Ungar.

Iterative

combinatorial

auctions:

Theory

and

practice.

In

Proc.

National

Conference

on

Artificial

Intelligence

pages

July

S.

J.

Rassenti,

V.

L.

Smith,

and

R.

L.

Bulfin.

A

combinatorial

mechanism

for

airport

time

slot

allocation.

Bell

Journal

of

Economics,

M.

H.

Rothkopf,

A.

Pekeˇc,

and

R.

M.

Harstad.

Computationally

manageable

combinatorial

auctions.

Management

Science,

T.

Sandholm

and

C.

Boutilier.

Preference

elicitation

in

combinatorial

auctions.

In

Cramton

et

al.

chapter

P.

R.

Wurman

and

M.

P.

Wellman.

AkBA:

A

progressive,

anonymous-price

combinatorial

auction.

In

Second

ACM

Conference

on

Electronic

Commerce,

pages

buyer and seller
tree-based bidding language
winner-determination

iterative combinatorial exchange
double auction
combinatorial auction
trade
price
bidding
threshold payment
combinatorial exchange
vcg
preference elicitation


Exchanging Reputation Values among Heterogeneous Agent Reputation Models: An Experience on ART Testbed Anarosa A. F. Brandão1 , Laurent Vercouter2 , Sara Casare1 and Jaime Sichman1 1 Laboratório de Técnicas Inteligentes - EP/USP Av. Prof. Luciano Gualberto, 158, trav. 3, 05508-970, São Paulo - Brazil +55 11 3091 5397 anarosabrandao@gmail.com, {sara.casare,jaime.sichman}@poli.usp.br 2 Ecole Nationale Supérieure des Mines de Saint-Etienne 158, cours Fauriel, 42023 Saint-Etienne Cedex 2, France Laurent.Vercouter@emse.fr ABSTRACT In open MAS it is often a problem to achieve agents' interoperability. The heterogeneity of its components turns the establishment of interaction or cooperation among them into a non trivial task, since agents may use different internal models and the decision about trust other agents is a crucial condition to the formation of agents' cooperation. In this paper we propose the use of an ontology to deal with this issue. We experiment this idea by enhancing the ART reputation model with semantic data obtained from this ontology. This data is used during interaction among heterogeneous agents when exchanging reputation values and may be used for agents that use different reputation models. Categories and Subject Descriptors I.2.11 [Distributed Artificial Intelligence]: Multiagent systems General Terms Design, Experimentation, Standardization. 1. INTRODUCTION Open multiagent systems (MAS) are composed of autonomous distributed agents that may enter and leave the agent society at their will because open systems have no centralized control over the development of its parts [1]. Since agents are considered as autonomous entities, we cannot assume that there is a way to control their internal behavior. These features are interesting to obtain flexible and adaptive systems but they also create new risks about the reliability and the robustness of the system. Solutions to this problem have been proposed by the way of trust models where agents are endowed with a model of other agents that allows them to decide if they can or cannot trust another agent. Such trust decision is very important because it is an essential condition to the formation of agents' cooperation. The trust decision processes use the concept of reputation as the basis of a decision. Reputation is a subject that has been studied in several works [4][5][8][9] with different approaches, but also with different semantics attached to the reputation concept. Casare and Sichman [2][3] proposed a Functional Ontology of Reputation (FORe) and some directions about how it could be used to allow the interoperability among different agent reputation models. This paper describes how the FORe can be applied to allow interoperability among agents that have different reputation models. An outline of this approach is sketched in the context of a testbed for the experimentation and comparison of trust models, the ART testbed [6]. 2. THE FUNCTIONAL ONTOLOGY OF REPUTATION (FORe) In the last years several computational models of reputation have been proposed [7][10][13][14]. As an example of research produced in the MAS field we refer to three of them: a cognitive reputation model [5], a typology of reputation [7] and the reputation model used in the ReGret system [9][10]. Each model includes its own specific concepts that may not exist in other models, or exist with a different name. For instance, Image and Reputation are two central concepts in the cognitive reputation model. These concepts do not exist in the typology of reputation or in the ReGret model. In the typology of reputation, we can find some similar concepts such as direct reputation and indirect reputation but there are some slight semantic differences. In the same way, the ReGret model includes four kinds of reputation (direct, witness, neighborhood and system) that overlap with the concepts of other models but that are not exactly the same. The Functional Ontology of Reputation (FORe) was defined as a common semantic basis that subsumes the concepts of the main reputation models. The FORe includes, as its kernel, the following concepts: reputation nature, roles involved in reputation formation and propagation, information sources for reputation, evaluation of reputation, and reputation maintenance. The ontology concept ReputationNature is composed of concepts such as IndividualReputation, GroupReputation and ProductReputation. Reputation formation and propagation involves several roles, played by the entities or agents that participate in those processes. The ontology defines the concepts ReputationProcess and ReputationRole. Moreover, reputation can be classified according to the origin of beliefs and opinions that can derive from several sources. The ontology defines the concept ReputationType which can be PrimaryReputation or SecondaryReputation. PrimaryReputation is composed of concepts ObservedReputation and DirectReputation and the concept SecondaryReputation is composed of concepts such as PropagatedReputation and CollectiveReputation. More details about the FORe can be found on [2][3]. 3. MAPPING THE AGENT REPUTATION MODELS TO THE FORe Visser et al [12] suggest three different ways to support semantic integration of different sources of information: a centralized approach, where each source of information is related to one common domain ontology; a decentralized approach, where every source of information is related to its own ontology; and a hybrid approach, where every source of information has its own ontology and the vocabulary of these ontologies are related to a common ontology. This latter organizes the common global vocabulary in order to support the source ontologies comparison. Casare and Sichman [3] used the hybrid approach to show that the FORe serves as a common ontology for several reputation models. Therefore, considering the ontologies which describe the agent reputation models we can define a mapping between these ontologies and the FORe whenever the ontologies use a common vocabulary. Also, the information concerning the mappings between the agent reputation models and the FORe can be directly inferred by simply classifying the resulting ontology from the integration of a given reputation model ontology and the FORe in an ontology tool with reasoning engine. For instance, a mapping between the Cognitive Reputation Model ontology and the FORe relates the concepts Image and Reputation to PrimaryReputation and SecondaryReputation from FORe, respectively. Also, a mapping between the Typology of Reputation and the FORe relates the concepts Direct Reputation and Indirect Reputation to PrimaryReputation and SecondaryReputation from FORe, respectively. Nevertheless, the concepts Direct Trust and Witness Reputation from the Regret System Reputation Model are mapped to PrimaryReputation and PropagatedReputation from FORe. Since PropagatedReputation is a sub-concept of SecondaryReputation, it can be inferred that Witness Reputation is also mapped to SecondaryReputation. 4. EXPERIMENTAL SCENARIOS USING THE ART TESTBED To exemplify the use of mappings from last section, we define a scenario where several agents are implemented using different agent reputation models. This scenario includes the agents" interaction during the simulation of the game defined by ART [6] in order to describe the ways interoperability is possible between different trust models using the FORe. 4.1 The ART testbed The ART testbed provides a simulation engine on which several agents, using different trust models, may run. The simulation consists in a game where the agents have to decide to trust or not other agents. The game"s domain is art appraisal, in which agents are required to evaluate the value of paintings based on information exchanged among other agents during agents" interaction. The information can be an opinion transaction, when an agent asks other agents to help it in its evaluation of a painting; or a reputation transaction, when the information required is about the reputation of another agent (a target) for a given era. More details about the ART testbed can be found in [6]. The ART common reputation model was enhanced with semantic data obtained from FORe. A general agent architecture for interoperability was defined [11] to allow agents to reason about the information received from reputation interactions. This architecture contains two main modules: the Reputation Mapping Module (RMM) which is responsible for mapping concepts between an agent reputation model and FORe; and the Reputation Reasoning Module (RRM) which is responsible for deal with information about reputation according to the agent reputation model. 4.2 Reputation transaction scenarios While including the FORe to the ART common reputation model, we have incremented it to allow richer interactions that involve reputation transaction. In this section we describe scenarios concerning reputation transactions in the context of ART testbed, but the first is valid for any kind of reputation transaction and the second is specific for the ART domain. 4.2.1 General scenario Suppose that agents A, B and C are implemented according to the aforementioned general agent architecture with the enhanced ART common reputation model, using different reputation models. Agent A uses the Typology of Reputation model, agent B uses the Cognitive Reputation Model and agent C uses the ReGret System model. Consider the interaction about reputation where agents A and B receive from agent C information about the reputation of agent Y. A big picture of this interaction is showed in Figure 2. ReGret Ontology (Y, value=0.8, witnessreputation) C Typol. Ontology (Y, value=0.8, propagatedreputation) A CogMod. Ontology (Y, value=0.8, reputation) B (Y, value=0.8, PropagatedReputation) (Y, value=0.8, PropagatedReputation) ReGret Ontology (Y, value=0.8, witnessreputation) C ReGret Ontology (Y, value=0.8, witnessreputation) ReGret Ontology (Y, value=0.8, witnessreputation) (Y, value=0.8, witnessreputation) C Typol. Ontology (Y, value=0.8, propagatedreputation) A Typol. Ontology (Y, value=0.8, propagatedreputation) Typol. Ontology (Y, value=0.8, propagatedreputation) (Y, value=0.8, propagatedreputation) A CogMod. Ontology (Y, value=0.8, reputation) B CogMod. Ontology (Y, value=0.8, reputation) CogMod. Ontology (Y, value=0.8, reputation) (Y, value=0.8, reputation) B (Y, value=0.8, PropagatedReputation) (Y, value=0.8, PropagatedReputation) (Y, value=0.8, PropagatedReputation) (Y, value=0.8, PropagatedReputation) Figure 1. Interaction about reputation The information witness reputation from agent C is treated by its RMM and is sent as PropagatedReputation to both agents. The corresponding information in agent A reputation model is propagated reputation and in agent B reputation model is reputation. The way agents A and B make use of the information depends on their internal reputation model and their RRM implementation. 1048 The Sixth Intl. Joint Conf. on Autonomous Agents and Multi-Agent Systems (AAMAS 07) 4.2.2 ART scenario Considering the same agents A and B and the art appraisal domain of ART, another interesting scenario describes the following situation: agent A asks to agent B information about agents it knows that have skill on some specific painting era. In this case agent A wants information concerning the direct reputation agent B has about agents that have skill on an specific era, such as cubism. Following the same steps of the previous scenario, agent A message is prepared in its RRM using information from its internal model. A big picture of this interaction is in Figure 2. Typol. Ontology (agent = ?, value = ?, skill = cubism, reputation = directreputation) A (agent = ?, value = ?, skill = cubism, reputation = PrimaryReputation) CogMod. Ontology (agent = ?, value = ?, skill = cubism, reputation = image) B Typol. Ontology (agent = ?, value = ?, skill = cubism, reputation = directreputation) A (agent = ?, value = ?, skill = cubism, reputation = PrimaryReputation) CogMod. Ontology (agent = ?, value = ?, skill = cubism, reputation = image) B Figure 2. Interaction about specific types of reputation values Agent B response to agent A is processed in its RRM and it is composed of tuples (agent, value, cubism, image) , where the pair (agent, value) is composed of all agents and associated reputation values whose agent B knows their expertise about cubism by its own opinion. This response is forwarded to the RMM in order to be translated to the enriched common model and to be sent to agent A. After receiving the information sent by agent B, agent A processes it in its RMM and translates it to its own reputation model to be analyzed by its RRM. 5. CONCLUSION In this paper we present a proposal for reducing the incompatibility between reputation models by using a general agent architecture for reputation interaction which relies on a functional ontology of reputation (FORe), used as a globally shared reputation model. A reputation mapping module allows agents to translate information from their internal reputation model into the shared model and vice versa. The ART testbed has been enriched to use the ontology during agent transactions. Some scenarios were described to illustrate our proposal and they seem to be a promising way to improve the process of building reputation just using existing technologies. 6. ACKNOWLEDGMENTS Anarosa A. F. Brandão is supported by CNPq/Brazil grant 310087/2006-6 and Jaime Sichman is partially supported by CNPq/Brazil grants 304605/2004-2, 482019/2004-2 and 506881/2004-1. Laurent Vercouter was partially supported by FAPESP grant 2005/02902-5. 7. REFERENCES [1] Agha, G. A. Abstracting Interaction Patterns: A Programming Paradigm for Open Distributed Systems, In (Eds) E. Najm and J.-B. Stefani, Formal Methods for Open Object-based Distributed Systems IFIP Transactions, 1997, Chapman Hall. [2] Casare,S. and Sichman, J.S. Towards a Functional Ontology of Reputation, In Proc of the 4th Intl Joint Conference on Autonomous Agents and Multi Agent Systems (AAMAS"05), Utrecht, The Netherlands, 2005, v.2, pp. 505-511. [3] Casare, S. and Sichman, J.S. Using a Functional Ontology of Reputation to Interoperate Different Agent Reputation Models, Journal of the Brazilian Computer Society, (2005), 11(2), pp. 79-94. [4] Castelfranchi, C. and Falcone, R. Principles of trust in MAS: cognitive anatomy, social importance and quantification. In Proceedings of ICMAS"98, Paris, 1998, pp. 72-79. [5] Conte, R. and Paolucci, M. Reputation in Artificial Societies: Social Beliefs for Social Order, Kluwer Publ., 2002. [6] Fullam, K.; Klos, T.; Muller, G.; Sabater, J.; Topol, Z.; Barber, S.;Rosenchein, J.; Vercouter, L. and Voss, M. A specification of the agent reputation and trust (art) testbed: experimentation and competition for trust in agent societies. In Proc. of the 4th Intl. Joint Conf on Autonomous Agents and Multiagent Systems (AAMAS"05), ACM, 2005, 512-158. [7] Mui, L.; Halberstadt, A.; Mohtashemi, M. Notions of Reputation in Multi-Agents Systems: A Review. In: Proc of 1st Intl. Joint Conf. on Autonomous Agents and Multi-agent Systems (AAMAS 2002), Bologna, Italy, 2002, 1, 280-287. [8] Muller, G. and Vercouter, L. Decentralized monitoring of agent communication with a reputation model. In Trusting Agents for Trusting Electronic Societies, LNCS 3577, 2005, pp. 144-161. [9] Sabater, J. and Sierra, C. ReGret: Reputation in gregarious societies. In Müller, J. et al (Eds) Proc. of the 5th Intl. Conf. on Autonomous Agents, Canada, 2001, ACM, 194-195. [10] Sabater, J. and Sierra, C. Review on Computational Trust and Reputation Models. In: Artificial Intelligence Review, Kluwer Acad. Publ., (2005), v. 24, n. 1, pp. 33 - 60. [11] Vercouter,L, Casare, S., Sichman, J. and Brandão, A. An experience on reputation models interoperability based on a functional ontology In Proc. of the 20th IJCAI, Hyderabad, India, 2007, pp.617-622. [12] Visser, U.; Stuckenschmidt, H.; Wache, H. and Vogele, T. Enabling technologies for inter-operability. In: In U. Visser and H. Pundt, Eds, Workshop on the 14th Intl Symp. of Computer Science for Environmental Protection, Bonn, Germany, 2000, pp. 35-46. [13] Yu, B. and Singh, M.P. An Evidential Model of Distributed Reputation Management. In: Proc. of the 1st Intl Joint Conf. on Autonomous Agents and Multi-agent Systems (AAMAS 2002), Bologna, Italy, 2002, part 1, pp. 294 - 301. [14] Zacharia, G. and Maes, P. Trust Management Through Reputation Mechanisms. In: Applied Artificial Intelligence, 14(9), 2000, pp. 881-907. The Sixth Intl. Joint Conf. on Autonomous Agents and Multi-Agent Systems (AAMAS 07) 1049

O B O O B I B O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O B I O O O O O O B O O O O O O O O O O O B O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O B O O O B O O O O O O O O O O O O O O O O O B O O O O O O B O O O O O O B O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O B I I I O O O O O O O O O O O O O B O O O B O O O O O O O O O O O O B O O O O O B O O O O O O O O O O O O O O O O O O O O B O O B I O O O B I I I O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O B I O O O O B O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O B I O O O O O O O O O B O O O O O O O O O B O O O O O O O O O B O O B O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O B I I I O O O O O O O O O O O O O O O B O O O O O O O O O O B O O O O B I O O O O O B O O B O B O O B O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O B O O O O O O O B O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O B O O O O O O O O O O O O B O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O B O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O B O O O O O O B I B O O O O O B O O O O O O O O O O O B I B O O O O O O O O B O O O O O O O O O O O O O O B O O O O O O O B O O B O O O O O O O O O O O B O O B O O O O B I O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O B O O O O B O O O O O O B I O B I O O O O O O O O O O B O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O B O O O O O O O O O O O O O B I O O O O O O O O B I O O O O O O O O O O B I O B O O O O O O O O O O O O O B O O O O O O O O B O O O O O O O O O O O O B I O O O O B O O O O O O O O O O O B O O O O B I O B O O O O O O O O O O B I O O O O O O O O O O B O O O O O O O O B O O O O O B I O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O B I O O B O O O O O O O B I O O O O O B I O O O O O O O O O O O O B O O O O O O O O O O O O B O O O O O O O O O O O O O O O B O O O O O B O O O O O B O O B O O O O O O O O B O O O O O B O O O O B O O O O O O O O B O O O O O B O O O O B O O O O O O O O B O O B O O B O O B O B O O B O O B O O O O O O O O O O O O O O O O O B O O O B O O O O O O O O O O O O O O O O O O O O O O B I O O B O O O O B I O B O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O B O O O O O O O O O O O O B O O O B O O O O O O O O O B O O O O B O O O O O O O O O B O O O O O O O O O O O O B O O O B O O O O O O O O O B O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O O B O O O O O B I O B O O O O O B I I I O O O O O O B I O B O O O O O O O O O O B I O O O O O O O O B I O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I I I O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I I I O O O O B O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O B B I O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B I O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O B O O O O B O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O O B O O B O O O O O O O O O O O O O O O O O O O O O O O

reputation value
multiagent system
autonomous distributed agent
art testb

heterogeneous agent
reputation model
interoperability
art testbed
reputation formation
agent architecture
functional ontology of reputation
reputation
trust
ontology