Preference Elicitation in Combinatorial Auctions: An Overview Tuomas Sandholm [For an overview, see review article by Sandholm

1
Preference Elicitation in Combinatorial
AuctionsAn OverviewTuomas SandholmFor an
overview, see review article by Sandholm
Boutilier in the textbook Combinatorial Auctions,
MIT Press 2006, posted on course home page
2
Setting

• Combinatorial auction m items for sale
• Private values auction, no allocative
  externalities
• So, each bidder i has value function, vi 2m ? R
• Free disposal
• Unique valuations (to ease presentation)

3
Another complex problem in combinatorial
auctions Revelation problem

• In direct-revelation mechanisms (e.g. VCG),
  bidders bid on all 2items combinations
• Need to compute the valuation for exponentially
  many combinations
• Each valuation computation can be NP-complete
  local planning problem
• For example if a carrier company bids on trucking
  tasks TRACONET Sandholm AAAI-93,
• Need to communicate the bids
• Need to reveal the bids
• Loss of privacy strategic info

4
Revelation problem

• Agents need to decide what to bid on
• Waste effort on counter-speculation
• Waste effort making losing bids
• Fail to make bids that would have won
• Reduces economic efficiency revenue

5
What info is needed from an agent depends on what
others have revealed
Elicitor
Clearing algorithm
Elicitor decides what to ask next based on
answers it has received so far
Conen Sandholm IJCAI-01 workshop on Econ.
Agents, Models Mechanisms, ACMEC-01
6
Elicitor skeleton

• Repeat
• Decide what to ask (and from which bidder)
• Ask that and propagate the answer in data
  structures
• Check whether you know the optimal allocation of
  items to agents. If so, stop

7
Incentive to answer elicitors queries truthfully

• Elicitors queries leak information across agents
• Thrm. Nevertheless, answering truthfully can be
  made an ex post equilibrium ConenSandholm
  ACMEC-01
• Elicit enough to determine optimal allocation
  overall, and for each agent removed in turn
• Use VCG pricing
• Push-pull mechanism
• If a bidder can endogenously decide which bundles
  for which bidders to evaluate, then no nontrivial
  mechanism even a direct revelation mechanisms -
  can 1) be truth-promoting, and 2) avoid
  motivating an agent to compute on someone elses
  valuation(s) LarsonSandholm AAMAS-05

8
First generation of elicitors

• Rank lattice based elicitors

Conen Sandholm IJCAI-01 workshop, ACMEC-01,
AAAI-02, AMEC-02
9
Rank Lattice
Rank of Bundle Ø A B AB for Agent 1
4 2 3 1 for Agent 2 4
3 2 1
1,1
1,2
2,1
3,1
2,2
1,3
2,3
3,2
1,4
4,1
2,4
3,3
4,2
3,4
4,3
4,4
Infeasible
Feasible
Dominated
10
A search algorithm for the rank lattice

• Algorithm PAR PAReto optimal
• OPEN ? (1,...,1)
• while OPEN ? do
• Remove(c,OPEN) SUC ? suc(c)
• if Feasible(c) then
• PAR ? PAR ? c Remove(SUC,OPEN)
• else foreach node ? SUC do
• if node ? OPEN and Undominated(node,PAR)
• then Append(node,OPEN)
• Thrm. Finds all feasible Pareto-undominated
  allocations (if bidders utility functions are
  injective, i.e., no ties)
• Welfare maximizing solution(s) can be selected as
  a post-processor by evaluating those allocations
  
• Call this hybrid algorithm MPAR (for maximizing
  PAR)

11
Value-Augmented Rank Lattice
Value of Bundle Ø A B AB for Agent 1
0 4 3 8 for Agent 2 0 1 6 9
17
1,1
14
13
1,2
2,1
10
12
9
3,1
2,2
1,3
8
9
2,3
3,2
1,4
4,1
2,4
3,3
4,2
3,4
4,3
4,4
12
Search algorithm family for the value-augmented
rank lattice

• Algorithm EBF Efficient Best First
• OPEN ? (1,...,1)
• loop
• if OPEN 1 then c ? combination in OPEN
• else
• M ? k ? OPEN v(k) maxnode ? OPEN v(node)
• if M ? 1 ? ?node ? M with Feasible(node) then
  return node
