1. Preference Elicitation in Combinatorial Auctions: An Overview Tuomas Sandholm [For 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, v i : 2 m  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 2 #items 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. Clearing algorithm What info is needed from an agent depends on what others have revealed Elicitor Conen & Sandholm IJCAI-01 workshop on Econ. Agents, Models & Mechanisms, ACMEC-01 Elicitor decides what to ask next based on answers it has received so far $ 1,000 for $ 1,500 for ? for

6. Conen & Sandholm IJCAI workshop- 01, ACMEC-01 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 elicitor’s queries truthfully Elicitor’s queries leak information across agents Thrm. Nevertheless, answering truthfully can be made an ex post equilibrium [Conen&Sandholm ACMEC-01] –Elicit enough to determine optimal allocation overall, and for each agent removed in turn –Use externality pricing [Vickrey-Clarke-Groves (VCG)] 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 else’s valuation(s) [Larson&Sandholm 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 [1,1] [1,2][2,1] [2,3] [3,1] [3,2] [2,4] [3,4][4,3] [3,3][4,2] [4,4] [1,4][4,1] [2,2][1,3] Infeasible Feasible Dominated Rank of Bundle Ø A B AB for Agent 1 4 2 3 1 for Agent 2 4 3 2 1

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 1413 9 1012 9 8 [1,1] [1,2][2,1] [2,3] [3,1] [3,2] [2,4] [3,4][4,3] [3,3][4,2] [4,4] [1,4][4,1] [2,2][1,3]

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) = max node  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: 0) Thrm. Any EBF algorithm requires at worst (2 #items #bidders – #bidders #items )/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 [Nisan&Segal 03]

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 #bidders #items 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 2 #agents #items –#feasible nodes is only #agents #items agents items 468210 23456 queries 1 10 100 1000 20 40 60 80 queries Full revelation Queries 12

17. Differential-revelation Extension of EBF Information elicited: differences between valuations –Hides sensitive value information Motivation: max ∑ v i (X i )  min ∑ [v i (r -1 (1)) – v i (X i )] –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 δ? if „yes“ increment δ, 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 < Δ 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 elicitor’s 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 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 A a2: Give me your valuation for AB and B 1.a1: AB, a2: AB (not feasible) 2.a1: A, a2: B (feasible) 3.a1: v AB =8, v A =4 a2: v AB =9, v B =6 Questions of the Auctioneer Answers of the Agents

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 ØBAAB ∞∞∞∞ 0000 ØAB 0016 40362619 Agent1 Agent2 A B Ø B > ∞ 1 ∞ 1 Allocations AB 6 19 RankUpper Bound Lower Bound [1,1] [1,2][2,1] [2,3] [3,1] [3,2] [2,4] [3,4][4,3] [3,3][4,2] [4,4] [1,4] [2,2][1,3] 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 v i (b)  v i (b’) At start: create all nodes, add edges for free disposal

29. Constraint Network 111 110101011 100010001 000 1 per agent

30. Constraint Network 111 110101011 100010001 000 [0,  ] [0,][0,] [0] Lower bound Upper bound

31. Constraint Propagation 111 110101011 100010001 000 [0,  ] [5] [0,  ] [0] v i (110)=5

32. Constraint Propagation 111 110101011 100010001 000 [0,  ] [5] [0,  ] [0] v i (110)=5

33. Constraint Propagation 111 110101011 100010001 000 [5,][5,] [0,  ] [5] [0,5] [0,  ] [0] v i (110)=5

34. Constraint Propagation 111 110101011 100010001 000 [5,][5,] [0,  ] [5] [0,5] [0,  ] [0] v i (110)=5

35. Constraint Propagation 111 110101011 100010001 000 [5,][5,] [0,  ] [5] [0,5] [0,  ] [0,5] v i (110)=5 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 v i (b)  v i (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 v i (b) How to pick b, i?

40. Hudson & Sandholm AMEC-02, AAMAS-04 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? Random elicitation

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 agents items 345678 9 2 10 23456 queries 1 10 100 1000 20 40 60 80 queries Full revelation Queries 2 agents 4 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 agents items 345678 9 2 10 23456 queries 1 10 100 1000 20 40 60 80 queries Full revelation Queries

45. Hudson & Sandholm AMEC-02, AAMAS-04 Number of items for sale Fraction of values queried before provably optimal allocation found Omniscient elicitor Optimal elicitor implementable, but utterly intractable. 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.

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 Nisan’s home page] 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. Zinkevich, Blum & Sandholm ACMEC-03 Read-once valuations 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 agent’s 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 PLUS ALL MAX ALL 500400 200 100 1000 150 GATE k,c Returns sum of c highest-valued inputs if at least k inputs are positive, 0 otherwise

50. Zinkevich, Blum & Sandholm ACMEC-03 Toolbox valuations Items are viewed as tools Agent can accomplish multiple goals –Each goal has a value & requires some subset of tools –Agent’s 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) queries

51. Zinkevich, Blum & Sandholm ACMEC-03 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, s1+s2)

52. Conitzer, Sandholm & Santi Draft-03, AAAI-05 0+1+2 = 3 2-wise dependent valuations Prop. If an agent has a 2-wise dependent valuation function, elicitor finds it in m(m+1)/2 queries Thrm. If an agent’s valuation function is approximately 2-wise dependent, elicitor finds an approximation in m(m+1)/2 queries –Thrm. Every super-additive valuation function is approximately 2-wise dependent Thrm. These results generalize to k-wise dependent valuations using O(m k ) queries 1 3 3 -2 0 2 1 Node = item m items

