Combinatorial Auctions and Approximation Mechanisms

Single-minded bidders and the greedy mechanism; Walrasian equilibrium and the LP relaxation; bidding languages and OR* bids; demand queries; communication lower bounds; ascending auctions; monotone scheduling; the decomposition technique; Roberts-style impossibilities; and algorithmic implementation

· 55 min read · 10,862 words

Motivation: the allocation problem with many interrelated items

A large part of computer science, and a large part of economics, may be viewed as addressing the allocation problem: how should we allocate resources among the different possible uses? An auction of a single item is a simple abstraction — one indivisible resource, several players who want it, who should get it? — which explains the pivotal role of simple auctions in mechanism design.

Combinatorial auctions abstract the same issue when multiple resources are involved. In general the interrelations of the resources may be combinatorially complex, and handling them requires handling that complexity. It is no surprise that the field is gaining a central place at the interface of computer science and economics.

DefinitionThe model

mm indivisible items concurrently auctioned among nn bidders. Each bidder has a valuation viv_i: a real-valued function where vi(S)v_i(S) is the value of receiving bundle SS. A valuation must have free disposal (be monotone, v(S)≤v(T)v(S)\le v(T) for S⊆TS\subseteq T) and be normalized (v(∅)=0v(\emptyset)=0).

An allocation is S1,…,SnS_1,\ldots,S_n with Si∩Sj=∅S_i\cap S_j = \emptyset; its social welfare is ∑ivi(Si)\sum_i v_i(S_i), and a socially efficient allocation maximizes this.

ImportantThe whole point of a valuation function

The value of a bundle need not equal the sum of the values of its items. For disjoint S,TS,T: they are complements if v(S∪T)>v(S)+v(T)v(S\cup T) > v(S)+v(T), and substitutes if v(S∪T)<v(S)+v(T)v(S\cup T) < v(S)+v(T).

Two assumptions are implicit: preferences are quasi-linear in money (utility vi(S)−pv_i(S) - p), and there are no externalities (a bidder cares only about what he receives, not how the rest is allocated).

WarningThree difficulties, and their interplay

  • Computational complexity. The allocation problem is NP-complete even for simple special cases.
  • Representation and communication. Valuation functions are exponential size objects — a value per bundle. How do we even represent them, let alone transfer enough information to the auctioneer?
  • Strategies. How do we analyze, and design for, strategic behavior?

The combination of these difficulties, and the subtle interplay between them, is what gives the problem its generic flavor — in some sense encompassing many of the issues found in algorithmic mechanism design generally.

ExampleThree application areas

Spectrum auctions, held worldwide, have received the most attention: a large number of licenses, each for a band of spectrum in a geographic area, needed by cell-phone companies. One scheduled FCC auction included 1,122 licenses, each covering a 10- or 20-MHz band over an area of 0.5 to 50 million people, with total minimum bids over 1 billion dollars. Bidders want licenses covering their operating area with sufficient bandwidth. Most spectrum auctions so far escaped the combinatorial nature by essentially running a separate auction per item (in a clever simultaneous way), so bidders could not fully express preferences, presumably leading to suboptimal allocation.

Transportation, usually reversed — a procurement auction where the auctioneer buys from many bidding suppliers. A company buying transportation for many routes: for each supplier the cost of a bundle depends on its structure, since vehicles must be moved between routes. Commercial operators commonly report savings of many millions of dollars.

Network connection requests, a conceptual example. Each request wants a path between two nodes and offers a price; each edge must be fully allocated, so the paths must be edge-disjoint. As a combinatorial auction: the items are the edges, the players are the requests, and a request values at its offered price any bundle containing a suitable path, and 0 otherwise.


Single-minded bidders

This section isolates computation and strategy while leaving out representation entirely.

DefinitionSingle-minded valuation

vv is single minded if there is a bundle S∗S^* and value v∗v^* with v(S)=v∗v(S) = v^* for all S⊇S∗S\supseteq S^* and 0 otherwise. The bid is the pair (S∗,v∗)(S^*, v^*) — very simply represented.

Computational complexity

DefinitionThe allocation problem

Input: (Si∗,vi∗)(S_i^*, v_i^*) for each bidder. Output: a set of winners W⊆{1,…,n}W\subseteq\{1,\ldots,n\} with Si∗∩Sj∗=∅S_i^*\cap S_j^* = \emptyset for distinct i,j∈Wi,j\in W, maximizing ∑i∈Wvi∗\sum_{i\in W}v_i^*.

(In an optimal allocation a single-minded bidder gets exactly Si∗S_i^* or nothing.)

TheoremNP-hardness

The allocation problem among single-minded bidders is NP-hard; deciding whether the optimum is at least kk is NP-complete.

ProofReduction from INDEPENDENT-SET

Given a graph G=(V,E)G=(V,E) and kk: let the items be the edges EE, and give each vertex ii a player with Si∗={e∈E∣i∈e}S_i^* = \{e\in E \mid i\in e\} (the adjacent edges) and vi∗=1v_i^* = 1.

A set WW satisfies Si∗∩Sj∗=∅S_i^*\cap S_j^* = \emptyset for distinct i,j∈Wi,j\in W iff the corresponding vertices form an independent set, and the social welfare is exactly its size. Membership in NP is trivial — guess the allocation and compute.

∎

WarningApproximation is hard too

Maximum independent set is NP-hard to approximate within n1−ϵn^{1-\epsilon}, and since welfare equals independent-set size in the reduction, the same hardness transfers. Stated in terms of items, using m≤n2m\le n^2:

Approximating the optimal allocation among single-minded bidders to within better than m1/2−ϵm^{1/2-\epsilon} is NP-hard.

NoteThe three standard responses

Approximation — m\sqrt m is reachable, and even truthfully, as below.

Special cases. (i) Each bidder wants at most two items: an instance of weighted matching in general nonbipartite graphs, efficiently solvable. (ii) The linear order case: items arranged in a line, each desired bundle a contiguous segment (think lots along a seashore, each bidder wanting a connected strip) — solvable by dynamic programming.

Heuristics. NP-completeness only rules out algorithms guaranteed polynomial and optimal on all inputs. Stated as an integer program, many heuristics apply, often relying on the LP relaxation below. It is probably safe to say that problems with up to hundreds of items can be practically solved optimally, and problems with thousands or tens of thousands approximately solved quite well.

An incentive compatible approximation mechanism

ImportantWhy VCG cannot be used, even approximately

Without the efficiency requirement the answer is easy: take the efficient allocation with VCG payments. But exact optimization is intractable. One might try a “VCG-like” mechanism — take the best approximation algorithm and charge each bidder his externality according to that algorithm. This is not incentive compatible. VCG-like payments give incentive compatibility if and only if the social welfare is exactly optimized by the allocation rule (at least over some subrange).

So we need a non-VCG mechanism. In general settings almost none are known — but our setting is “almost single-dimensional”, the private value being a scalar plus a bundle, and there this is easier.

AlgorithmThe greedy mechanism

Reorder the bids by vi∗/∣Si∗∣v_i^*/\sqrt{|S_i^*|}, descending. Greedily add bidder ii to WW if Si∗S_i^* is disjoint from the bundles already allocated. Each winner ii pays vj∗∣Si∗∣/∣Sj∗∣v_j^*\sqrt{|S_i^*|/|S_j^*|}, where jj is the first bidder after ii in the order who was denied because of ii; losers pay 0.

The sorting expression was chosen to optimize the approximation ratio, but the incentive compatibility argument applies to any expression increasing in vi∗v_i^* and decreasing in ∣Si∗∣|S_i^*|. The intuition for jj is that he is the bidder who lost exactly because of ii — had ii not participated, jj would have won.

TheoremGreedy works

The greedy mechanism is efficiently computable, incentive compatible, and gives a m\sqrt m approximation — as good as theoretically possible in polynomial time.

LemmaCharacterization for single-minded bidders

A mechanism in which losers pay 0 is incentive compatible iff

  1. Monotonicity: a winner with bid (Si∗,vi∗)(S_i^*,v_i^*) keeps winning with any vi′>vi∗v_i'>v_i^* and any Si′⊂Si∗S_i'\subset S_i^* (others fixed).
  2. Critical payment: a winner pays the infimum of all values vi′v_i' such that (Si∗,vi′)(S_i^*,v_i') still wins.

NoteWhy this differs from Chapter 9’s characterization

This is not the general single-parameter characterization from introduction-to-mechanism-design, since single-minded bidders are not single-parameter agents — their private data consists of both a value and a desired bundle.

Greedy satisfies both: raising vi∗v_i^* or shrinking Si∗S_i^* moves ii up the greedy order, making winning easier; and ii wins exactly while he precedes jj, so the computed payment is precisely the transition point.

ProofIncentive compatibility from the two conditions

First, a truthful bidder never gets negative utility: zero when losing, and when winning his value is at least the critical value, which equals his payment.

Suppose the bidder’s true type is (S,v)(S,v) and he reports (S′,v′)(S',v'). If (S′,v′)(S',v') loses or S′⊉SS'\not\supseteq S, truth is at least as good. So assume (S′,v′)(S',v') wins and S′⊇SS'\supseteq S.