• else choose c ? M such that c is not dominated
  by any node ? M
• OPEN ? OPEN \ c
• if Feasible(c) then return c
• else foreach node ? suc(c) do
• if node ? OPEN then OPEN ? OPEN ? node
• Thrm. Any EBF algorithm finds a welfare
  maximizing allocation
• Thrm. VCG payments can be determined from the
  information already elicited

13
Best worst case elicitation effort

• Best case rank vector (1,...,1) is feasible
• One bundle query to each agent, no value queries
• VCG payments are all 0
• Thrm. Any EBF algorithm requires at worst
  (2items bidders biddersitems)/2 1 value
  queries
• Proof idea. Upper part of the lattice is
  infeasible and not less in value than the
  solution
• Not surprising because in the worst case, finding
  a provably (even approximately) optimal
  allocation requires exponentially many bits to be
  communicated no matter what query types are used
  and what query policy is used NisanSegal J.
  Economic Theory 2006
• We will prove this later

14
EBF minimizes feasibility checks

• Def An algorithm is admissible if it always
  finds a welfare maximizing allocation
• Def An algorithm is admissibly equipped if it
  only has
• value queries, and
• a feasibility function on rank vectors, and
• a successor function on rank vectors
• Thrm There is no admissible, admissibly equipped
  algorithm that requires fewer feasibility checks
  (for every problem instance) than an (arbitrary)
  EBF algorithm

15
MPAR minimizes value queries

• Thrm. No admissible, admissibly equipped
  algorithm (that calls the valuation function for
  bundles in feasible rank vectors only) will
  require fewer value queries than MPAR
• MPAR requires at most biddersitems value queries

16
Rank lattice based elicitation

• Go down the rank lattice in best-first order (
  EBF)
• Performance not as good as value-based why?
• nodes in rank lattice is 2agents items
• feasible nodes is only agentsitems

queries
queries
80
1000
Full revelation
60
100
40
Queries
10
20
1
2
3
4
5
6
4
6
8
2
10
12
agents
items
17
Differential-revelation

• Extension of EBF
• Information elicited differences between
  valuations
• Hides sensitive value information
• Motivation max ? vi(Xi) ? min ? vi(r-1(1))
  vi(Xi)
• Maximizing sum of value ? Minimizing difference
  between value of best ranked bundle and bundle in
  the allocation
• Thrm. Differences suffice for determining welfare
  maximizing allocations VCG payments
• 2 low-revelation incremental ex post incentive
  compatible mechanisms ...

18
Differential elicitation ...

• Questions (start at rank 1)
• tell me the bundle at the current rank
• tell me the difference in value of that bundle
  and the best bundle
• increment rank
• Natural sequence from good to bad bundles

19
Differential elicitation ...

• Variation Bitwise decrement mechanism
• Is the difference in value between the best
  bundle and the bundle at the current rank greater
  than d?
• if yes increment d, requires min. Increment
• allows establishing a bit stream (yes/no
  answers)

20
Differential-revelation Algorithm

• Like EBF algorithms, except in step 3,
  determination of the set of combinations that are
  considered for expansion
• M k?OPEN Tight(k) ? ?k ?d for all d with
  Tight(d) ? ?k lt ?d for all d with Not(Tight(d))

21
Differential-revelation Theoretical results

• Any algortihm of the modified EBF family finds a
  welfare-maximizing feasible allocation
• Given an arbitrary subset of rank lattice nodes,
  the set M is the same whether the original EBF or
  the differential-revelation EBF is used
• No additional revelation is needed to determine
  the VCG payments

22
Policy-independent elicitor algorithms
23
Some of our elicitors query types

• Order information Which bundle do you prefer, A
  or B?
• Value information What is your valuation for
  bundle A? (Answer Exact or Bounds)
• Rank information
• What is the rank of bundle b?
• What bundle is at rank x?
• Given bundle b, what is the next lower (higher)
  ranked bundle?

24
Interrogation An Example
Questions of the Auctioneer Answers of the
Agents

