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
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
indivisible items concurrently auctioned among bidders. Each bidder has a valuation : a real-valued function where is the value of receiving bundle . A valuation must have free disposal (be monotone, for ) and be normalized ().
An allocation is with ; its social welfare is , 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 : they are complements if , and substitutes if .
Two assumptions are implicit: preferences are quasi-linear in money (utility ), 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
is single minded if there is a bundle and value with for all and 0 otherwise. The bid is the pair — very simply represented.
Computational complexity
DefinitionThe allocation problem
Input: for each bidder. Output: a set of winners with for distinct , maximizing .
(In an optimal allocation a single-minded bidder gets exactly or nothing.)
TheoremNP-hardness
The allocation problem among single-minded bidders is NP-hard; deciding whether the optimum is at least is NP-complete.
ProofReduction from INDEPENDENT-SET
Given a graph and : let the items be the edges , and give each vertex a player with (the adjacent edges) and .
A set satisfies for distinct 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 , and since welfare equals independent-set size in the reduction, the same hardness transfers. Stated in terms of items, using :
Approximating the optimal allocation among single-minded bidders to within better than is NP-hard.
NoteThe three standard responses
Approximation — 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 , descending. Greedily add bidder to if is disjoint from the bundles already allocated. Each winner pays , where is the first bidder after in the order who was denied because of ; losers pay 0.
The sorting expression was chosen to optimize the approximation ratio, but the incentive compatibility argument applies to any expression increasing in and decreasing in . The intuition for is that he is the bidder who lost exactly because of — had not participated, would have won.
TheoremGreedy works
The greedy mechanism is efficiently computable, incentive compatible, and gives a 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
- Monotonicity: a winner with bid keeps winning with any and any (others fixed).
- Critical payment: a winner pays the infimum of all values such that 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 or shrinking moves up the greedy order, making winning easier; and wins exactly while he precedes , 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 and he reports . If loses or , truth is at least as good. So assume wins and .
Reporting is no worse than . Let the payments be and . For every , bidding loses since is critical; by monotonicity also loses, so . Hence switching still wins and the payment does not increase.
Reporting is no worse than . If wins with critical value , then any wins with the same payment, and any loses for zero utility. If loses, then is below the critical value, so any winning costs more than — an unprofitable deviation.
∎
ProofThe approximation
Let be an optimal winner set and the greedy output. For let — those excluded because of , plus itself. Since , it suffices to show .
Every came after in the greedy order, so . Summing and applying Cauchy–Schwarz,
Every for intersects , and since is an allocation those intersections are disjoint, giving ; also . Substituting gives , hence the claim.
∎
Walrasian equilibrium and the LP relaxation
FormulaThe linear programming relaxation (LPR)
In the integer program indicates that receives . 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)
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 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, is a demand of bidder if for every .
Prices and an allocation are a Walrasian equilibrium if every is a demand at , 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 , using ,
Sum over bidders. It remains to check the price terms: the left side totals exactly, since unallocated items have price zero, while the right side is at most since each price has coefficient at most 1 by the item constraint.
∎
WarningWalrasian equilibria need not exist
Two players, two items . Alice values every nonempty set at 2; Bob values at 3 and singletons at 0. The optimal allocation gives both items to Bob, so Alice must demand — 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 . Complementary slackness makes constraint binding wherever , so ; 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 .
∎
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 items requires 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 . 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.
For OR, is the maximum over all valid collections (pairwise disjoint ) of .
ExampleWhere they differ
Both ” XOR ” and the OR version value at 0 and at 3. They differ on : 5 for XOR (the best atom satisfied) versus 8 for OR. And ” OR ” values at 5, since both atoms cannot be satisfied together.
ImportantExpressiveness and size
XOR can represent every valuation — just XOR the atoms for all bundles. OR can represent only superadditive valuations, since the atoms giving and are disjoint and get added; all superadditive valuations are representable this way.
But size — the number of atoms — is what matters:
| Valuation | Definition | OR | XOR |
|---|---|---|---|
| Additive | size | exponential ( atoms) | |
| Unit demand | impossible (never superadditive) | size |
DefinitionCombining the two
and , giving general OR/XOR formulae. For instance values at 3 and at 8.
ExampleOR-of-XORs and downward sloping valuations
is symmetric if depends only on , and downward sloping if with . Such a valuation with strict inequalities requires XOR bids of size and cannot be represented by OR at all.
OR-of-XORs does it in size : one clause per offering for any single item (a simple XOR bid), with the clauses joined by OR. Since the 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 have private dummy items with no intrinsic value; an OR* bid is an OR bid over , valuing by what the OR bid gives .
The idea: XOR becomes OR . For , the OR* bid OR OR equals .
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 is representable by OR* bids of size , using at most 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 , in two different sub-bids, introduce a dummy ; each bid becomes where ranges over atoms of all other sub-bids.
This gives exactly 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 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 , , and the bits of precision.
- Value query: the auctioneer presents , the bidder reports .
- Demand query (item prices): the auctioneer presents prices ; the bidder reports some maximizing .
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 demand queries ( = 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 : set for , for , and binary search on — the highest whose demand contains is the marginal value. Then .
∎
Solving the linear program
TheoremDemand queries solve LPR
LPR can be solved in polynomial time (in , , 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 variables but exponentially many constraints; the ellipsoid method runs in polynomial time on such programs given a separation oracle.
Rewrite the dual constraint as . A demand query to bidder at prices reveals exactly the maximizing the right-hand side. So to test feasibility of : query each bidder for his demand , and check only the constraints (with simulated by demand queries). If none is violated, 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
: general; subadditive (); XOS (representable by XOR-of-ORs with singleton atoms); submodular (); substitutes (below). Also Dup ( duplicates of each good, each bidder wanting at most one of each) and Proc (procurement, a buyer minimizing total cost paid to 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 and must run a protocol ending in an allocation maximizing . Alice’s message may depend only on 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 bits in the worst case.
(By Stirling, .)
ImportantWhy this applies everywhere
Yao’s model is very powerful, so the bound applies to essentially all settings where and 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 define the dual . Note is a monotone 0/1 valuation, and for every partition, .
Key lemma: for , the communication sequence on differs from that on .
Suppose not. Then the same sequence occurs on : Alice does not see so she behaves as in ; Bob behaves as in ; neither ever notices a deviation. Likewise for . So one allocation is produced in all four cases — impossible.
Since there is with, WLOG, and , so and optimality on forces . But , so — the allocation is not optimal for , 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 (count valuations that are 0 below size , 1 above, and free at size ). A binary sequence set of that size needs one sequence of length .
∎
TheoremApproximation is hard too
For every , approximating the social welfare to within a factor strictly smaller than requires exponential communication.
NoteThis is tight
A factor of is trivial (bundle everything and run a single-item auction), and for there is an 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
satisfies substitutes if for item prices coordinatewise, every demand at has a demand at containing all items whose price stayed the same. Formally, for there is with .
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 demands both at prices , but if 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-Walrasian equilibrium
An allocation and prices with , where each is a demand of at prices for and for .
TheoremConvergence under substitutes
For bidders with substitutes valuations, the ascending auction ends with an -Walrasian equilibrium; in particular the welfare is within of optimal.
ProofThe invariant
Claim: at every stage, for every bidder. True initially. Consider an update step for bidder : for himself, afterwards equals exactly (the price changes on newly added items match those defining ). For , two things can happen — items may be taken from by , which shrinks without affecting ; and prices outside may rise, which does not affect , while substitutes directly implies the only items that can leave are those whose price strictly increased, hence not in .
Given the claim, no item ever demanded is left unallocated, so contains every positively priced item; termination requires all . Near-optimality follows as in the First Welfare Theorem.
∎
NoteTermination and the primal-dual reading
Since prices only rise, the algorithm terminates within 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
| Alice | 4 | 4 | 4 |
| Bob | 5 | 5 | 10 |
The auction terminates at with Bob winning both, earning him 2. If Bob bids only on , the auction stops at zero prices, allocating to Bob and to Alice — improving Bob’s payoff to 5.
Bundle-price ascending auctions
DefinitionCompetitive equilibrium with personalized bundle prices
Prices per bidder and bundle, with an allocation, such that (i) each is a demand at , and (ii) the allocation maximizes the seller’s revenue: for every other allocation.
ImportantThese always exist — and still give efficiency
Any welfare-maximizing allocation with is a competitive equilibrium (a Second Welfare Theorem for this setting). And even this weak notion guarantees optimal welfare: summing the demand inequalities over bidders, together with revenue maximality, gives that beats any .
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 -competitive equilibrium
For any profile of valuations the auction terminates with an -competitive equilibrium; the welfare is within of optimal.
(An -demand satisfies .)
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 -demand. Losers get , their demand, by the termination condition. For a winner, the auction maintains that every bundle with is an -demand: such a was ‘s exact demand at some earlier round, hence an -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
jobs assigned to machines; job consumes time-units, machine has speed , so it needs time. With load , the goal is to minimize the makespan . Each machine is selfish with unit cost per time unit, so utility is . The mechanism designer knows the processing times.
DefinitionSingle-dimensional linear domain
is single-dimensional and linear if there are constants (loads) such that every has for some (the cost).
The player’s type is simply her cost , which discloses the entire valuation vector. Scheduling fits: and is the load assigned by .
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 , the algorithm determines a load . For the weak monotonicity condition reduces to , which holds iff — the load function is nonincreasing.
Charge . Truthful utility is the area under the load curve up to . Reporting loses exactly the area : the cost from the load falls to but the payment rises to the area between the line and the curve. Reporting loses area , since the cost rises to .
These prices violate individual rationality (utility is always negative), so add the constant — then a machine declaring infinite cost gets zero utility and a truthful player gets .
TheoremCharacterization for single-dimensional linear domains
An algorithm is implementable iff its load functions are nonincreasing, and then the prices
give an individually rational dominant-strategy implementation. Truthfulness in expectation is equivalent to monotonicity of the expected load.
A monotone approximation algorithm
Order and . (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 and target . Any schedule with makespan assigns each of jobs to a machine with ; let . By space considerations,
Define . Then the optimal makespan is at least : for , with the minimizing index, the left term increases in and the right decreases, so is either the last index where the right term dominates or the first where the left does; in either case violates the displayed inequality.
Hence lower bounds the optimum.
DefinitionThe fractional allocation
Let be the first job with . Assign to machine 1 jobs plus a fraction of to make ; recurse on the remaining fractions and machines .
ProofFeasibility and monotonicity of the fractional allocation
Feasibility: since we can fractionally assign jobs within the first machines; and gives whenever lands on . Setting gives full assignment.
Monotonicity: if rises to , then (scaling all speeds by scales by , and the actual other speeds are no larger). If was full, … more precisely , matching. Otherwise is the last nonempty machine, and since all earlier machines take at least as much as before, so 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 uniformly. For each job split between and , assign it fully to if ‘s fraction on is at least , else to . This is truthful in expectation and gives a 2-approximation in polynomial time.
ProofApproximation, then the expected-load argument
Approximation: machine may get two extra jobs — shared with and shared with . If rounds to then had at least of it, so the extra load is at most ; similarly at most for . Since , the total extra is at most .
Truthfulness: machine gets with probability , so gets it with probability , and gets with probability — so the expected load equals the fractional load, which is monotone.
∎
AlgorithmThe deterministic variant, via virtual speeds
- Set virtual speeds: , and for let be the closest breakpoint with . (The fastest machine is made slightly faster, the others slightly slower.)
- Compute from the virtual speeds.
- Assign jobs largest-first, fastest-first, moving to the next machine when the current one holds total processing time .
This is exactly the natural rounding that previously failed — but on the rather than the , which is what enables monotonicity, at the cost of approximation.
The loss: since speeds were slowed by at most that factor. On machine 1, since , the load may be ; with one extra partial job, and using , the total is . On any other machine , so after the extra job the load is at most .
ProofMonotonicity of the deterministic algorithm
Three observations. (a) For and , : give machine nothing and shift each earlier machine’s jobs down one; machines stay under the limit since each is faster than its successor, and machine 1 gains at most a factor since always . (b) If a machine slows, the work on faster machines does not decrease, since is monotone. (c) If the fastest machine slows but stays fastest, its work does not increase: all breakpoints shift by the same factor , so if no crosses a new breakpoint everything scales and machine 1 keeps the same jobs; if some do, their fall, so falls and machine 1 gets no more.
Now suppose slows to . If is fastest and stays so, use (c). If the title of fastest passes to , insert an artificial breakpoint where their speeds coincide; ‘s work as fastest is at least while its work once is fastest is at most . If is not fastest but full, then so by (a) its work goes from to at most . If 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, is the computational and communication barrier, and 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 -approximation to the optimal fractional welfare, construct a randomized -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)
(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
verifies a -integrality-gap for CA-P if, given real numbers , it outputs a feasible integral with .
LemmaThe decomposition lemma
If verifies a -integrality-gap in polynomial time and is feasible for CA-P, then can be decomposed into a convex combination of integral feasible points — in polynomial time.
AlgorithmThe decomposition-based mechanism
- Compute the optimal fractional and the VCG fractional prices .
- Obtain a decomposition .
- With probability : choose allocation and set prices .
NoteWhy these prices
The strategic properties hold whenever the expected price equals the fractional price over . These particular prices additionally give strong individual rationality — truth-telling ensures nonnegative utility regardless of the coin toss — since VCG is individually rational, so and hence for every .
ProofTruthfulness in expectation
Expected price. Using the decomposition,
Truthfulness. Fix ; let and be the fractional optima under and . Fractional VCG gives . Dividing by and using the expected-price identity turns the two sides into the expected utilities of declaring and .
Approximation. The expected welfare is , and 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, 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 (minimize subject to for and ) and its dual (maximize subject to for every integral ), where is of polynomial size.
has exponentially many variables; has polynomially many variables but exponentially many constraints. The verifier is the separation oracle: if , feed to to get with — a violated constraint.
Hence the optimum of is exactly 1 ( 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 with polynomially many variables, which we solve directly.
ProofBuilding the verifier from an ordinary approximation
Two things differentiate a verifier from a “regular” -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 , define and — a valid valuation, succinctly representable with size . Feed to the approximation to get . Two discrepancies remain: the sum over may miss coordinates, and some may be negative. Fix the first by setting, for each , the coordinate for ; fix the second by zeroing the coordinates with . The result is feasible with the same objective value.
∎
AlgorithmGreedy as an integrality-gap verifier
Given : repeatedly pick , set , and remove from all with or .
ProofGreedy verifies a integrality gap
Let be the optimal fractional allocation, and for each winner let be the positively weighted pairs removed when was added. Then
the first step because was chosen while was still in . Feasibility gives (each such pair has either or ) and . Combining, the sum is at most .
∎
TheoremThe result
The decomposition-based mechanism with Greedy as verifier is individually rational, truthful in expectation, and achieves a 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 copies of each item: one can verify an 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 for subadditive valuations, 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 for general and 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
is an affine maximizer if there are weights and constants with . These are always implementable.
TheoremRoberts
If and for all , then 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. is neutral if whenever some satisfies for all and all , then — essentially forcing the additive constants to be zero.
DefinitionTwo strengthened monotonicity conditions
Positive association of differences (PAD): if and for every and every , , then .
Generalized-WMON: for every with , , there is a player with . (Weak monotonicity without the qualifier of fixing one player and the others’ declarations.)
ProofAny implementable satisfies PAD
Let , so and . If , then for every we have while , so W-MON gives . Induct.
∎
ProofUnrestricted domains satisfy Generalized-WMON
Suppose and ; we show . Assume , fix with , and define by for , , . PAD on gives ; PAD on gives — contradiction.
∎
DerivationThe main construction
For define . Looking at differences helps since we must show whenever . is nonempty, and is closed under adding any (by PAD).
Duality. For : (i) , since otherwise two valuations violate Generalized-WMON; and (ii) , by constructing a with and large gaps to all other alternatives, forcing and hence .
Additivity. If and then .
Interiors coincide. If is interior to then by neutrality , and additivity gives interior to ; symmetrically across the first coordinate. So all the sets have the same interior, call it .
Convexity. Additivity gives ; and , since otherwise and then . Hence midpoints stay in , which gives convexity.
Conclusion. Neutrality puts on the boundary of every , hence outside . By the separation lemma there is with for all . So gives and hence .
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
is an algorithmic implementation of a -approximation in undominated strategies if there is a strategy set such that (i) achieves a -approximation in polynomial time for any combination of strategies from , and (ii) every strategy outside 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 would have done better; (II) deciding how to play is not straightforward — a player will not play outside , but which member of he picks may depend on his beliefs or computational power.
(Note: 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
is single-valued if there is with for every bundle — she desires any one bundle from a collection , for value . Both are private, and since may be exponentially large we assume query access.
AlgorithmThe iterative wrapper
Initialize , , , . While :
- .
- Each active non-winner chooses to double his value () or permanently retire ().
- Update and reiterate.
Outcome: each gets and pays ; 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: .
LemmaFew iterations
If no player ever raises above , a proper procedure performs at most iterations — independent of .
ProofPareto plus shrinking sets forces doubling
At iteration , suppose doubles. By Pareto there is a winner with intersecting bundle, and by shrinking sets their bundles intersected at every earlier — so at each one at least one of them was a non-winner and doubled. Then , a contradiction.
∎
Warm-up: known single-minded players
Here a player desires one public bundle and can lie only about the value. Set and (trivially shrinking); Pareto holds WLOG by adding winners arbitrarily; and add one more property.
DefinitionImprovement
— again WLOG, by outputting if violated.
DefinitionLocal approximation
A proper procedure is a -local-approximation w.r.t. if it satisfies improvement and, for any strategies in and any :
- algorithmic approximation: ;
- value bounds: , and a player retiring at has .
Here — a virtual single-value player per retiree, with only the bundles inside his tentative set.
ProofLocal to global
By value bounds ; by algorithmic approximation and improvement this is at most ; and . Summing over the iterations,
∎
TheoremThe KSM result
Given any -approximation for known single-minded players, the wrapper implements an approximation in dominant strategies — a deterministic technique for converting algorithms to mechanisms with small approximation loss. (Under dominant strategies, retires iff .)
Single-value players
Now players are multiminded and their bundles unknown.
Algorithm1-CA-PROC
Let and . For each player with , in descending value order:
- Shrinking: if , allow him to pick with ; otherwise keep .
- Updating: if , add to any of in which his bundle is still free.
Output and whichever of maximizes .
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
is loser-if-silent at if, when asked to shrink, , , and his bundle intersects both the and allocations — i.e. he loses regardless of others unless he shrinks. Then consists of strategies satisfying, at every :
- , and if retiring at ;
- if loser-if-silent, declare a valid bundle if one exists.
There is a polynomial-time algorithm finding a strategy in dominating any given one, so satisfies requirement (ii) of algorithmic implementation.
Proof1-CA-PROC is an -local-approximation
Pareto, improvement and value bounds are immediate. For the approximation, divide the winners into four sets: those in , , — 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 in , match him to the highest-value player in ; at most players in can have such bundles, so we lose a factor. If he receives with , then being loser-if-silent there is with and ; map to . Any two players mapped to have disjoint bundles (both are in ), and , so at most players map to each .
∎
DefinitionFirst-time shrink
PROC satisfies first-time shrink if any two players shrinking below for the first time at the same iteration have disjoint bundles. (1-CA-PROC satisfies this, since every shrinking player is added to .)
ProofFrom local approximation to the global guarantee
In the single-value case does not contain all players, so we need an intermediate step. Let be the losers with — these appear with all their desired bundles, while has only part.
Claim: . Let be those first shrinking at ; by first-time shrink their bundles at are disjoint, so . Sum over .
All true players lie in (a retiree who shrank is in with all his bundles; one who never shrank is in with all his bundles; non-retirees are in ). Hence , and since contains a desired bundle, .
∎
TheoremThe result
The wrapper with 1-CA-PROC is an algorithmic implementation of an -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
| Object | Statement |
|---|---|
| Allocation problem, single-minded | NP-hard; inapproximable within |
| Greedy mechanism | sort by $v_i^*/\sqrt{ |
| Single-minded characterization | monotone pay the critical value (not the Chapter 9 single-parameter case) |
| LPR / DLPR | duals are item prices and bidder utilities |
| Walrasian equilibrium | demands met, unallocated items free |
| First / Second Welfare | Walrasian LPR has an integral optimum |
| OR vs XOR | XOR expresses everything; OR only superadditive; additive is cheap in OR, dear in XOR |
| OR* bids | dummy items simulate XOR; size formula size OR* with dummies |
| Value vs demand queries | value demand queries; demand needs exponentially many value queries |
| Solving LPR | ellipsoid on the dual, one demand query per bidder as separation oracle |
| Communication | bits for exact; for approximation |
| Item-price ascending | converges to -Walrasian under substitutes; exposure and demand reduction otherwise |
| Bundle-price ascending | always converges to an -competitive equilibrium; possibly exponential |
| Single-dimensional linear | implementable nonincreasing load functions |
| Scheduling | randomized 2-approx truthful-in-expectation; deterministic 5-approx truthful |
| Decomposition technique | -integrality-gap verifier -approx truthful-in-expectation |
| Greedy as verifier | gap, hence that approximation truthfully |
| Roberts | unrestricted domain, $ |
| Algorithmic implementation | -approx for all strategies in ; everything outside dominated, computably |
| Single-value wrapper | 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 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 monotonicity is a usable algorithmic constraint; multidimensional 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
- Nisan, Roughgarden, Tardos & Vazirani, Algorithmic Game Theory — chapters 11 (Blumrosen & Nisan) and 12 (Lavi)