Reporting (S,v′)(S,v') is no worse than (S′,v′)(S',v'). Let the payments be p′p' and pp. For every x<px<p, bidding (S,x)(S,x) loses since pp is critical; by monotonicity (S′,x)(S',x) also loses, so p′≥pp'\ge p. Hence switching still wins and the payment does not increase.

Reporting (S,v)(S,v) is no worse than (S,v′)(S,v'). If (S,v)(S,v) wins with critical value p′′p'', then any v′>p′′v'>p'' wins with the same payment, and any v′<p′′v'<p'' loses for zero utility. If (S,v)(S,v) loses, then vv is below the critical value, so any winning (S,v′)(S,v') costs more than vv — an unprofitable deviation.

∎

ProofThe m\sqrt m approximation

Let OPTOPT be an optimal winner set and WW the greedy output. For i∈Wi\in W let OPTi={j∈OPT, j≥i∣Si∗∩Sj∗≠∅}OPT_i = \{j\in OPT,\ j\ge i \mid S_i^*\cap S_j^*\ne\emptyset\} — those excluded because of ii, plus ii itself. Since OPT⊆⋃i∈WOPTiOPT\subseteq\bigcup_{i\in W}OPT_i, it suffices to show ∑j∈OPTivj∗≤m vi∗\sum_{j\in OPT_i}v_j^*\le\sqrt m\,v_i^*.

Every j∈OPTij\in OPT_i came after ii in the greedy order, so vj∗≤vi∗∣Sj∗∣/∣Si∗∣v_j^*\le v_i^*\sqrt{|S_j^*|}/\sqrt{|S_i^*|}. Summing and applying Cauchy–Schwarz,

∑j∈OPTivj∗≤vi∗∣Si∗∣∑j∈OPTi∣Sj∗∣≤vi∗∣Si∗∣∣OPTi∣∑j∈OPTi∣Sj∗∣\sum_{j\in OPT_i}v_j^* \le \frac{v_i^*}{\sqrt{|S_i^*|}}\sum_{j\in OPT_i}\sqrt{|S_j^*|} \le \frac{v_i^*}{\sqrt{|S_i^*|}}\sqrt{|OPT_i|\sum_{j\in OPT_i}|S_j^*|}

Every Sj∗S_j^* for j∈OPTij\in OPT_i intersects Si∗S_i^*, and since OPTOPT is an allocation those intersections are disjoint, giving ∣OPTi∣≤∣Si∗∣|OPT_i|\le|S_i^*|; also ∑j∈OPTi∣Sj∗∣≤m\sum_{j\in OPT_i}|S_j^*|\le m. Substituting gives ∣Si∗∣ m\sqrt{|S_i^*|\,m}, hence the claim.

∎


Walrasian equilibrium and the LP relaxation

FormulaThe linear programming relaxation (LPR)

max⁡ ∑i∈N,S⊆Mxi,S vi(S)\max\ \sum_{i\in N, S\subseteq M} x_{i,S}\,v_i(S) s.t.∑i∈N, S:j∈Sxi,S≤1  ∀j∈M,∑S⊆Mxi,S≤1  ∀i∈N,xi,S≥0\text{s.t.}\quad \sum_{i\in N,\ S : j\in S} x_{i,S}\le 1\ \ \forall j\in M, \qquad \sum_{S\subseteq M}x_{i,S}\le1\ \ \forall i\in N, \qquad x_{i,S}\ge0

In the integer program xi,S∈{0,1}x_{i,S}\in\{0,1\} indicates that ii receives SS. The first constraint says no item is over-allocated; the second that each player gets at most one bundle. LP solutions are fractional allocations — what would be allowed if items were divisible.

FormulaThe dual (DLPR)

min⁡ ∑i∈Nui+∑j∈Mpjs.t.ui+∑j∈Spj ≥ vi(S)  ∀i,S,ui,pj≥0\min\ \sum_{i\in N}u_i + \sum_{j\in M}p_j \qquad \text{s.t.}\quad u_i + \sum_{j\in S}p_j\ \ge\ v_i(S)\ \ \forall i,S, \qquad u_i,p_j\ge0

The notation is intentional: at the optimum these dual variables can be interpreted as item prices and bidder utilities.

NoteExponentially many variables, but still useful

For single-minded bidders only one variable xi,Si∗x_{i,S_i^*} per bidder is needed, so the LP is directly solvable. For general valuations, Solving the linear program shows it can still be solved efficiently given reasonable query access.

DefinitionDemand and Walrasian equilibrium

Under linear (item) prices, TT is a demand of bidder ii if vi(S)−∑j∈Spj≤vi(T)−∑j∈Tpjv_i(S)-\sum_{j\in S}p_j \le v_i(T)-\sum_{j\in T}p_j for every SS.

Prices p∗p^* and an allocation S∗S^* are a Walrasian equilibrium if every Si∗S_i^* is a demand at p∗p^*, and every unallocated item has price zero.

TheoremFirst Welfare Theorem

A Walrasian equilibrium allocation maximizes social welfare — and moreover maximizes it over all fractional allocations. In particular, if a Walrasian equilibrium exists, the LP relaxation has an integral optimum.

ProofSum the demand inequalities, then compare the price terms

Each bidder receives his demand, so for any feasible fractional X∗X^*, using ∑SXi,S∗≤1\sum_S X_{i,S}^*\le1,

vi(Si∗)−∑j∈Si∗pj∗ ≥ ∑SXi,S∗(vi(S)−∑j∈Spj∗)v_i(S_i^*)-\sum_{j\in S_i^*}p_j^* \ \ge\ \sum_{S}X_{i,S}^*\Big(v_i(S)-\sum_{j\in S}p_j^*\Big)

Sum over bidders. It remains to check the price terms: the left side totals ∑jpj∗\sum_{j}p_j^* exactly, since unallocated items have price zero, while the right side is at most ∑jpj∗\sum_j p_j^* since each price has coefficient at most 1 by the item constraint.

∎

WarningWalrasian equilibria need not exist

Two players, two items {a,b}\{a,b\}. Alice values every nonempty set at 2; Bob values {a,b}\{a,b\} at 3 and singletons at 0. The optimal allocation gives both items to Bob, so Alice must demand ∅\emptyset — forcing both prices to be at least 2. But then the bundle costs at least 4, Bob will not demand it, and no Walrasian equilibrium exists.

TheoremSecond Welfare Theorem

If LPR has an integral optimal solution, a Walrasian equilibrium with that allocation exists.

ProofComplementary slackness

Take the integral primal optimum and a dual optimum p∗,u∗p^*,u^*. Complementary slackness makes constraint ui+∑j∈Spj≥vi(S)u_i+\sum_{j\in S}p_j\ge v_i(S) binding wherever xi,Si∗=1x_{i,S_i^*}=1, so ui∗=vi(Si∗)−∑j∈Si∗pj∗u_i^* = v_i(S_i^*)-\sum_{j\in S_i^*}p_j^*; the same constraint for other bundles then gives the demand condition. And where the item constraint is strict — which for integral solutions means the item is unallocated — complementary slackness forces pj∗=0p_j^*=0.

∎

ImportantThe equivalence

A Walrasian equilibrium exists iff the LP relaxation has an integral optimum — i.e. iff the integrality gap is zero. One immediate consequence: in environments where Walrasian equilibria exist, the efficient allocation is polynomial-time computable.


Bidding languages

The problem. Specifying a valuation over mm items requires 2m−12^m-1 numbers — completely impractical beyond two or three dozen items. Since computational complexity can be handled for much larger auctions, representation seems to be the bottleneck in practice.

IntuitionThe design trade-off

From the outset it is clear that for information-theoretic reasons no language can succinctly encode all valuations; the interest is in succinctly encoding the interesting ones. As in all language design: expressiveness versus simplicity. We want to express as many naturally occurring valuations as possible, while staying simple for humans to write and programs to manipulate.

DefinitionAtoms, OR, XOR

The atoms are single-minded bids (S,p)(S,p). Two semantics for combining them: OR treats the bids as independent, allowing any subset to be fulfilled; XOR treats them as mutually exclusive, allowing only one.

v=(S1,p1) XOR⋯XOR (Sk,pk):v(S)=max⁡i:Si⊆Spiv = (S_1,p_1)\ \mathrm{XOR}\cdots\mathrm{XOR}\ (S_k,p_k): \quad v(S) = \max_{i : S_i\subseteq S}p_i

For OR, v(S)v(S) is the maximum over all valid collections WW (pairwise disjoint SiS_i) of ∑i∈Wpi\sum_{i\in W}p_i.

ExampleWhere they differ

Both ”({a,b},3)(\{a,b\},3) XOR ({c,d},5)(\{c,d\},5)” and the OR version value {a,c}\{a,c\} at 0 and {a,b}\{a,b\} at 3. They differ on {a,b,c,d}\{a,b,c,d\}: 5 for XOR (the best atom satisfied) versus 8 for OR. And ”({a,b},3)(\{a,b\},3) OR ({a,c},5)(\{a,c\},5)” values {a,b,c}\{a,b,c\} at 5, since both atoms cannot be satisfied together.

ImportantExpressiveness and size

XOR can represent every valuation — just XOR the atoms (S,v(S))(S,v(S)) for all bundles. OR can represent only superadditive valuations, since the atoms giving v(S)v(S) and v(T)v(T) are disjoint and get added; all superadditive valuations are representable this way.

But size — the number of atoms — is what matters:

ValuationDefinitionORXOR
Additivev(S)=∑j∈Sv({j})v(S)=\sum_{j\in S}v(\{j\})size mmexponential (2m−12^m-1 atoms)
Unit demandv(S)=max⁡j∈Sv({j})v(S)=\max_{j\in S}v(\{j\})impossible (never superadditive)size mm

DefinitionCombining the two

(v XOR u)(S)=max⁡(v(S),u(S))(v\ \mathrm{XOR}\ u)(S) = \max(v(S),u(S)) and (v OR u)(S)=max⁡R,T⊆S, R∩T=∅v(R)+u(T)(v\ \mathrm{OR}\ u)(S) = \max_{R,T\subseteq S,\ R\cap T=\emptyset}v(R)+u(T), giving general OR/XOR formulae. For instance (({a,b},3) XOR ({c},2)) OR ({d},5)((\{a,b\},3)\ \mathrm{XOR}\ (\{c\},2))\ \mathrm{OR}\ (\{d\},5) values {a,b,c}\{a,b,c\} at 3 and {a,b,d}\{a,b,d\} at 8.

ExampleOR-of-XORs and downward sloping valuations

vv is symmetric if v(S)v(S) depends only on ∣S∣|S|, and downward sloping if v(S)=∑j≤∣S∣pjv(S)=\sum_{j\le|S|}p_j with p1≥⋯≥pm≥0p_1\ge\cdots\ge p_m\ge0. Such a valuation with strict inequalities requires XOR bids of size 2m−12^m-1 and cannot be represented by OR at all.

OR-of-XORs does it in size m2m^2: one clause per jj offering pjp_j for any single item (a simple XOR bid), with the mm clauses joined by OR. Since the pjp_j decrease, the first allocated item comes from the first clause, the second from the second, and so on.

Dummy items

ImportantRepresenting XOR inside OR

General OR/XOR formulae look hard to handle algorithmically. Luckily a generalization makes things simple again. Let each bidder ii have private dummy items DiD_i with no intrinsic value; an OR* bid is an OR bid over M∪DiM\cup D_i, valuing S⊆MS\subseteq M by what the OR bid gives S∪DiS\cup D_i.

The idea: (S1,p1)(S_1,p_1) XOR (S2,p2)(S_2,p_2) becomes (S1∪{d},p1)(S_1\cup\{d\},p_1) OR (S2∪{d},p2)(S_2\cup\{d\},p_2). For M={a,b,c}M=\{a,b,c\}, the OR* bid ({a,d},1)(\{a,d\},1) OR ({b,d},1)(\{b,d\},1) OR ({c},1)(\{c\},1) equals (({a},1) XOR ({b},1)) OR ({c},1)((\{a\},1)\ \mathrm{XOR}\ (\{b\},1))\ \mathrm{OR}\ (\{c\},1).

A more appealing user interface: let bidders report atomic bids plus constraints saying which are mutually exclusive; each constraint becomes a dummy item added to the conflicting atoms.

TheoremOR* simulates general OR/XOR formulae

Any valuation representable by an OR/XOR formula of size ss is representable by OR* bids of size ss, using at most s2s^2 dummy items.

ProofInduction on formula structure, then prune the dummies

Base: an atomic bid is already an OR* bid. OR step: merge the clause sets of the sub-bids. XOR step: for each pair of atoms (S,v)(S,v), (T,v′)(T,v') in two different sub-bids, introduce a dummy xSTx_{ST}; each bid (S,v)(S,v) becomes (S∪{xST∣T},v)(S\cup\{x_{ST}\mid T\},v) where TT ranges over atoms of all other sub-bids.

This gives exactly ss clauses, but possibly many dummies. The only role of a dummy is to forbid two or more atoms being taken together, so replace them all with at most (s2)\binom s2 new dummies, one per forbidden pair, added to both atoms of that pair.

∎

ImportantWhy this matters for algorithms

The simulation is a compiler from OR/XOR formulae to OR* bids, with an extremely appealing implication: to a winner-determination algorithm, an OR* bid looks just like a regular OR bid on a larger item set — and an OR bid looks just like a collection of atomic bids from different players.

So any allocation algorithm handling single-minded bids immediately handles general valuations represented as OR* bids or general OR/XOR formulae. All the heuristics mentioned earlier apply.


Iterative auctions and the query model

The alternative to encoding. Rather than having bidders send their valuation, the auction repeatedly interacts with them, adaptively eliciting enough information to find a good allocation.

IntuitionThree benefits of adaptivity

It may pinpoint the relevant information rather than requiring full disclosure, reducing communication and associated complexities. It preserves privacy, revealing only what is required. And in real settings bidders may need to exert effort even to determine their own valuation (collecting data, hiring consultants) — iterative mechanisms guide their attention to the relevant data.

DefinitionTwo query types

Bidders are modelled as oracles; the auctioneer must be efficient both in the number of queries and in internal computation — polynomial in mm, nn, and the bits of precision.

  • Value query: the auctioneer presents SS, the bidder reports v(S)v(S).
  • Demand query (item prices): the auctioneer presents prices p1,…,pmp_1,\ldots,p_m; the bidder reports some SS maximizing v(S)−∑i∈Spiv(S)-\sum_{i\in S}p_i.

NoteHow hard is it to answer?

This depends on the bidder’s internal representation — intractable for some, trivial for others. In many realistic situations bidders have no explicit internal representation at all, but “know” their valuation only in the sense of being able to answer such queries.

LemmaDemand queries are strictly stronger

A value query can be simulated by mtmt demand queries (tt = bits of precision); an exponential number of value queries may be required to simulate one demand query.

ProofMarginal values by binary search

To compute the marginal value v(S∪{j})−v(S)v(S\cup\{j\})-v(S): set pi=0p_i=0 for i∈Si\in S, pi=∞p_i=\infty for i∉S∪{j}i\notin S\cup\{j\}, and binary search on pjp_j — the highest pjp_j whose demand contains jj is the marginal value. Then v(S)=∑j∈S(v({i∈S:i≤j})−v({i∈S:i<j}))v(S) = \sum_{j\in S}\big(v(\{i\in S : i\le j\}) - v(\{i\in S : i<j\})\big).

∎

Solving the linear program

TheoremDemand queries solve LPR

LPR can be solved in polynomial time (in nn, mm, and precision) using only demand queries with item prices — surprising, since the LP has exponentially many variables.

ProofEllipsoid on the dual, with a demand query as separation oracle

The dual has only n+mn+m variables but exponentially many constraints; the ellipsoid method runs in polynomial time on such programs given a separation oracle.

Rewrite the dual constraint as ui≥vi(S)−∑j∈Spju_i\ge v_i(S)-\sum_{j\in S}p_j. A demand query to bidder ii at prices pp reveals exactly the SS maximizing the right-hand side. So to test feasibility of (u,p)(u,p): query each bidder for his demand DiD_i, and check only the nn constraints ui+∑j∈Dipj≥vi(Di)u_i+\sum_{j\in D_i}p_j\ge v_i(D_i) (with vi(Di)v_i(D_i) simulated by demand queries). If none is violated, (u,p)(u,p) is feasible; otherwise we have a violated constraint.

Recovering the primal. Ellipsoid encounters only polynomially many constraints; deleting the rest leaves the same dual optimum. Take the dual of that reduced program — same solution as the original primal, but with polynomially many variables — solve it, and set all other variables to zero.

∎

NoteClasses of valuations, and where the results live

Gen⊃SubA⊃XOS⊃SubM⊃Subs\mathrm{Gen}\supset\mathrm{SubA}\supset\mathrm{XOS}\supset\mathrm{SubM}\supset\mathrm{Subs}: general; subadditive (v(S∪T)≤v(S)+v(T)v(S\cup T)\le v(S)+v(T)); XOS (representable by XOR-of-ORs with singleton atoms); submodular (v(S)+v(T)≥v(S∪T)+v(S∩T)v(S)+v(T)\ge v(S\cup T)+v(S\cap T)); substitutes (below). Also kkDup (kk duplicates of each good, each bidder wanting at most one of each) and Proc (procurement, a buyer minimizing total cost paid to nn suppliers).


Communication complexity

The question. Solving the allocation problem is NP-complete, yet in practice thousands of items can be handled. Is representation an obstacle beyond the computational hardness? The answer is yes: even with unlimited computational power, eliciting enough information requires exponentially many queries — for any query type.

DefinitionYao’s two-party model

Alice and Bob hold monotone valuations v1,v2:2M→{0,1}v_1,v_2 : 2^M\to\{0,1\} and must run a protocol ending in an allocation (S,Sc)(S,S^c) maximizing v1(S)+v2(Sc)v_1(S)+v_2(S^c). Alice’s message may depend only on v1v_1 and Bob’s prior messages, and vice versa. No computational constraints — only communication is measured.

TheoremExponential communication lower bound

Every protocol finding the optimal allocation for every pair of 0/1 valuations must use at least (mm/2)\binom{m}{m/2} bits in the worst case.

(By Stirling, (mm/2)∼2/(πm)⋅2m\binom{m}{m/2}\sim\sqrt{2/(\pi m)}\cdot 2^m.)

ImportantWhy this applies everywhere

Yao’s model is very powerful, so the bound applies to essentially all settings where v1v_1 and v2v_2 reside in different places: to bidders answering an auctioneer’s queries (a protocol with an auctioneer converts to one without, by having Alice and Bob exchange replies and simulate the auctioneer), and to any larger number of bidders (two bidders is the special case where all others have null valuations).

ProofA fooling set of dual valuation pairs

For a 0/1 valuation vv define the dual v∗(S)=1−v(Sc)v^*(S) = 1-v(S^c). Note v∗v^* is a monotone 0/1 valuation, and for every partition, v(S)+v∗(Sc)=1v(S)+v^*(S^c) = 1.

Key lemma: for v≠uv\ne u, the communication sequence on (v,v∗)(v,v^*) differs from that on (u,u∗)(u,u^*).

Suppose not. Then the same sequence occurs on (v,u∗)(v,u^*): Alice does not see u∗u^* so she behaves as in (v,v∗)(v,v^*); Bob behaves as in (u,u∗)(u,u^*); neither ever notices a deviation. Likewise for (u,v∗)(u,v^*). So one allocation (S,Sc)(S,S^c) is produced in all four cases — impossible.

Since u≠vu\ne v there is TT with, WLOG, v(T)=1v(T)=1 and u(T)=0u(T)=0, so v(T)+u∗(Tc)=2v(T)+u^*(T^c)=2 and optimality on (v,u∗)(v,u^*) forces v(S)+u∗(Sc)≥2v(S)+u^*(S^c)\ge2. But (v(S)+v∗(Sc))+(u(S)+u∗(Sc))=2(v(S)+v^*(S^c))+(u(S)+u^*(S^c)) = 2, so u(S)+v∗(Sc)≤0u(S)+v^*(S^c)\le0 — the allocation is not optimal for (u,v∗)(u,v^*), contradiction.

From the lemma to the bound: the number of communication sequences is at least the number of distinct 0/1 valuations, which is at least 2(mm/2)2^{\binom{m}{m/2}} (count valuations that are 0 below size m/2m/2, 1 above, and free at size m/2m/2). A binary sequence set of that size needs one sequence of length ≥(mm/2)\ge\binom{m}{m/2}.

∎

TheoremApproximation is hard too

For every ϵ>0\epsilon>0, approximating the social welfare to within a factor strictly smaller than min⁡{n,m1/2−ϵ}\min\{n, m^{1/2-\epsilon}\} requires exponential communication.

NoteThis is tight

A factor of nn is trivial (bundle everything and run a single-item auction), and for n≥mn\ge\sqrt m there is an O(m)O(\sqrt m) approximation. Most of the known lower bounds in this area are communication-complexity results.


Ascending auctions

These are iterative auctions with demand queries in which prices only increase. The auctioneer publishes prices, initially zero; bidders respond with their most desired bundle; the auctioneer raises some prices; repeat until an allocation can be declared.

IntuitionWhy they are popular

Their intuitiveness; the fact that private information is only partially revealed; that it is clear they terminate; and that they may increase the seller’s revenue in some settings. This class contains the vast majority of implemented or suggested combinatorial auction designs.

Item-price ascending auctions

AlgorithmThe natural ascending auction

Increase prices gradually, maintaining a tentative allocation, until no item tentatively held by one bidder is demanded by another. Intuitively, at that point demand equals supply and we are near a Walrasian equilibrium, hence near efficient.

WarningThe failure mode, and the class that avoids it

We know Walrasian equilibria do not always exist. The problem is that the auction does not ensure items are not underdemanded: an item previously demanded may cease to be.

Definition(Gross) substitutes

viv_i satisfies substitutes if for item prices q≥pq\ge p coordinatewise, every demand at pp has a demand at qq containing all items whose price stayed the same. Formally, for A∈arg⁡max⁡S{v(S)−∑j∈Spj}A\in\arg\max_S\{v(S)-\sum_{j\in S}p_j\} there is D∈arg⁡max⁡S{v(S)−∑j∈Sqj}D\in\arg\max_S\{v(S)-\sum_{j\in S}q_j\} with D⊇{j∈A∣pj=qj}D\supseteq\{j\in A\mid p_j=q_j\}.

The only items that can drop from the demand are those whose price strictly increased — this rules out any form of complementarity.

ExampleWhat substitutes excludes, and includes

A single-minded bidder willing to pay 10 for {a,b}\{a,b\} demands both at prices (3,3)(3,3), but if pbp_b rises to 8 he demands nothing — contrary to substitutes. In general substitutes valuations must be submodular, and the class contains additive, unit-demand, and downward-sloping valuations.

Definitionϵ\epsilon-Walrasian equilibrium

An allocation and prices with ⋃iSi⊇{j∣pj>0}\bigcup_iS_i\supseteq\{j\mid p_j>0\}, where each SiS_i is a demand of ii at prices pjp_j for j∈Sij\in S_i and pj+ϵp_j+\epsilon for j∉Sij\notin S_i.

TheoremConvergence under substitutes

For bidders with substitutes valuations, the ascending auction ends with an ϵ\epsilon-Walrasian equilibrium; in particular the welfare is within nϵn\epsilon of optimal.

ProofThe invariant Si⊆DiS_i\subseteq D_i

Claim: at every stage, Si⊆DiS_i\subseteq D_i for every bidder. True initially. Consider an update step for bidder ii: for ii himself, SiS_i afterwards equals DiD_i exactly (the price changes on newly added items match those defining DiD_i). For k≠ik\ne i, two things can happen — items may be taken from SkS_k by ii, which shrinks SkS_k without affecting DkD_k; and prices outside SkS_k may rise, which does not affect SkS_k, while substitutes directly implies the only items that can leave DkD_k are those whose price strictly increased, hence not in SkS_k.

Given the claim, no item ever demanded is left unallocated, so ⋃iSi\bigcup_iS_i contains every positively priced item; termination requires all Di=SiD_i=S_i. Near-optimality follows as in the First Welfare Theorem.

∎

NoteTermination and the primal-dual reading

Since prices only rise, the algorithm terminates within m⋅vmax⁡/ϵm\cdot v_{\max}/\epsilon stages. It may also be viewed as a primal-dual algorithm: start from a feasible dual solution (zero prices) and, while complementary slackness is unsatisfied, improve the dual by raising prices.

WarningStrategic behavior: two separate problems

With complementarities, the exposure problem. Bidders bidding for a complementary bundle (a pair of shoes) risk having part taken from them later, leaving them liable for the price of the rest (the right shoe), which is worthless alone.

Even with substitutes, incentives are not solved. Walrasian prices are not necessarily VCG prices, so truthful bidding is not an ex-post equilibrium. The weakness is demand reduction: bidders may demand smaller bundles to lower their payments.

ExampleDemand reduction

v(a)v(a)v(b)v(b)v(ab)v(ab)
Alice444
Bob5510

The auction terminates at pa=pb=4p_a=p_b=4 with Bob winning both, earning him 2. If Bob bids only on aa, the auction stops at zero prices, allocating aa to Bob and bb to Alice — improving Bob’s payoff to 5.

Bundle-price ascending auctions

DefinitionCompetitive equilibrium with personalized bundle prices

Prices pi(S)p_i(S) per bidder and bundle, with an allocation, such that (i) each SiS_i is a demand at pip_i, and (ii) the allocation maximizes the seller’s revenue: ∑ipi(Si)≥∑ipi(Ti)\sum_ip_i(S_i)\ge\sum_ip_i(T_i) for every other allocation.

ImportantThese always exist — and still give efficiency

Any welfare-maximizing allocation with pi(S)=vi(S)p_i(S)=v_i(S) is a competitive equilibrium (a Second Welfare Theorem for this setting). And even this weak notion guarantees optimal welfare: summing the demand inequalities vi(Si)−pi(Si)≥vi(Ti)−pi(Ti)v_i(S_i)-p_i(S_i)\ge v_i(T_i)-p_i(T_i) over bidders, together with revenue maximality, gives that SS beats any TT.

AlgorithmThe bundle-price auction

At each stage the auctioneer computes a tentative allocation maximizing his revenue at current prices — viewed as the current bids. All losing bidders then raise their bids on their currently demanded bundle. Terminate when no losing bidder is willing to do so.

TheoremTermination at an ϵ\epsilon-competitive equilibrium

For any profile of valuations the auction terminates with an ϵ\epsilon-competitive equilibrium; the welfare is within nϵn\epsilon of optimal.

(An ϵ\epsilon-demand satisfies vi(S)−pi(S)≥vi(T)−pi(T)−ϵv_i(S)-p_i(S)\ge v_i(T)-p_i(T)-\epsilon.)

ProofThe maintained invariant

Each step raises at least one price and a bundle price never exceeds its value, so the auction terminates. The allocation is revenue-maximizing by construction, so it suffices that each bidder gets an ϵ\epsilon-demand. Losers get ∅\emptyset, their demand, by the termination condition. For a winner, the auction maintains that every bundle with pi(Ti)>0p_i(T_i)>0 is an ϵ\epsilon-demand: such a TiT_i was ii‘s exact demand at some earlier round, hence an ϵ\epsilon-demand after the increment, and since then only other bundles’ prices have risen.

∎

WarningTwo exponential costs, and a strategic one

The number of stages may be exponential, and each stage requires solving an NP-hard optimization. We know this is unavoidable. Variants may be faster by letting bidders report a collection of demand bundles per stage.

The prices are not VCG prices, so players are not motivated to bid myopically and truthfully. One weak positive: with proxy bidding (each bidder committed in advance to a fixed valuation) the auction admits ex-post Nash equilibria, though these require considerable knowledge of others’ preferences. Charging VCG prices instead would make truthful bidding an ex-post Nash equilibrium, but loses nice properties of the equilibrium prices such as resistance to collusion and to false-name bids.


Single-dimensional domains: job scheduling

The framing. Algorithms and mechanisms are close in nature — both implement desirable properties drawn from real needs — but the two sets of properties are completely different, and merging them poses difficult challenges. Classic mechanism design solutions are mostly not computationally efficient; classic algorithmic techniques mostly do not yield the game-theoretic needs.

ImportantDimensionality is the key variable

In single-dimensional domains, truthfulness reduces to a convenient algorithmic monotonicity condition leaving ample flexibility. Multidimensionality poses much harder obstacles. This section demonstrates the easy case.

DefinitionScheduling related machines

nn jobs assigned to mm machines; job jj consumes pjp_j time-units, machine ii has speed sis_i, so it needs pj/sip_j/s_i time. With load li=∑j→ipjl_i = \sum_{j\to i}p_j, the goal is to minimize the makespan max⁡ili/si\max_i l_i/s_i. Each machine is selfish with unit cost per time unit, so utility is −li/si−Pi-l_i/s_i - P_i. The mechanism designer knows the processing times.

DefinitionSingle-dimensional linear domain

ViV_i is single-dimensional and linear if there are constants (loads) {qi,a}a∈A\{q_{i,a}\}_{a\in A} such that every vi∈Viv_i\in V_i has vi(a)=qi,a⋅cv_i(a)=q_{i,a}\cdot c for some c∈R−c\in\mathbb{R}_- (the cost).

The player’s type is simply her cost cc, which discloses the entire valuation vector. Scheduling fits: c=1/sic=1/s_i and qi,aq_{i,a} is the load assigned by aa.

ImportantTwo CS-versus-economics differences visible here

Different objectives: economics studies welfare and revenue maximization, while computational models raise entirely different goals — here a min-max criterion. Existing incentive-compatible techniques do not fit such objectives, and existing algorithmic solutions do not yield the incentives. Different models and analysis conventions (online arrival, worst-case rather than distributional) are further sources of clash.

DerivationMonotonicity and the price formula

Fixing c−ic_{-i}, the algorithm determines a load qi(c)q_i(c). For c′>cc'>c the weak monotonicity condition reduces to −qi(c′)(c′−c)≥−qi(c)(c′−c)-q_i(c')(c'-c)\ge -q_i(c)(c'-c), which holds iff qi(c′)≤qi(c)q_i(c')\le q_i(c) — the load function is nonincreasing.

Charge Pi(c)=∫0c[qi(x)−qi(c)]dxP_i(c) = \int_0^c[q_i(x)-q_i(c)]dx. Truthful utility is the area under the load curve up to cc. Reporting c′>cc'>c loses exactly the area AA: the cost from the load falls to c⋅qi(c′)c\cdot q_i(c') but the payment rises to the area between the line qi(c′)q_i(c') and the curve. Reporting c′<cc'<c loses area BB, since the cost rises to c⋅qi(c′)c\cdot q_i(c').

These prices violate individual rationality (utility is always negative), so add the constant ∫0∞qi(x)dx\int_0^\infty q_i(x)dx — then a machine declaring infinite cost gets zero utility and a truthful player gets ∫c∞qi(x)dx≥0\int_c^\infty q_i(x)dx\ge0.

TheoremCharacterization for single-dimensional linear domains

An algorithm is implementable iff its load functions are nonincreasing, and then the prices

Pi(c)=∫0c[qi(x)−qi(c)]dx−∫c∞qi(x) dxP_i(c) = \int_0^c\big[q_i(x)-q_i(c)\big]dx - \int_c^\infty q_i(x)\,dx

give an individually rational dominant-strategy implementation. Truthfulness in expectation is equivalent to monotonicity of the expected load.

A monotone approximation algorithm

Order s1≥⋯≥sms_1\ge\cdots\ge s_m and p1≥⋯≥pnp_1\ge\cdots\ge p_n. (The optimum itself is implementable but NP-hard to compute, so we need a monotone polynomial-time approximation — a purely algorithmic problem, with no game theory left.)

DerivationEstimating the optimal makespan

Fix job jj and target TT. Any schedule with makespan ≤T\le T assigns each of jobs 1..j1..j to a machine with T≥pj/siT\ge p_j/s_i; let i(j,T)=max⁡{i∣T≥pj/si}i(j,T)=\max\{i\mid T\ge p_j/s_i\}. By space considerations,

T ≥ ∑k≤jpk∑l≤i(j,T)slT\ \ge\ \frac{\sum_{k\le j}p_k}{\sum_{l\le i(j,T)}s_l}

Define Tj=min⁡imax⁡{pjsi, ∑k≤jpk∑l≤isl}T_j = \min_i\max\Big\{\frac{p_j}{s_i},\ \frac{\sum_{k\le j}p_k}{\sum_{l\le i}s_l}\Big\}. Then the optimal makespan is at least TjT_j: for T<TjT<T_j, with iji_j the minimizing index, the left term increases in ii and the right decreases, so iji_j is either the last index where the right term dominates or the first where the left does; in either case TT violates the displayed inequality.

Hence TLB=max⁡jTjT_{LB} = \max_jT_j lower bounds the optimum.

DefinitionThe fractional allocation

Let jj be the first job with ∑k≤jpk>TLB⋅s1\sum_{k\le j}p_k > T_{LB}\cdot s_1. Assign to machine 1 jobs 1..j−11..j-1 plus a fraction of jj to make l1=TLBs1l_1 = T_{LB}s_1; recurse on the remaining fractions and machines 2..m2..m.

ProofFeasibility and monotonicity of the fractional allocation

Feasibility: since TLB≥Tj≥∑k≤jpk∑l≤ijslT_{LB}\ge T_j\ge\frac{\sum_{k\le j}p_k}{\sum_{l\le i_j}s_l} we can fractionally assign jobs 1..j1..j within the first iji_j machines; and Tj≥pj/sijT_j\ge p_j/s_{i_j} gives pj/si≤TLBp_j/s_i\le T_{LB} whenever jj lands on ii. Setting j=nj=n gives full assignment.

Monotonicity: if sis_i rises to αsi\alpha s_i, then TLB′≤αTLBT_{LB}'\le\alpha T_{LB} (scaling all speeds by α\alpha scales TLBT_{LB} by α\alpha, and the actual other speeds are no larger). If ii was full, li′≤TLB′si≤αTLBsi=li′l_i' \le T_{LB}'s_i \le \alpha T_{LB}s_i = l_i'… more precisely li′≤TLB′si≤TLBαsil_i'\le T'_{LB}s_i\le T_{LB}\alpha s_i, matching. Otherwise ii is the last nonempty machine, and since TLB′≥TLBT_{LB}'\ge T_{LB} all earlier machines take at least as much as before, so ii cannot gain load.

∎

WarningThe natural rounding is not monotone

Integrally placing each job on one of the machines holding a fraction gives a 2-approximation but violates monotonicity. Two alternatives follow: a randomized rounding (simpler, better ratio, weaker solution concept) and a deterministic one (more involved, deterministic truthfulness, worse ratio).

TheoremRandomized rounding

Choose α∈[0,1]\alpha\in[0,1] uniformly. For each job jj split between ii and i+1i+1, assign it fully to ii if jj‘s fraction on ii is at least α\alpha, else to i+1i+1. This is truthful in expectation and gives a 2-approximation in polynomial time.

ProofApproximation, then the expected-load argument

Approximation: machine ii may get two extra jobs — jj shared with i−1i-1 and kk shared with i+1i+1. If jj rounds to ii then ii had at least 1−α1-\alpha of it, so the extra load is at most αpj\alpha p_j; similarly at most (1−α)pk(1-\alpha)p_k for kk. Since max⁡{pj,pk}≤TLB\max\{p_j,p_k\}\le T_{LB}, the total extra is at most TLBT_{LB}.

Truthfulness: machine i−1i-1 gets jj with probability α\alpha, so ii gets it with probability 1−α1-\alpha, and gets kk with probability α\alpha — so the expected load equals the fractional load, which is monotone.

∎

AlgorithmThe deterministic variant, via virtual speeds
  1. Set virtual speeds: d1=85s1d_1 = \frac85 s_1, and for i≥2i\ge2 let did_i be the closest breakpoint s12.5i\frac{s_1}{2.5^i} with di≤sid_i\le s_i. (The fastest machine is made slightly faster, the others slightly slower.)
  2. Compute TLBT_{LB} from the virtual speeds.
  3. Assign jobs largest-first, fastest-first, moving to the next machine when the current one holds total processing time ≥TLBdi\ge T_{LB}d_i.

This is exactly the natural rounding that previously failed — but on the did_i rather than the sis_i, which is what enables monotonicity, at the cost of approximation.

The loss: TLB(d)≤2.5 TLB(s)T_{LB}(d)\le2.5\,T_{LB}(s) since speeds were slowed by at most that factor. On machine 1, since s1<d1s_1<d_1, the load may be 1.6TLB(d)≤4TLB(s)1.6T_{LB}(d)\le4T_{LB}(s); with one extra partial job, and using d1≥4d2d_1\ge4d_2, the total is 54⋅1.6TLB(d)≤5TLB(s)\frac54\cdot1.6T_{LB}(d)\le5T_{LB}(s). On any other machine di≤sid_i\le s_i, so after the extra job the load is at most 2TLB(d)di≤5TLB(s)si2T_{LB}(d)d_i\le5T_{LB}(s)s_i.

ProofMonotonicity of the deterministic algorithm

Three observations. (a) For i>1i>1 and β<di\beta<d_i, TLB(β,d−i)≤54TLB(di,d−i)T_{LB}(\beta,d_{-i})\le\frac54T_{LB}(d_i,d_{-i}): give machine ii nothing and shift each earlier machine’s jobs down one; machines 2..i−12..i-1 stay under the limit since each is faster than its successor, and machine 1 gains at most a factor 54\frac54 since always d1≥4d2d_1\ge4d_2. (b) If a machine i>1i>1 slows, the work on faster machines does not decrease, since TLBT_{LB} is monotone. (c) If the fastest machine slows but stays fastest, its work does not increase: all breakpoints shift by the same factor cc, so if no sis_i crosses a new breakpoint everything scales and machine 1 keeps the same jobs; if some do, their did_i fall, so TLBT_{LB} falls and machine 1 gets no more.

Now suppose ii slows to si′s_i'. If ii is fastest and stays so, use (c). If the title of fastest passes to i′i', insert an artificial breakpoint where their speeds coincide; ii‘s work as fastest is at least 85siT\frac85s_iT while its work once i′i' is fastest is at most 2s12.5T<85siT2\frac{s_1}{2.5}T<\frac85s_iT. If ii is not fastest but full, then di′<did_i'<d_i so by (a) its work goes from ≥Tdi\ge Td_i to at most 2⋅54Tdi2.5=Tdi2\cdot\frac54T\frac{d_i}{2.5}=Td_i. If ii is not full, use (b).

∎

TheoremDeterministic result

There is a truthful deterministic mechanism for scheduling related machines approximating the makespan within a factor of 5.

NoteComputing the prices, and an open problem

Prices require integrating the load function with others’ speeds fixed. In both cases this is a step function with polynomially many steps — declaring a large enough speed wins all jobs, and as speed falls the assigned set shrinks monotonically — so price computation is polynomial.

Without monotonicity a PTAS exists. Open: does there exist a truthful PTAS for related machines?


Multidimensional domains: the decomposition technique

The clash, stated sharply. For general combinatorial auctions, Ω(m1/2−ϵ)\Omega(m^{1/2-\epsilon}) is the computational and communication barrier, and O(m)O(\sqrt m) is achievable deterministically — so the computational status alone is well understood. The incentives status alone is also well understood — VCG, which needs the exact optimum. The two clash if we use classic techniques.

ImportantThe plan

A general LP-based technique using randomness: given any algorithm producing a cc-approximation to the optimal fractional welfare, construct a randomized cc-approximation mechanism that is truthful in expectation. The same approximation guarantee is maintained. Three steps: the fractional domain, the transition back, and the decomposition itself.

FormulaThe fractional relaxation (CA-P)

max⁡ ∑i,S≠∅xi,Svi(S)s.t.∑S≠∅xi,S≤1 ∀i,∑i∑S:j∈Sxi,S≤1 ∀j,xi,S≥0\max\ \sum_{i,S\ne\emptyset}x_{i,S}v_i(S) \quad\text{s.t.}\quad \sum_{S\ne\emptyset}x_{i,S}\le1\ \forall i, \qquad \sum_i\sum_{S:j\in S}x_{i,S}\le1\ \forall j, \qquad x_{i,S}\ge0

(The empty set is excluded for technical reasons.) Solvable by ellipsoid: with bidding languages the LP is polynomial in the bid size; with query access it needs polynomially many demand queries. Either way the number of nonzero coordinates is polynomial, which matters below.

PropositionThe fractional case is easy

Since we obtain the optimal fractional allocation, VCG applies: there is a truthful optimal mechanism with efficient computation and communication, in both models.

DefinitionIntegrality-gap verifier

AA verifies a cc-integrality-gap for CA-P if, given real numbers wi,Sw_{i,S}, it outputs a feasible integral x~\tilde x with c∑i,Swi,Sx~i,S ≥ max⁡feasible x∑i,Swi,Sxi,Sc\sum_{i,S}w_{i,S}\tilde x_{i,S}\ \ge\ \max_{\text{feasible }x}\sum_{i,S}w_{i,S}x_{i,S}.

LemmaThe decomposition lemma

If AA verifies a cc-integrality-gap in polynomial time and xx is feasible for CA-P, then x/cx/c can be decomposed into a convex combination of integral feasible points — in polynomial time.

AlgorithmThe decomposition-based mechanism

  1. Compute the optimal fractional x∗x^* and the VCG fractional prices piF(v)p_i^F(v).
  2. Obtain a decomposition x∗/c=∑l∈Iλlxlx^*/c = \sum_{l\in I}\lambda_l x^l.
  3. With probability λl\lambda_l: choose allocation xlx^l and set prices piR(v)=[vi(xl)/vi(x∗)] piF(v)p_i^R(v) = [v_i(x^l)/v_i(x^*)]\,p_i^F(v).

NoteWhy these prices

The strategic properties hold whenever the expected price equals the fractional price over cc. These particular prices additionally give strong individual rationality — truth-telling ensures nonnegative utility regardless of the coin toss — since VCG is individually rational, so piF(v)≤vi(x∗)p_i^F(v)\le v_i(x^*) and hence piR(v)≤vi(xl)p_i^R(v)\le v_i(x^l) for every ll.

ProofTruthfulness in expectation

Expected price. Using the decomposition,

Eλ[piR(v)]=piF(v)vi(x∗)∑lλlvi(xl)=piF(v)vi(x∗)⋅vi(x∗/c)=piF(v)c\mathbb{E}_{\lambda}\big[p_i^R(v)\big] = \frac{p_i^F(v)}{v_i(x^*)}\sum_l\lambda_lv_i(x^l) = \frac{p_i^F(v)}{v_i(x^*)}\cdot v_i(x^*/c) = \frac{p_i^F(v)}{c}

Truthfulness. Fix v−iv_{-i}; let x∗x^* and z∗z^* be the fractional optima under viv_i and vi′v_i'. Fractional VCG gives vi(x∗)−piF(vi,v−i)≥vi(z∗)−piF(vi′,v−i)v_i(x^*)-p_i^F(v_i,v_{-i})\ge v_i(z^*)-p_i^F(v_i',v_{-i}). Dividing by cc and using the expected-price identity turns the two sides into the expected utilities of declaring viv_i and vi′v_i'.

Approximation. The expected welfare is 1c∑ivi(x∗)\frac1c\sum_iv_i(x^*), and x∗x^* is the fractional optimum.

∎

WarningEx-post Nash in the query model

The analysis above is for one-shot mechanisms. With iterative queries the concept weakens to ex-post Nash: if all others answer truthfully, ii maximizes his expected utility by being truthful.

(Analogy: a single-item auction where I bids first and II observes. Truthfulness is not dominant — if II plays “bid 20 if I bids above 5, else bid 2”, then I with value 6 should declare 5. But truthfulness is ex-post Nash: against any fixed bid by II, I’s best response is the truth.)

DerivationComputing the decomposition

Write the primal PP (minimize ∑lλl\sum_l\lambda_l subject to ∑lλlxi,Sl=xi,S/c\sum_l\lambda_lx_{i,S}^l = x_{i,S}/c for (i,S)∈E(i,S)\in E and ∑lλl≥1\sum_l\lambda_l\ge1) and its dual DD (maximize 1c∑(i,S)∈Exi,Swi,S+z\frac1c\sum_{(i,S)\in E}x_{i,S}w_{i,S}+z subject to ∑(i,S)∈Exi,Slwi,S+z≤1\sum_{(i,S)\in E}x_{i,S}^lw_{i,S}+z\le1 for every integral xlx^l), where E={(i,S)∣xi,S>0}E=\{(i,S)\mid x_{i,S}>0\} is of polynomial size.

PP has exponentially many variables; DD has polynomially many variables but exponentially many constraints. The verifier AA is the separation oracle: if 1c∑Exi,Swi,S+z>1\frac1c\sum_Ex_{i,S}w_{i,S}+z>1, feed ww to AA to get xlx^l with ∑Exi,Slwi,S≥1c∑Exi,Swi,S>1−z\sum_Ex^l_{i,S}w_{i,S}\ge\frac1c\sum_Ex_{i,S}w_{i,S}>1-z — a violated constraint.

Hence the optimum of DD is exactly 1 (z=1,w=0z=1,w=0 is feasible, and the claim bounds it above). Ellipsoid touches only polynomially many constraints; keeping just those gives an equivalent program whose dual is equivalent to PP with polynomially many variables, which we solve directly.

ProofBuilding the verifier from an ordinary approximation

Two things differentiate a verifier from a “regular” cc-approximation: it cannot assume any structure on the weights (they may be negative and non-monotone), and it must compare against the fractional optimum. The first is not a problem.

Given ww, define wi,S+=max⁡(wi,S,0)w^+_{i,S}=\max(w_{i,S},0) and w~i,S=max⁡T⊆S,(i,T)∈Ewi,T+\tilde w_{i,S} = \max_{T\subseteq S,(i,T)\in E}w^+_{i,T} — a valid valuation, succinctly representable with size ∣E∣|E|. Feed w~\tilde w to the approximation to get x~\tilde x. Two discrepancies remain: the sum over EE may miss coordinates, and some wi,Sw_{i,S} may be negative. Fix the first by setting, for each x~i,S=1\tilde x_{i,S}=1, the coordinate xi,T+=1x^+_{i,T}=1 for T=arg⁡max⁡T⊆S,(i,T)∈Ewi,T+T=\arg\max_{T\subseteq S,(i,T)\in E}w^+_{i,T}; fix the second by zeroing the coordinates with wi,S<0w_{i,S}<0. The result is feasible with the same objective value.

∎

AlgorithmGreedy as an integrality-gap verifier

Given {wi,S}(i,S)∈E\{w_{i,S}\}_{(i,S)\in E}: repeatedly pick (i,S)=arg⁡max⁡(i′,S′)∈Ewi′,S′/∣S′∣(i,S)=\arg\max_{(i',S')\in E}w_{i',S'}/\sqrt{|S'|}, set xi,S=1x_{i,S}=1, and remove from EE all (i′,S′)(i',S') with i′=ii'=i or S′∩S≠∅S'\cap S\ne\emptyset.

ProofGreedy verifies a 2m\sqrt2\sqrt m integrality gap

Let yy be the optimal fractional allocation, and for each winner ii let YiY_i be the positively weighted pairs removed when (i,Si)(i,S_i) was added. Then

∑(i′,S)∈Yiyi′,Swi′,S≤wi,Si∣Si∣∑Yiyi′,S∣S∣≤wi,Si∣Si∣(∑Yiyi′,S)(∑Yiyi′,S∣S∣)\sum_{(i',S)\in Y_i}y_{i',S}w_{i',S}\le\frac{w_{i,S_i}}{\sqrt{|S_i|}}\sum_{Y_i}y_{i',S}\sqrt{|S|} \le \frac{w_{i,S_i}}{\sqrt{|S_i|}}\sqrt{\Big(\sum_{Y_i}y_{i',S}\Big)\Big(\sum_{Y_i}y_{i',S}|S|\Big)}

the first step because (i,Si)(i,S_i) was chosen while (i′,S)(i',S) was still in EE. Feasibility gives ∑Yiyi′,S≤∣Si∣+1\sum_{Y_i}y_{i',S}\le|S_i|+1 (each such pair has either S∩Si≠∅S\cap S_i\ne\emptyset or i′=ii'=i) and ∑Yiyi′,S∣S∣≤m\sum_{Y_i}y_{i',S}|S|\le m. Combining, the sum is at most 2m wi,Si\sqrt2\sqrt m\,w_{i,S_i}.

∎

TheoremThe result

The decomposition-based mechanism with Greedy as verifier is individually rational, truthful in expectation, and achieves a 2m\sqrt2\sqrt m approximation. Greedy is not truthful — randomness is what “plugs in” truthfulness.

NoteReach and limits of the technique

It is quite general wherever an integrality-gap verifier exists. Most notably multi-unit CAs with BB copies of each item: one can verify an O(m1/(B+1))O(m^{1/(B+1)}) gap, which is the best possible in polynomial time, and the decomposition-based mechanism is the only truthful mechanism with this tight guarantee.

But it is not fully general, as VCG is. For special cases with low approximation ratios the integrality gap of the LP is unchanged — with submodular valuations the constraints are the same, yet better-than-2 approximations exist, and no truthful constant-factor mechanism is known. Reformulating the LP with a smaller gap has so far been unsuccessful.

And truthfulness-in-expectation is inferior to truthfulness. Players are assumed to care only about the expectation, not the variance. Universal truthfulness (optimal for every coin toss) is stronger but still weaker than determinism: in classic algorithmics one invokes the law of large numbers by repeating, but in mechanism design one cannot repeat and pick the best outcome, as that changes the strategic properties.

NoteThe broader landscape of truthful CAs

Two techniques have proved useful. Maximal-in-Range mechanisms restrict the range and optimize within it, giving deterministic truthfulness with O(m)O(\sqrt m) for subadditive valuations, O(m/log⁡m)O(m/\sqrt{\log m}) for general valuations, and 2 for identical items. Partition-and-sample — split the players, gather statistics from one set, use them on the other — gives O(m)O(\sqrt m) for general and O(log⁡2m)O(\log^2m) for XOS valuations, with universal truthfulness.

Open: do truthful constant-factor approximations exist for NP-hard special cases where constant algorithmic approximations are known — e.g. submodular valuations? And: what are the limitations of deterministic truthful CAs? A possible explanation for the randomized/deterministic gap is that for general valuations every deterministic mechanism is VCG-based and these have no power — but only partial results are known on either half of that argument.


Impossibilities of dominant-strategy implementability

ImportantWhat “impossibility” means here

VCG is possible in every domain, so an impossibility must mean that nothing besides VCG is possible. That is a genuine impossibility because (i) VCG is often computationally intractable, and (ii) we often want goals other than welfare maximization.

DefinitionAffine maximizer

ff is an affine maximizer if there are weights k1,…,knk_1,\ldots,k_n and constants {Cx}x∈A\{C_x\}_{x\in A} with f(v)∈arg⁡max⁡x∈A{∑ikivi(x)+Cx}f(v)\in\arg\max_{x\in A}\{\sum_ik_iv_i(x)+C_x\}. These are always implementable.

TheoremRoberts

If ∣A∣≥3|A|\ge3 and Vi=RAV_i=\mathbb{R}^A for all ii, then ff is dominant-strategy implementable iff it is an affine maximizer.

NoteWhat we prove

A slightly easier version with an extra hypothesis, keeping the essential structure. ff is neutral if whenever some xx satisfies vi(x)>vi(y)v_i(x)>v_i(y) for all ii and all y≠xy\ne x, then f(v)=xf(v)=x — essentially forcing the additive constants CxC_x to be zero.

DefinitionTwo strengthened monotonicity conditions

Positive association of differences (PAD): if f(v)=xf(v)=x and for every y≠xy\ne x and every ii, vi′(x)−vi(x)>vi′(y)−vi(y)v_i'(x)-v_i(x) > v_i'(y)-v_i(y), then f(v′)=xf(v')=x.

Generalized-WMON: for every v,v′v,v' with f(v)=xf(v)=x, f(v′)=yf(v')=y, there is a player ii with vi′(y)−vi(y)≥vi′(x)−vi(x)v_i'(y)-v_i(y)\ge v_i'(x)-v_i(x). (Weak monotonicity without the qualifier of fixing one player and the others’ declarations.)

ProofAny implementable ff satisfies PAD

Let vi=(v1′,…,vi′,vi+1,…,vn)v^i = (v_1',\ldots,v_i',v_{i+1},\ldots,v_n), so v0=vv^0=v and vn=v′v^n=v'. If f(vi−1)=xf(v^{i-1})=x, then for every y≠xy\ne x we have vi′(y)−vi(y)<vi′(x)−vi(x)v_i'(y)-v_i(y) < v_i'(x)-v_i(x) while v−ii−1=v−iiv^{i-1}_{-i}=v^i_{-i}, so W-MON gives f(vi)=xf(v^i)=x. Induct.

∎

ProofUnrestricted domains satisfy Generalized-WMON

Suppose f(v′)=xf(v')=x and v′(y)−v(y)>v′(x)−v(x)v'(y)-v(y)>v'(x)-v(x); we show f(v)≠yf(v)\ne y. Assume f(v)=yf(v)=y, fix ϵ\epsilon with v′(x)−v′(y)=v(x)−v(y)−ϵv'(x)-v'(y)=v(x)-v(y)-\epsilon, and define v′′v'' by vi′′(z)=min⁡{vi(z),vi′(z)+vi(x)−vi′(x)}−ϵiv''_i(z)=\min\{v_i(z),v_i'(z)+v_i(x)-v_i'(x)\}-\epsilon_i for z≠x,yz\ne x,y, vi′′(x)=vi(x)−ϵi/2v''_i(x)=v_i(x)-\epsilon_i/2, vi′′(y)=vi(y)v''_i(y)=v_i(y). PAD on v→v′′v\to v'' gives f(v′′)=yf(v'')=y; PAD on v′→v′′v'\to v'' gives f(v′′)=xf(v'')=x — contradiction.

∎

DerivationThe main construction

For x,y∈Ax,y\in A define P(x,y)={α∈Rn∣∃v:v(x)−v(y)=α, f(v)=x}P(x,y)=\{\alpha\in\mathbb{R}^n\mid\exists v: v(x)-v(y)=\alpha,\ f(v)=x\}. Looking at differences helps since we must show ∑iki[vi(x)−vi(y)]≥Cy−Cx\sum_ik_i[v_i(x)-v_i(y)]\ge C_y-C_x whenever f(v)=xf(v)=x. P(x,y)P(x,y) is nonempty, and is closed under adding any δ>0\delta>0 (by PAD).

Duality. For ϵ>0\epsilon>0: (i) α−ϵ∈P(x,y)  ⟹  −α∉P(y,x)\alpha-\epsilon\in P(x,y)\implies-\alpha\notin P(y,x), since otherwise two valuations violate Generalized-WMON; and (ii) α∉P(x,y)  ⟹  −α∈P(y,x)\alpha\notin P(x,y)\implies-\alpha\in P(y,x), by constructing a vv with v(x)−v(y)=αv(x)-v(y)=\alpha and large gaps to all other alternatives, forcing f(v)∈{x,y}f(v)\in\{x,y\} and hence f(v)=yf(v)=y.

Additivity. If α−ϵ1∈P(x,y)\alpha-\epsilon_1\in P(x,y) and β−ϵ2∈P(y,z)\beta-\epsilon_2\in P(y,z) then α+β−(ϵ1+ϵ2)/2∈P(x,z)\alpha+\beta-(\epsilon_1+\epsilon_2)/2\in P(x,z).

Interiors coincide. If α\alpha is interior to P(x,y)P(x,y) then by neutrality ϵ/8∈P(y,z)\epsilon/8\in P(y,z), and additivity gives α\alpha interior to P(x,z)P(x,z); symmetrically across the first coordinate. So all the sets have the same interior, call it PP.

Convexity. Additivity gives α+β∈P\alpha+\beta\in P; and α/2∈P\alpha/2\in P, since otherwise −α/2∈P-\alpha/2\in P and then α/2=α+(−α/2)∈P\alpha/2=\alpha+(-\alpha/2)\in P. Hence midpoints stay in PP, which gives convexity.

Conclusion. Neutrality puts 00 on the boundary of every P(x,y)P(x,y), hence outside PP. By the separation lemma there is kk with k⋅α≥0k\cdot\alpha\ge0 for all α∈Pˉ\alpha\in\bar P. So f(v)=xf(v)=x gives v(x)−v(y)∈P(x,y)v(x)-v(y)\in P(x,y) and hence k⋅v(x)≥k⋅v(y)k\cdot v(x)\ge k\cdot v(y).

WarningWhat this does and does not settle

This is a unique example of a domain where affine maximizers are the only possibility. Our natural focus is on restricted domains, since most computational models have structure — and clear-cut impossibilities for such domains are not known. The result therefore emphasizes our lack of knowledge about the entire intermediate range of multidimensional domains, to which CAs belong. It is even known that there exists an implementable but non-affine-maximizer CA.

Open: characterize the domains for which affine maximizers are the only implementable functions.


Alternative solution concepts

IntuitionRelaxing what we ask for

Algorithm designers do not care so much about actually reaching an equilibrium point — the major concern is guaranteeing the optimality of the solution given strategic behavior. One way is to reach a good equilibrium; but there is no reason not to leave in several acceptable strategic choices and require the approximation in each.

The pitfall to avoid: simply letting players lie causes unpredictable dynamics, each player lying under assumptions about the others’ lies. We insist on rigorous reasoning for why the outcome will be satisfactory.

DefinitionAlgorithmic implementation

MM is an algorithmic implementation of a cc-approximation in undominated strategies if there is a strategy set DD such that (i) MM achieves a cc-approximation in polynomial time for any combination of strategies from DD, and (ii) every strategy outside DD is weakly dominated by one inside, with the transition polynomial-time computable.

ImportantWhat is kept and what differs

The essential ingredient of dominant strategies is retained: the only assumption is that a player replaces a strategy with one that dominates it — guaranteeing at least the same utility even in the worst case, computably. No coordination is required (unlike Nash), and no assumptions about others’ rationality (unlike iterated deletion).

Two differences: (I) a player might regret his choice, realizing another strategy in DD would have done better; (II) deciding how to play is not straightforward — a player will not play outside DD, but which member of DD he picks may depend on his beliefs or computational power.

(Note: DD need not contain all undominated strategies, only an equivalent for each — the same situation as VCG, where truthfulness need only be a dominant strategy, not the only one.)

DefinitionSingle-value players

ii is single-valued if there is vˉi≥1\bar v_i\ge1 with vi(s)∈{0,vˉi}v_i(s)\in\{0,\bar v_i\} for every bundle — she desires any one bundle from a collection Sˉi\bar S_i, for value vˉi\bar v_i. Both are private, and since Sˉi\bar S_i may be exponentially large we assume query access.

AlgorithmThe iterative wrapper

Initialize j=0j=0, Wj=Lj=∅W_j=L_j=\emptyset, vi0=1v_i^0=1, si0=Ωs_i^0=\Omega. While Wj∪Lj≠NW_j\cup L_j\ne N:

  1. (Wj+1,sj+1)←PROC(vj,sj,Wj)(W_{j+1},s^{j+1})\leftarrow \mathrm{PROC}(v^j,s^j,W_j).
  2. Each active non-winner chooses to double his value (vij+1=2vijv_i^{j+1}=2v_i^j) or permanently retire (vij+1=0v_i^{j+1}=0).
  3. Update Lj+1L_{j+1} and reiterate.

Outcome: each i∈WJi\in W_J gets siJs_i^J and pays viJv_i^J; all others get nothing and pay 0. For feasibility PROC must keep the winners’ bundles disjoint.

DefinitionProper procedures

PROC is proper if (1) Pareto: every non-winner that has not retired desires a bundle intersecting some winner’s, and (2) shrinking sets: sij+1⊆sijs_i^{j+1}\subseteq s_i^j.

LemmaFew iterations

If no player ever raises vijv_i^j above vˉi\bar v_i, a proper procedure performs at most 2log⁡(vmax⁡)+12\log(v_{\max})+1 iterations — independent of nn.

ProofPareto plus shrinking sets forces doubling

At iteration j=2log⁡(vmax⁡)+1j=2\log(v_{\max})+1, suppose i1i_1 doubles. By Pareto there is a winner i2i_2 with intersecting bundle, and by shrinking sets their bundles intersected at every earlier j′<jj'<j — so at each one at least one of them was a non-winner and doubled. Then vi1j≥vmax⁡v_{i_1}^j\ge v_{\max}, a contradiction.

∎

Warm-up: known single-minded players

Here a player desires one public bundle Sˉi\bar S_i and can lie only about the value. Set si0=Sˉis_i^0=\bar S_i and sij+1=sijs_i^{j+1}=s_i^j (trivially shrinking); Pareto holds WLOG by adding winners arbitrarily; and add one more property.

DefinitionImprovement

∑i∈Wj+1vij ≥ ∑i∈Wjvij\sum_{i\in W_{j+1}}v_i^j\ \ge\ \sum_{i\in W_j}v_i^j — again WLOG, by outputting WjW_j if violated.

DefinitionLocal approximation

A proper procedure is a cc-local-approximation w.r.t. DD if it satisfies improvement and, for any strategies in DD and any jj:

  • algorithmic approximation: OPT(Rj(vj,Sˉ))≤c∑i∈WjvijOPT(R_j(v^j,\bar S))\le c\sum_{i\in W_j}v_i^j;
  • value bounds: vij≤vi(sij)v_i^j\le v_i(s_i^j), and a player retiring at jj has vij≥vˉi/2v_i^j\ge\bar v_i/2.

Here Rj(v,S)={(vi,Si∣sij)∣i retired at iteration j}R_j(v,S) = \{(v_i, S_i|_{s_i^j}) \mid i \text{ retired at iteration } j\} — a virtual single-value player per retiree, with only the bundles inside his tentative set.

ProofLocal to global

By value bounds OPT(Rj(vˉ,Sˉ))≤2 OPT(Rj(vj,Sˉ))OPT(R_j(\bar v,\bar S))\le2\,OPT(R_j(v^j,\bar S)); by algorithmic approximation and improvement this is at most 2c∑i∈WJviJ2c\sum_{i\in W_J}v_i^J; and viJ≤vˉiv_i^J\le\bar v_i. Summing over the J≤2log⁡(vmax⁡)+1J\le2\log(v_{\max})+1 iterations,

OPT(Rˉ) ≤ 5log⁡(vmax⁡)⋅c⋅∑i∈WJvˉiOPT(\bar R)\ \le\ 5\log(v_{\max})\cdot c\cdot\sum_{i\in W_J}\bar v_i

∎

TheoremThe KSM result

Given any cc-approximation for known single-minded players, the wrapper implements an O(log⁡(vmax⁡)⋅c)O(\log(v_{\max})\cdot c) approximation in dominant strategies — a deterministic technique for converting algorithms to mechanisms with small approximation loss. (Under dominant strategies, ii retires iff vˉi/2≤vij≤vˉi\bar v_i/2\le v_i^j\le\bar v_i.)

Single-value players

Now players are multiminded and their bundles unknown.

Algorithm1-CA-PROC

Let Mj=arg⁡max⁡ivijM_j=\arg\max_i v_i^j and GREEDYj=∅GREEDY_j=\emptyset. For each player with vij>0v_i^j>0, in descending value order:

  • Shrinking: if i∉Wji\notin W_j, allow him to pick sij+1⊆Free(GREEDYj,sj+1)∩sijs_i^{j+1}\subseteq \mathrm{Free}(GREEDY_j,s^{j+1})\cap s_i^j with ∣sij+1∣≤m|s_i^{j+1}|\le\sqrt m; otherwise keep sij+1=sijs_i^{j+1}=s_i^j.
  • Updating: if ∣sij+1∣≤m|s_i^{j+1}|\le\sqrt m, add ii to any of {Wj,Mj,GREEDYj}\{W_j, M_j, GREEDY_j\} in which his bundle is still free.

Output sj+1s^{j+1} and whichever of Wj,Mj,GREEDYjW_j, M_j, GREEDY_j maximizes ∑i∈Wvij\sum_{i\in W}v_i^j.

ImportantThe conceptual difference, and why we need the new concept

Here the players themselves gradually determine their winning set (focusing on one desired bundle) and their price. Ideally a player should focus on a bundle intersecting few low-value competitors — but in early iterations that information is unavailable. So there is no clear-cut way to shrink, the mechanism contains no dominant strategy, and this is exactly where algorithmic implementation is used.

DefinitionThe strategy set DD

ii is loser-if-silent at jj if, when asked to shrink, vij≥vˉi/2v_i^j\ge\bar v_i/2, i∉Wj∪Mji\notin W_j\cup M_j, and his bundle intersects both the WjW_j and MjM_j allocations — i.e. he loses regardless of others unless he shrinks. Then DD consists of strategies satisfying, at every jj:

  1. vij≤vi(sij)v_i^j\le v_i(s_i^j), and vij≥vˉi/2v_i^j\ge\bar v_i/2 if retiring at jj;
  2. if loser-if-silent, declare a valid bundle sij+1s_i^{j+1} if one exists.

There is a polynomial-time algorithm finding a strategy in DD dominating any given one, so DD satisfies requirement (ii) of algorithmic implementation.

Proof1-CA-PROC is an O(m)O(\sqrt m)-local-approximation

Pareto, improvement and value bounds are immediate. For the approximation, divide the OPTOPT winners into four sets: those in MjM_j, GREEDYjGREEDY_j, WjW_j — for which the procedure explicitly checks — and the rest, each of whom is loser-if-silent.

If such a player receives a bundle of size ≥m\ge\sqrt m in OPTOPT, match him to the highest-value player in MjM_j; at most m\sqrt m players in OPTOPT can have such bundles, so we lose a m\sqrt m factor. If he receives si∗s_i^* with ∣si∗∣<m|s_i^*|<\sqrt m, then being loser-if-silent there is i′∈GREEDYji'\in GREEDY_j with si′j∩si∗≠∅s_{i'}^j\cap s_i^*\ne\emptyset and vij≤vi′jv_i^j\le v_{i'}^j; map ii to i′i'. Any two players mapped to i′i' have disjoint bundles (both are in OPTOPT), and ∣si′j∣≤m|s_{i'}^j|\le\sqrt m, so at most m\sqrt m players map to each i′i'.

∎

DefinitionFirst-time shrink

PROC satisfies first-time shrink if any two players shrinking below mm for the first time at the same iteration have disjoint bundles. (1-CA-PROC satisfies this, since every shrinking player is added to GREEDYjGREEDY_j.)

ProofFrom local approximation to the global guarantee

In the single-value case Rˉ\bar R does not contain all players, so we need an intermediate step. Let PP be the losers with ∣siJ∣<m|s_i^J|<m — these appear with all their desired bundles, while Rˉ\bar R has only part.

Claim: OPT(P)≤J⋅OPT(Rˉ)OPT(P)\le J\cdot OPT(\bar R). Let PjP_j be those first shrinking at jj; by first-time shrink their bundles at jj are disjoint, so OPT(Rˉ)≥∑i∈Pjvˉi≥OPT(Pj)OPT(\bar R)\ge\sum_{i\in P_j}\bar v_i\ge OPT(P_j). Sum over jj.

All true players lie in P∪Rˉ∪WJP\cup\bar R\cup W_J (a retiree who shrank is in PP with all his bundles; one who never shrank is in Rˉ\bar R with all his bundles; non-retirees are in WJW_J). Hence OPT(P∪Rˉ)≤(J+1)OPT(Rˉ)≤4J2c∑i∈WJvˉiJOPT(P\cup\bar R)\le(J+1)OPT(\bar R)\le 4J^2c\sum_{i\in W_J}\bar v_i^J, and since siJs_i^J contains a desired bundle, OPT(WJ)=∑i∈WJvˉiOPT(W_J)=\sum_{i\in W_J}\bar v_i.

∎

TheoremThe result

The wrapper with 1-CA-PROC is an algorithmic implementation of an O(log⁡2(vmax⁡)⋅c)O(\log^2(v_{\max})\cdot c)-approximation for single-value players.

Note also the format: most mechanisms so far are direct revelation, whereas in practice indirect — especially ascending — auctions are much preferred, and this is one.

NoteThe open question

This demonstrates that if we care less about reaching an equilibrium point and more about guaranteeing a good-enough outcome, alternative concepts no worse than dominant strategies can help a lot. But the true power of the relaxation is not settled: does there exist a domain where a computationally efficient algorithmic implementation beats every computationally efficient dominant-strategy one?


Quick reference

ObjectStatement
Allocation problem, single-mindedNP-hard; inapproximable within m1/2−ϵm^{1/2-\epsilon}
Greedy mechanismsort by $v_i^*/\sqrt{
Single-minded characterizationmonotone ++ pay the critical value (not the Chapter 9 single-parameter case)
LPR / DLPRduals are item prices and bidder utilities
Walrasian equilibriumdemands met, unallocated items free
First / Second WelfareWalrasian   ⟺  \iff LPR has an integral optimum
OR vs XORXOR expresses everything; OR only superadditive; additive is cheap in OR, dear in XOR
OR* bidsdummy items simulate XOR; size ss formula →\to size ss OR* with ≤s2\le s^2 dummies
Value vs demand queriesvalue ≤mt\le mt demand queries; demand needs exponentially many value queries
Solving LPRellipsoid on the dual, one demand query per bidder as separation oracle
Communication(mm/2)\binom{m}{m/2} bits for exact; min⁡{n,m1/2−ϵ}\min\{n,m^{1/2-\epsilon}\} for approximation
Item-price ascendingconverges to ϵ\epsilon-Walrasian under substitutes; exposure and demand reduction otherwise
Bundle-price ascendingalways converges to an ϵ\epsilon-competitive equilibrium; possibly exponential
Single-dimensional linearimplementable   ⟺  \iff nonincreasing load functions
Schedulingrandomized 2-approx truthful-in-expectation; deterministic 5-approx truthful
Decomposition techniquecc-integrality-gap verifier →\to cc-approx truthful-in-expectation
Greedy as verifier2m\sqrt2\sqrt m gap, hence that approximation truthfully
Robertsunrestricted domain, $
Algorithmic implementationcc-approx for all strategies in DD; everything outside DD dominated, computably
Single-value wrapperO(log⁡2vmax⁡⋅c)O(\log^2 v_{\max}\cdot c) via iterative doubling and 1-CA-PROC

Facts to keep to hand:

  • The single-minded case is the whole subject in miniature: NP-hardness, a matching m\sqrt m approximation, and a non-VCG truthful mechanism achieving it.
  • VCG-like payments on top of an approximation algorithm are not truthful — this is the single fact that forces everything in chapter 12.
  • Walrasian equilibrium, zero integrality gap, and efficient computability are the same condition for combinatorial auctions.
  • The OR* trick means any algorithm for atomic bids handles general valuations; representation and computation decouple.
  • Demand queries do two jobs: they are strictly stronger than value queries, and they are exactly the separation oracle that makes the exponential-size LP solvable.
  • The communication lower bound is independent of computational power, so representation is a barrier in its own right — and it is what makes iterative auctions necessarily heuristic.
  • Substitutes is precisely the condition making ascending item prices safe; it rules out complementarity and is what fails in the exposure problem.
  • Single-dimensional ⇒\Rightarrow monotonicity is a usable algorithmic constraint; multidimensional ⇒\Rightarrow Roberts looms at one extreme and almost nothing is known in between.
  • Two escapes from the clash, both weakening the solution concept: randomization (truthful in expectation, via decomposition) and undominated strategies (algorithmic implementation).

References

← All notes