1. a1,a2 Give me your highest ranking bundle
2. a1,a2 Give me your next best bundle
3. a1 Give me your valuation for AB and Aa2 Give
   me your valuation for AB and B

• a1 AB, a2 AB(not feasible)
• a1 A, a2 B(feasible)
• a1 vAB8, vA4a2 vAB9, vB6

25
General Algorithmic Framework for Elicitation
Algorithm Solve(Y,G) while not Done(Y,G) do o
SelectOp(Y,G) ? Choose question I
PerformOp(o,N) ? Ask bidder G Propagate(I,G) ?
Update data structures with answer Y
Candidates(Y,G) ? Curtail set of candidate
allocations
Output Y set of optimal allocations Input Y
set of candidate allocations (some may turn
out infeasible, some suboptimal) G partially
augmented order graph
26
General Task of the Procedures

• Done checks if the topological structure has
  been sufficiently explored to exclude
  existence of better solutions
• In SelectOp, a Policy determines which questions
  to ask next
• PerformOp asks the questions and obtains
  answers
• Propagate will update the augmented order graph
• Candidates will determine a new set of potential
  solutions based on the update graph

27
(Partially) Augmented Order Graph
8
8
8
8
8
8
Ø
B
A
AB
Agent1
A
Ø
0
0
0
0
gt
Allocations
B
B
4
0
3
6
2
6
1
9
Ø
A
B
AB
Agent2
1
1
0
0
1
6
1,1
1,2
2,1
Rank
Upper Bound
3,1
2,2
1,3
1
9
2,3
3,2
1,4
1,4
AB
6
2,4
3,3
4,2
3,4
4,3
Lower Bound
4,4
Some interesting procedures for combining
different types of info
28
Storing the answer

• Interval constraint networks, 1 per agent
• Nodes store upper/lower bounds on value of
  bundle
• Edge (b,b) means vi(b) ? vi(b)
• At start create all nodes, add edges for free
  disposal

29
Constraint Network
111
1 per agent
110
101
011
100
010
001
000
30
Constraint Network
0,?
111
Upper bound
0,?
0,?
0,?
110
101
011
Lower bound
0,?
0,?
0,?
100
010
001
0
000
31
Constraint Propagation
0,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,?
0,?
0,?
100
010
001
0
000
32
Constraint Propagation
0,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,?
0,?
0,?
100
010
001
0
000
33
Constraint Propagation
5,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,5
0,5
0,?
100
010
001
0
000
34
Constraint Propagation
5,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,5
0,5
0,?
100
010
001
0
000
35
Constraint Propagation
5,?
111
vi(110)5
0,?
0,?
5
110
101
011
0,5
0,5
0,?
100
010
001
0 ,5
000
000
Additional edges from order queries
36
Constraint propagation

• Davis87 shows propagation is
• complete for assimilation (values for UB, LB are
  as tight as they can be made)
• incomplete for inference (cannot always use
  values to infer vi(b) ? vi(b))
• Need to use both values and network topology
  during inference

37
Are we done yet?

• Need to stop when enough information has been
  gathered
• Store list of possible allocations (candidates)
  C
• After each phase, eliminate allocations that
  cannot be optimal v(c) ? v(c)
• Stop when C 1

38
We present algorithms that use any combination of
value, order rank queries

• If value queries are used, all social welfare
  maximizing allocations are guaranteed to be found
• Otherwise, all Pareto efficient allocation are
  guaranteed to be found
• We propose several query policies that are geared
  toward reducing the number of queries needed

39
What query should the elicitor ask next ?

• Simplest answer value query
• Ask for the value of a bundle vi(b)
• How to pick b, i?

40
Random elicitation

• Asks randomly chosen value queries whose answer
  cannot yet be inferred
• Thrm. If the full-revelation mechanism makes Q
  value queries and the best value-elicitation
  policy makes q queries, random elicitation makes
  on average value queries
• Proof idea We have q red balls, and the
  remaining balls are blue how many balls do we
  draw before removing all q red balls?

41
Experimental setup for all graphs in this talk

• Simulations
• Draw agents valuation functions from a random
  distribution where free disposal is honored