53. Conitzer, Sandholm & Santi Draft-03 G k = k-wise dependent valuations G 1  G 2  …  G m G 1 = linear valuations: Easy to elicit & allocate G k where k ≥ 2 is a constant: Easy to elicit, NP- hard to allocate –if graph cycle free (i.e. forest), allocation polytime G g(m) where g(m) is an arbitrary (sublinear) fn s.t. g(m)  as m  : Hard to elicit & NP- hard to allocate G m contains all valuation fns

54. Santi, Conitzer, Sandholm COLT-04 Combining polynomially elicitable classes Thrm. If class C1 (resp. C2) is elicitable using p1(m) (resp. p2(m)) queries, then C1  C2 is elicitable in p1(m) + p2(m) + 1 queries. Tight Computational complexity? O(#items 2 + #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

55. Blum, Jackson, Sandholm & Zinkevich JMLR-04 In some settings, learning only a tiny part of valuation fns suffices to allocate optimally Consider 2 agents –Each has some subsets of items that he likes –Each such subset is of size log m –Agent’s 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 => can require super-polynomial number of queries to learn an agent’s valuation fn But… Thrm. Optimal allocation can be determined in poly(m) queries

56. Blum, Jackson, Sandholm & Zinkevich JMLR-04 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’ Agent’s 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 + log 2 m value queries –Proof. First find |S’| in log 2 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 set 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.

57. 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

58. 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-taker’s non-price preferences in (combinatorial) reverse auctions [Boutilier, Sandholm, Shields AAAI-04]

59. Demand queries “If the prices (on items or some bundles) were p, which bundle would you buy?”

60. Value queries vs. demand queries A value query can be simulated by a polynomial number of demand queries [Blumrosen&Nisan 04] A demand query cannot be simulated in a polynomial number of value queries [Blumrosen&Nisan 04] 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]

61. 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 03] –To allocate optimally, enough info has to be elicited to determine the minimal competitive equilibrium prices [Parkes; Nisan-Segal 03] Could also use descending prices

62. XOR-bidding language [Sandholm ICE-98, IJCAI-99] ({umbrella}, $4) XOR ({raincoat}, $5) XOR ({umbrella,raincoat}, $7) XOR … Bidder’s valuation is the highest-priced term, of the terms whose bundle the bidder receives

63. 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(m 2 #terms) queries Thrm. [Blum, Jackson, Sandholm, Zinkevich COLT-03] If the elicitor can use value queries and item-price demand queries only, then 2  (  m) queries are needed in the worst case –even if each agent’s XOR-valuation has only O(  m) terms

64. Conclusions on preference elicitation in combinatorial auctions Reduces the number of local plans needed Capitalizes on multi-agent elicitation Truth-promoting push-pull mechanism

65. 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] )

66. 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])

67. Tradeoffs between 1.Agent’s evaluation complexity 2.Amount revealed to the auctioneer (crypto) 3.Amount revealed to other agents (vs. to elicitor) 4.Bits communicated 5.Elicitor’s computational complexity (knowing when to terminate, what to ask next) 6.Elicitor’s memory usage (e.g., implicit candidate list) 7.Designer’s objective Designing for specific prior & eliciting using the prior Terminating before optimal allocation, …

68. Thank you for your attention! Papers with additional results at www.cs.cmu.edu/~sandholm

69. 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 Agent 1’s preferences Agent |A|’s preferences... Strategy formulator Strategy formulator Strategy Original mechanism x Outcome Constructed truth-promoting 1-step mechanism

70. Conitzer & Sandholm AMEC-03 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?

71. 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?

72. 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’ ?

73. 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

74. Value and order queries … Elicitation cost reduced compared to value queries only –Cost reduction depends on relative costs of order & value queries agents items 345678 9 2 10 23456 queries 1 10 100 1000 20 40 60 80 queries Order cost Value cost Total cost Full revelation

75. 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 UB i (b) and LB i (b) with more time spent deliberating Idea: don’t 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)

76. Bound-approx query policy 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 Don’t 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 This slide is hidden; later, it should replace the next slide.

77. 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 –Don’t know exactly how much bounds will change –Assume all legal answers equiprobable, sample to get expectation

78. Bound-approximation queries This policy does quite well Future work: try other related policies agents items 345678 9 2 10 23456 queries 1 10 100 1000 40 80 120 160 queries Full revelation Query cost

79. 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 needn’t 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

80. Supplementing bound-approximation queries with order queries Integrated as before –Computationally more expensive agents items 345678 9 2 10 23456 queries 1 10 100 1000 40 80 120 160 queries Full revelation Total cost Value cost Order cost

81. 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

82. Incentive compatibility Elicitor’s questions leak information about others’ preferences Can be made ex post incentive compatible –Ask enough questions to determine VCG prices Worst approach: #bidders+1 “elicitors” –Could interleave these “extra” questions with “real” questions To avoid lazyness; Not necessary from an incentive perspective –Agents don’t 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

83. 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” –Elicitor’s 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

84. Elicitation where worst-case number of queries is polynomial in items

85. Ascending combinatorial auctions

86. 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]

87. 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 1’s valuation Bidder 2’s valuation {1}$0$2 {2}$0$2 {1,2}$3$2

88. Competitive equilibrium Def. Competitive equilibrium (CE) –For each bidder, payoff = max [v i (S) – p i (S), 0] –Seller’s payoff = max S  Feasibles  i p i (S) –Prices can be on bundles and discriminatory Thrm. Allocation S* is supported in CE iff it is an efficient allocation Thrm [Parkes 02; Nisan&Segal 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

89. 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]

90. 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