• Run the auction auctioneer asks queries of
  agents, agents look up answer from a file
• Each point on plots is average of 10 runs

42
Random elicitation

• Not much better than theoretical bound

queries
queries
2 agents
4 items
80
1000
60
Full revelation
100
Queries
40
10
20
1
9
2
2
3
4
5
6
3
4
5
6
7
8
10
agents
items
43
Querying random allocatable bundle-agent pairs
only

• Bundle-agent pair (b,i) is allocatable if some
  yet potentially optimal allocation allocates
  bundle b to agent i
• How to pick (b,i)?
• Pick a random allocatable one
• Asking only allocatable bundles means throwing
  out some queries
• Thrm. This restriction causes the policy to make
  at worst twice as many expected queries as the
  unrestricted random elicitor. (Tight)
• Proof idea These ignored queries are either
• Not useful to ask, or
• Useful, but we would have had low probability of
  asking it, so no big difference in expectation

44
Querying random allocatable bundle-agent pairs
only

• Much better
• Almost (items / 2) fewer queries than
  unrestricted random
• Vanishingly small fraction of all queries asked !
• Subexponential number of queries

queries
queries
80
1000
60
Full revelation
100
40
Queries
10
20
1
2
3
4
5
6
3
4
5
6
7
8
9
2
10
agents
items
45
Best value query elicitation policy so far
Focus on allocations that have highest upper
bound. Ask a (b,i) that is part of such an
allocation and among them, pick the one that
affects (via free disposal) the largest number
of bundles in such allocations.
Omniscient elicitor
Optimal elicitor implementable, but utterly
intractable.
46
Worst-case number of bits transmitted
(nondeterministic model)

• Exponential (even to approximately optimally
  allocate the items within ratio better than 1/2)
  Nisan Segal JET-06 see also CS-friendly
  version from Nisans home page

L is the number of items
Proof.
47
Universal revelation reducer

• Def. For a given query class, a universal
  revelation reducer is an elicitor that will ask
  less than everything whenever the shortest
  certificate includes less than all queries
• Thrm. Hudson Sandholm ACMEC-03, AAMAS-04 No
  deterministic universal revelation reducer exists
  for value queries
• Randomized ones exists, e.g., the random elicitor

48
Restricted preferences

• Even worst-case number of queries is polynomial
  when agents valuation functions fall within
  certain natural classes

49
Read-once valuations
Returns sum of c highest-valued inputs if at
least k inputs are positive, 0 otherwise
PLUS
MAX
ALL
ALL
1000
500
400
100
200
150

• Thrm. If an agent has a read-once valuation
  function, the number of value queries needed to
  elicit the function is polynomial in items
• Thrm. If an agents valuation function is
  approximable by a read-once function (with only
  MAX and PLUS nodes), elicitor finds an
  approximation in a polynomial number of value
  queries

50
Toolbox valuations

• Items are viewed as tools
• Agent can accomplish multiple goals
• Each goal has a value requires some subset of
  tools
• Agents valuation for a package of items is the
  sum of the values of the goals that those tools
  allow the agent to accomplish
• E.g. items medical patents, goals medicines
• Thrm. If an agent has a toolbox valuation
  function, it can be elicited in O(items goals)
  value queries

51
Computational complexity of finding an optimal
allocation after elicitation

• Thrm. Given one agent with an additive valuation
  fn and one agent with a read-once valuation fn,
  allocation requires only polynomial computation
• Thrm. With 2 agents with read-once valuations
  (even with just MAX, SUM, and ALL gates), it is
  NP-hard to find an allocation that is better than
  ½ optimal
• Thrm. Given 2 agents with toolbox valuations
  having s1 and s2 terms respectively, optimal
  allocation can be done in computation time
  poly(m, s1s2)

52
2-wise dependent valuations

• Prop. If an agent has a 2-wise dependent
  valuation function, elicitor finds it in m(m1)/2
  queries
• Thrm. If an agents valuation function is
  approximately 2-wise dependent, elicitor finds an
  approximation in m(m1)/2 queries
• Thrm. Every super-additive valuation function is
  approximately 2-wise dependent
• Thrm. These results generalize to k-wise
  dependent valuationsusing O(mk) queries

53
Gk k-wise dependent valuations

• G1 ? G2 ? ? Gm
• G1 linear valuations Easy to elicit allocate
• Gk where k 2 is a constant Easy to elicit,
  NP-hard to allocate
• if graph cycle free (i.e. forest), allocation
  polytime
• Gg(m) where g(m) is an arbitrary (sublinear) fn
  s.t. g(m) approaches infinity as m approaches
  infinity Hard to elicit NP-hard to allocate
• Gm contains all valuation fns

54
Combining polynomially elicitable classes

• Thrm. If class C1 (resp. C2) is elicitable using
  p1(m) (resp. p2(m)) queries, then C1 union C2 is
  elicitable in p1(m) p2(m) 1 queries. Tight

55
Combining polynomially elicitable classes

• Computational complexity?
• O(items2 items t) for union of
• Read-once valuations (with SUM and MAX gates
  only)
• Toolbox valuations (with t goals)
• 2-wise dependent valuations
• Toolbox-t
• INTERVAL

56
In some settings, learning only a tiny part of
valuation fns suffices to allocate optimally

• Consider 2 agents with valuations f and g
• Each has some subsets of items that he likes
• Each such subset is of size log m
• Agents valuation is 1 if he gets a set of items
  that he likes, 0 otherwise
• Since there are bundles of size log
  m, some members of this class cannot be
  represented in poly(m) bits gt can require
  super-polynomial number of queries to learn an
  agents valuation fn
• But Thrm. Optimal allocation can be determined
  in poly(m) queries
• Proof Try random partitions of items into two
  equal-sized sets
• Derandomization A set of assignments to m
  boolean variables is (m,k)-universal if for every
  subset of k variables, the induced assignments to
  those variables cover all 2k settings. Naor and
  Naor (1990) give efficient constructions of such
  sets using only 2O(k) log m assignments. We can
  use k O(log m), so the construction is
  polynomial time and space. Each of these
  assignments corresponds to a partition of items,
  and we ask f and g for their valuations on each
  one and take the best.

57
In some settings, learning only a tiny part of
valuation fns suffices to allocate optimally

• There can be super-polynomial power even when
  valuation fns have short descriptions
• Let each agent have some distinguished bundle S
• Agents valuation is
• 1 for all bundles of size S, except for S
  itself
• 0 otherwise
• Prop. It can take value queries to
  learn such a valuation fn
• Thrm. With two agents with such valuation fns,
  the optimal allocation can be determined in 4
  log2 m value queries
• Proof. First find S in log2 m 1 queries
  using binary search. Then make 3 arbitrary
  queries of size S. At most 1 of them can
  return 0. Call the other two sets T and T. We
  then query the other agent for M-T if it returns
  1, then T, M-T is an optimal allocation.
  Otherwise, T, M-T is optimal.

58
Power of interleaving queries among agents

• Observation In general (not just in
  combinatorial auctions), we can elicit without
  interleaving within a number of queries that is
  exponential in q
• where q is the number of queries used when
  eliciting with interleaving.
• Proof Contingency plan tree is (merely)
  exponential in the number of queries

59
Other results on elicitation

• Interleaving value order queries Hudson
  Sandholm AMEC-02, AAMAS-04
• Bound-approximation queries Hudson Sandholm
  AMEC-02, AAMAS-04
• Elicitation in exchanges (for multi-robot task
  allocation) Smith, Sandholm Simmons AAAI-02
  workshop
• Eliciting bid-takers non-price preferences in
  (combinatorial) reverse auctions Boutilier,
  Sandholm, Shields AAAI-04

60
Demand queries

• If the prices (on items or some bundles) were p,
  which bundle would you buy?

61
Value queries vs. demand queries

• A value query can be simulated by a polynomial
  number of demand queries BlumrosenNisan EC-05,
  see also their SIAM J. Computing 2010 paper
• Proof. Elicit value of adding one item at a time
  into the bundle. The marginal value of each such
  addition is done via binary search on that items
  price.
• A demand query cannot be simulated in a
  polynomial number of value queries
  BlumrosenNisan EC-05
• There exists restricted CAs where optimal
  allocation can be found in poly bits, but
  exponential number of demand (and thus value)
  queries are needed Nisan Segal TARK-05

62
Ascending combinatorial auctions

• Demand queries
• Per-item prices vs. bundle prices
• Discriminatory vs. nondiscriminatory prices
• Exponential communication complexity, but
  polynomial in special classes (e.g., when items
  are substitutes) Nisan-Segal JET-06
• To allocate optimally, enough info has to be
  elicited to determine the minimal competitive
  equilibrium prices Parkes Nisan-Segal JET-06
• Could also use descending prices

63
Ascending combinatorial auctions

• Thm Blumrosen Nisan JET-10. To achieve
  efficiency, the number of trajectories in an
  ascending item-price CA may have to be
  exponential in the number of items
• even if the trajectories can be interleaved and
  what is done on a trajectory can depend on what
  happened on other trajectories
• Thm Blumrosen Nisan JET-10. Any anonymous
  ascending (even bundle-price) CA may fail to find
  an efficient allocation

64
XOR-bidding language Sandholm ICE-98, IJCAI-99

• (umbrella, 4) XOR (raincoat, 5)
  XOR (umbrella,raincoat,
  7) XOR
• Bidders valuation is the highest-priced term, of
  the terms whose bundle the bidder receives

65
Power of bundle prices

• Thrm. Lahaie Parkes ACMEC-04 Using
  bundle-price demand queries (even when only
  poly(m) bundles are priced) and value queries, an
  XOR-valuation can be learned in O(m2 terms)
  queries
• Thrm. Blum, Jackson, Sandholm, Zinkevich
  COLT-03, JMLR-04 If the elicitor can use value
  queries and item-price demand queries only, then
  2?(vm) queries are needed in the worst case
• even if each agents XOR-valuation has only O(vm)
  terms

66
Conclusions on preference elicitation in
combinatorial auctions

• Reduces the number of local plans needed
• Capitalizes on multi-agent elicitation
• Truth-promoting push-pull mechanism

67
Future research on preference elicitation

• Scalable general elicitors (in queries, CPU, RAM)
  
• New polynomially elicitable valuation classes
• More powerful queries, e.g. side constraints
• Using models of how costly it is to answer
  different queries Hudson Sandholm AMEC-02,
  AAMAS-04
• Strategic deliberation Larson Sandholm
• Other applications (e.g. voting Conitzer
  Sandholm AAAI-02, EC-04)

68
Future research on multiagent preference
elicitation

• Scalable general elicitors (in queries, CPU, RAM)
• Current run-time exp in items, poly in agents
• Current space exp in items, linear in agents
• More powerful queries, e.g. side constraints
• New query policies
• New polynomially elicitable valuation classes
• Using models of how costly it is to answer
  different queries Hudson S. AMEC-02
• Decision-theoretic elicitation using priors
• Elicitors for markets beyond combinatorial
  auctions
• (Combinatorial) reverse auctions exchanges
• (Combinatorial) markets with side constraints
• (Combinatorial) markets with multiattribute
  features
• Other applications (e.g. voting Conitzer S.
  AAAI-02)

69
Tradeoffs between

• Agents evaluation complexity
• Amount revealed to the auctioneer (crypto)
• Amount revealed to other agents (vs. to elicitor)
• Bits communicated
• Elicitors computational complexity (knowing when
  to terminate, what to ask next)
• Elicitors memory usage (e.g., implicit candidate
  list)
• Designers objective
• Designing for specific prior eliciting using
  the prior
• Terminating before optimal allocation,

70
Thank you for your attention!

• Papers with additional results at
  www.cs.cmu.edu/sandholm

71
Revelation principle

• Thrm. Anything that can be accomplished with some
  mechanism x can also be accomplished via a
  mechanism where agents reveal their preferences
  truthfully in a single step

72
Sometimes a non-truthpromoting mechanism is
preferable

• Thrm. There are settings where
• Executing the social welfare maximizing
  truth-promoting mechanism is NP-complete
• There is a non-truthpromoting mechanism, where
• The mediator only carries out polynomial
  computation
• Finding a beneficial insincere revelation is
  NP-complete for each agent
• If an agent manages to find a beneficial
  insincere revelation, the mechanism is as good as
  the truth-promoting one
• Otherwise, the non-truthpromoting mechanism
  yields greater social welfare
• Are there practical settings where
  non-truthpromoting mechanisms yield a significant
  benefit?
• What would such mechanisms look like?
• Are there principles for designing them?
• Can they be designed automatically?
• What about multi-step non-truthpromoting
  mechanisms?

73
Mechanisms that take into account agents limited
computing

• Mechanisms that are average-case hard to
  manipulate, or where every instance is hard
• Modeling deliberation actions as part of the game
  Larson Sandholm AAAI-00,
  AGENTS-01 WS on Agent-based Approaches to B2B,
  TARK-01, AIJ-01, AAMAS-02, Draft-03
• E.g. bidding agents that determine valuations of
  items in auctions where local planning is
  intractable
• Anytime algorithms normative deliberation
  control method
• Strategic computing
• Deliberation equilibrium
• Thrm. Even for 1-item auctions, if computing is
  costly, there is no mechanism that motivates
  truthful bidding and avoids strategic computing
• What would good mechanisms for such agents look
  like? Design principles? Automated design?

74
Order queries

• Order query agent i, is bundle b worth more to
  you than bundle b ?
• Motivation Often easier to answer than value
  queries
• Order queries are insufficient for determining
  welfare maximizing allocations
• How to interleave order, value queries?
• How to choose i, b, b ?

75
Value and order queries

• Interleave
• 1 value query (of random allocatable agent-bundle
  pair)
• 1 order query (pick arbitrary allocatable i, b,
  b )
• To evaluate, in the graphs we have
• value query costs 1
• order query costs 0.1

76
Value and order queries

• Elicitation cost reduced compared to value
  queries only
• Cost reduction depends on relative costs of order
  value queries

77
Bound-approximation queries

• Often bidders can determine their valuations more
  precisely by allocating more time to deliberation
  S. AAAI-93, ICMAS-95, ICMAS-96, IJEC-00 Larson
  S. TARK-01, AGENTS-01 workshop, SITE-02 Parkes
  IJCAI workshop-99
• Get better bounds UBi(b) and LBi(b) with more
  time spent deliberating
• Idea dont ask for exact info if it is not
  necessary
• Query agent i, hint spend t time units
  tightening the upper (lower) bound on b
• How to choose i, b, t, UB or LB ?
• For simplicity, in the experiment graph, fix t
  0.2 time units (1 unit gives exact)

78
Bound-approx query policy
This slide is hidden later, it should replace
the next slide.

• For simplicity, fix t 0.2 units (1 unit gives
  exact)
• Can choose randomly.
• More complicated policy does slightly better
• Choose query that will change the bounds on
  allocatable bundles the most
• Dont know how much bounds will change
• Will try 3 policies
• Compute expectation (assume uniform distribution)
• Be optimistic assume most possible change
• Be pessimistic assume least possible change

79
Bound-approximation query policy

• Could choose the query randomly
• More sophisticated policy does slightly better
• Choose query that will change the bounds on
  allocatable bundles the most
• Dont know exactly how much bounds will change
• Assume all legal answers equiprobable, sample to
  get expectation

80
Bound-approximation queries

• This policy does quite well
• Future work try other related policies

queries
queries
160
1000
Full revelation
120
100
Query cost
80
10
40
1
9
2
2
3
4
5
6
3
4
5
6
7
8
10
agents
items
81
Bound-approximation a note

• To choose which query to ask, we calculated the
  expected change it makes
• But what is change from ? ?
• Policy actually is ask everyone for an UB on the
  grand bundle first
• After that, we neednt worry about ?
• Thrm. Upper bound on value of grand bundle is
  needed for all but one agent
• Thrm. With more than one bidder, eliciting the
  grand bundle from every agent cannot increase the
  length of the shortest elicitation certificate

82
Supplementing bound-approximation queries with
order queries

• Integrated as before
• Computationally more expensive

queries
queries
160
1000
Full revelation
120
Total cost
100
80
Order cost
10
Value cost
40
1
2
3
4
5
6
3
4
5
6
7
8
9
2
10
agents
items
83
A potentially better policy

• Assume auctioneer has an oracle that says which
  allocation is optimal. How to verify?
• To prove optimality, need to
• Prove sufficiently tight LB on optimal
• Prove sufficiently tight UB on all others
• Indicates a strategy when oracle is missing
• Usually ask queries that reduce UB
• But, need to sometimes raise LB

84
Incentive compatibility

• Elicitors questions leak information about
  others preferences
• Can be made ex post incentive compatible
• Ask enough questions to determine VCG prices
• Worst approach bidders1 elicitors
• Could interleave these extra questions with
  real questions
• To avoid lazyness Not necessary from an
  incentive perspective
• Agents dont have to answer the questions may
  answer questions that were not asked
• Unlike in price feedback (tatonnement)
  mechanisms Bikhchandani-Ostroy, Parkes-Ungar,
  Wurman-Wellman, Ausubel-Milgrom,
  Bikhchandani-deVries-Schummer-Vohra,
• Push-pull mechanism

85
Incentive compatibility of the different
approaches

• Classic single-shot full revelation mechanims
  (e.g., Vickrey-Clarke-Groves, dAGVA)
• Can be made dominant strategy incentive
  compatible
• (Ascending) mechanisms with price feedback (e.g.,
  iBundle, akBa)
• Can be made incentive compatible in ex post
  equilibrium
• Our new approach an elicitor agent
• Elicitors questions leak information about
  others preferences
• Can be made incentive compatible in ex post
  equilibrium
• Ask enough questions to determine VCG prices
• Could interleave these extra questions with
  real questions
• To avoid lazyness Not necessary from an
  incentive perspective
• Bidders can pass on questions answer questions
  that were not asked

86
Elicitation where worst-case number of queries is
polynomial in items
87
Ascending combinatorial auctions
88
Demand queries

• If these were the prices, which bundle would you
  buy?
• A value query can be simulated by a polynomial
  number of demand queries
• A demand query cannot be simulated in a
  polynomial number of value queries Nisan

89
Ascending combinatorial auctions

• Increase prices until each item is demanded only
  once
• Item prices vs. bundle prices
• E.g. where there exist no appropriate item prices
• Discriminatory vs. nondiscriminatory prices

Bundle Bidder 1s valuation Bidder 2s valuation
1 0 2
2 0 2
1,2 3 2
90
Competitive equilibrium

• Def. Competitive equilibrium (CE)
• For each bidder, payoff max vi(S) pi(S), 0
• Sellers payoff maxS ? Feasibles ?i pi(S)
• Prices can be on bundles and discriminatory
• Thrm. Allocation S is supported in CE iff it is
  an efficient allocation
• Thrm Parkes 02 NisanSegal 03. In a
  combinatorial auction, the information implied by
  best-responses to some set of CE prices is
  necessary and sufficient as a certificate for the
  optimal allocation

91
Communication complexity of ascending auctions

• Exponential in items in the general case
• (like any other preference elicitation scheme)
• If items are substitutes (for each agent), then a
  Walrasian equilibrium exists,
• i.e., nondiscriminatory per-item prices suffice
  for agents to self-select the right items
• Number of queries needed to find such prices is
  polynomial in items Nisan Segal 03

92
Conclusions on preference elicitation in
combinatorial auctions

• Combinatorial auctions are desirable winner
  determination algorithms now scale to the large
• Another problem The Revelation Problem
• Valuation computation / revelation /
  communication
• Introduced an elicitor that focuses revelation
• Provably finds the welfare maximizing (or Pareto
  efficient) allocations
• Policy dependent search algorithms for
  elicitation
• Based on topological observations
• Optimally effective among admissibly equipped
  elicitors
• Eliciting value differences suffices
• Policy independent general elicitation framework
• Uses value, order rank queries (etc)
• Bound-approximation queries takes incremental
  revelation further
• Several algorithms, data structures query
  policies in the paper
• Only elicits a vanishingly small fraction of the
  valuations
• Presented a way to make the elicitor incentive
  compatible
• Yields a push-pull partial-revelation mechanism