towards fast vickrey pricing using constraint programming

Towards Fast Vickrey Pricing Using Constraint Programming

ALAN HOLLAND & BARRY O’SULLIVANCork Constraint Computation Centre, Department of Computer Science, UniversityCollege Cork, Ireland (E-mail: {a.holland; b.osullivan}@cs.ucc.ie)

Abstract. Ensuring truthfulness amongst self-interested agents bidding against oneanother in an auction can be computationally expensive when prices are determined

using the Vickrey–Clarke–Groves (VCG) mechanism. This mechanism guarantees thateach agent’s dominant strategy is to tell the truth, but it requires solving nþ 1 opti-mization problems when the overall optimal solution involves n agents. This paper first

examines a case-study example demonstrating how Operations Research techniques canbe used to compute Vickrey prices efficiently. In particular, the case-study focuses on theAssignment Problem. We show how, in this case, Vickrey prices can be computed in the

same asymptotic time complexity as that of the original optimization problem. Thiscase-study can be seen as serving a pedagogical role in the paper illustrating howOperations Research techniques can be used for fast Vickrey pricing. We then propose aConstraint Programming approach that can be used in a more general context, where

nothing is assumed about the nature of the constraints that must be satisfied or thestructure of the underlying problem. In particular, we demonstrate how nogoodlearning can be used to improve the efficiency of constraint-based Vickrey pricing in

combinatorial auctions.

Keywords: combinational auctions, Constraint Programming, Vickrey pricing

1. Introduction

Eliciting truthful responses from self-interested agents has been previ-ously studied in game theory and economics. A class of Vickrey–Clarke–Groves (VCG) mechanisms have been developed whereby thedominant strategy for any agent is to tell the truth, meaning that ra-tional agents maximize their utility by truthfully revealing their pref-erences (Vickrey, 1961). Truthfulness is a dominant strategy when thereis no circumstance under which an agent can benefit from lying. TheVCG mechanism is also commonly referred to as the generalizedVickrey auction (GVA).

In a GVA bids are solicited from the agents for a range of items beingauctioned. An optimal solution is found, and subsequently the paymentto each agent, or Vickrey price, is determined by finding the cost of anoptimal solution without that agent present. Each agent cannot control

Artificial Intelligence Review 21: 335–352, 2004.� 2004 Kluwer Academic Publishers. Printed in the Netherlands.

335

the price paid to it because it is a function of the other agents’ preferences.This removes any potential profiteering by insidious providers. For anoverview of Mechanism Design in general, and the VCG mechanism inparticular, the reader is referred to Mas-Collel et al. (1995).

The research that we report in this paper has many practical appli-cations. For example, the Computational Grid has most recently beendefined as ‘‘coordinated resource sharing and problem solving in dynamic,multi-institutional virtual organizations’’ (Foster, 2001). Consequentlythe Grid presents difficulties in terms of scheduling and brokering ofdistributed applications. We can regard the service providers in the Gridas self-interested agents whose principle motivation is to maximize theirown profit when bidding for tasks. Truthfulness in such a scenario isdesirable but implementing it within a mechanism can become com-putationally expensive.

The vision for the future of the Grid is analogous to that of theelectricity grid. Computing power, storage facilities, specialized softwareand other resources should be provided on-demand and the source ofthe desired resource should be transparent to the end-user. These re-sources are ultimately provided by a wide range of agents, who can beregarded as self-interested and motivated by profit. They may act dis-honestly if they deem it beneficial. These agents can pool their resourcesin a co-operative in which a broker disseminates tasks based uponsolicited bids for them.

The main contributions of this paper are as follows:– We consider a case-study example, where n agents are bidding form tasks where m < n. This corresponds to a weighted bipartitematching problem, otherwise known as the Assignment Problem.We show how, in this case, Vickrey prices can be computed in thesame asymptotic time complexity as that of the original optimi-zation problem, thus tackling a problem posed by Hershbergerand Suri (2001). This case-study can be seen as serving a peda-gogical role in the paper illustrating how Operations Researchtechniques can be used for fast Vickrey pricing.

– We then propose a Constraint Programming approach that can beused in a more general context, where nothing is assumed aboutthe nature of the constraints that must be satisfied or the structureof the underlying problem. In particular, we demonstrate hownogood learning (Schiex and Verfaillie, 1994) can be used to im-prove the efficiency of constraint-based Vickrey pricing in com-binatorial auctions, that are NP-complete in general.

A. HOLLAND AND B. O’SULLIVAN336

This paper is organized as follows. Section 2 presents a brief overview ofMechanism Design. Section 3 presents a detailed case-study of fastVickrey pricing for the Assignment Problem, which is equivalent toscheduling m tasks on n machines where m < n. It gives a generaldescription of the problem and shows how the Hungarian Method canbe used for fast Vickrey pricing. Section 4 presents an approach to fastVickrey pricing based on Constraint Programming for the more generalcase of combinatorial auctions. Some concluding remarks are made inSection 5.

2. A Brief Overview of Mechanism Design

Mechanism Design is concerned with specifying the rules of a gamewhere a collection of agents, each holding private information abouttheir preferences over a set of outcomes, interact with each other in theirown self-interest. An example scenario is an auction where the agentsare the bidders and the set of outcomes describes the possible assign-ments of goods to bidders. A mechanism is then a tuple that comprisesthe set of possible actions that an agent may take and an outcome rule.A strategy defines the actions an agent will take over all its preferences.An example strategy may be for an agent to always exaggerate its truevaluation for an item by a given amount. The outcome rule thenassimilates the actions of the agents and determines an outcome. Acrucial assumption in Mechanism Design is that all the agents are ra-tional and selfish, and therefore seek to maximize their own utility bychoosing an appropriate strategy.

2.1. Mechanism Design: the goals

The traditional goal of Mechanism Design is to design a game in whichan overall equilibrium (or equilibria) is reached according to somedesirable system-wide properties, given that all participating agents actin their own self-interest. A social choice function (SCF) describes theproperties that the outcome should possess.

Some typical desirable properties include the following:

– Individual rationality: The SCF makes guarantees about an agent’sutility with respect to its participation in an auction. This is animportant property if agent participation is voluntary.

TOWARDS FAST VICKREY PRICING USING CONSTRAINT 337

– Efficiency: The outcome must maximize overall agent utility,thereby maximizing social welfare.

– Revenue maximizing: A single agent, an auctioneer for example,maximizes its revenue (utility).

– Budget balance: The sum of all agent payments equals zero,therefore no money is extracted or injected into the system. This isparticularly important for any self-sustaining mechanism whereno external benefactor exists to subsidize the system.

These desirable properties may directly conflict with each another.Budget Balance and Efficiency conflict in the VCG mechanism, whichachieves only the latter property. The goal of the mechanism, forexample, in the context of task allocation, is to try to find the mostefficient means of getting a set of given tasks completed, satisfying all oftheir timing and Quality of Service constraints. However, the VCGmechanism is not revenue maximizing and is dependent on a benevolentmediator to subsidize the payments in the outcome that are necessary toincentivize truthful bidding.

2.2. The Generalized Vickrey Auction

For a given mechanism, a solution concept is used to predict the strat-egies agents will choose in order to maximize their utility, thus deter-mining an equilibrium position for the game. The GVA has a dominantstrategy equilibrium. This means that the best response strategy for eachagent remains the same, irrespective of its knowledge about other agentsor their actions. Agents bid their truthful valuation for an item and donot profit from under-estimating or exaggerating their valuation even ifthey know all other bids. This is a powerful solution concept and makesit unprofitable for agents to concern themselves with other agents bids.

The GVA also ensures optimal efficiency, thereby maximizing socialwelfare according to some objective such as fairness. However, it is notbudget balanced, and a benevolent external party, such as a govern-ment, may be required to supplement the budget.

To determine payments to each agent participating in the overalloptimal solution, the overall cost is determined without each agentpresent in turn. This involves mþ 1 optimization problems if m agentsparticipate in the optimal solution to the allocation problem. Forexample, in an auction for task assignment where any one of n agentscan receive only one task out of the m being auctioned, n�m agents will


not participate in the overall optimal solution so there is no need todetermine Vickrey payments for these agents.

2.3. Disadvantages of Generalized Vickrey Auctions

There are several disadvantages associated with the Vickrey mechanismthat are worth highlighting. If non-optimal solutions are found to theoptimization problems that determine the prices paid in a GVA (basedon the Vickrey–Clarkes–Groves mechanism) the mechanism is nolonger guaranteed to be truthful. This is a major disadvantage of theGVA. Various polynomial-time heuristics and approximation algo-rithms can provide good or near optimal solutions to intractableproblems very quickly. However, Nisan and Ronen (2000) showed,constructively, that a non-optimal solution can in fact result in pay-ments arbitrarily far from optimum. If an auctioneer seeks to approx-imate optimal solutions in a GVA using polynomial-time algorithms theresults may not be reliable and agents may have an incentive to lie.

Other limitations include reduced revenue compared with otherauctions and susceptibility to a fraudulent auctioneer. It is possible foran auctioneer to introduce fake bids just below the value of the winningbids to increase revenue. For this reason a trustworthy auctioneer isimperative in a GVA.

A GVA is also sensitive to bidder collusion. Bidders may coordinatetheir bid prices so that the bids remain artificially low. In this manner,the bidders get the item at a lower price than they normally would.

3. Case-Study: An OR-Based Approach

In order to demonstrate a classical approach to reducing the complexityof computing Vickrey payments, we will focus on the well-knownAssignment Problem and an Operations Research technique for solvingit. This case-study can be regarded as serving a pedagogical role dem-onstrating how Operations Research techniques can be used for fastVickrey pricing. The approach presented in this section relies on thecharacteristics of the underlying problem. Later in this paper we willpresent a more general approach to the more general case of combi-natorial auctions based on Constraint Programming that makes noassumptions about the structure of the underlying problem, while stillachieving improvements in the efficiency of Vickrey pricing.


We chose to focus on the Assignment Problem for the purposes ofour case-study for the following reasons. Hershberger and Suri solvedan open problem, presented by Nisan and Ronen (1999), when theypresented an algorithm for reducing the computational complexity ofVickrey payments for the specific case of shortest path routing in net-works (Hershberger and Suri, 2001). They reduced the overall timecomplexity to the same asymptotic complexity of the original problem.They also posed the following question: ‘‘Can one achieve similarimprovements in other network settings?’’. Hershberger and Suri alsoidentified the problem of auctioning m tasks amongst n self-interestedagents, where m < n, and how an optimal task allocation requiressolving the Assignment Problem.

An algorithm for solving it is the Hungarian Method, upon which webase our case-study. This is a well-known primal–dual algorithm. Thereare a number of approaches in the literature which are similar to thisapproach. Bikchandani et al. (2002) investigated how payments thatbidders receive under the Vickrey auction correspond to duality in linearprograms. Recent work by Parkes (2001) has also developed a primal–dual method to determine the Vickrey outcome efficiently. The approachwe demonstrate here uses techniques similar to those used by Parkes.

In the Assignment Problem, otherwise known as the (Minimum Costor Maximum Weight) Bipartite Matching Problem, the objective is tofind the matching with the greatest total weight, or alternatively with thelowest total cost. It has a diverse range of applications including aircraftpilot rostering and dormitory room assignment.

In the case of task auctioning, each agent owns some set of resourcesand submits its bid to complete a given task using these resources. Thetask description contains the due-date and Quality of Service require-ments. If an agent cannot meet these demands it will not bid for thetask. The optimal solution, having minimal cost, is computed by theauctioneer. The computation involves assigning all the tasks to separateagents. The Vickrey payments to each of the successful bidders iscomputed by removing each of them in turn from the problem andresolving the matching problem.

3.1. The Hungarian Method

The Hungarian Method is an algorithm that finds a maximum cardi-nality match in a graph. In our scenario this would equate to solving amatching problem in which all the edges have the same cost. The Kuhn–Munkres algorithm (Kuhn, 1955) is an extension of the Hungarian


Method in which an optimal assignment to a problem with weightededges is found, and this algorithm is often referred to as the HungarianMethod itself (Papdimitriou and Steiglitz, 1982; Knuth, 1993). It is nolonger the state-of-the-art OR algorithm for solving the AssignmentProblem but it does offer a straightforward implementation and anincremental architecture for finding solutions to slightly differingproblems, a feature we exploit here.

The Hungarian Method has Oðmn2Þ time complexity using a spe-cialized data-structure proposed by Papdimitriou and Steiglitz (1982).Therefore, solving m problems is Oðm2n2Þ, when there are m tasks and nbidders.

However, there are other approaches that could be taken. Floyd’salgorithm can be applied to find the shortest paths that takes Oðmn2Þ.Hung et al. (1993) described an algorithm for finding what they term as‘‘the most vital edges of matching in a bipartite graph’’. An edge is calleda most vital edge (MVE), with respect to a weighted matching, if itsremoval from the graph results in the largest decrease in the total weightof the maximum matching, or alternatively, the greatest increase in costin a minimal cost matching. The MVE algorithm finds a maximalweighted matching with each edge removed in turn, in order to find themost important edge. This is precisely what is required to calculateVickrey prices for each provider.

3.2. Bipartite matching preliminaries

A graph G is bipartite if the vertex set VðGÞ can be partitioned into twosets X and Y such that no two vertices in the same set are adjacent. Inthe case of the task allocation problem, the set X may represent the setof agents and set the Y represent the tasks. The edges between the nodesin these two sets are the bids, where jXj ¼ n and jYj ¼ m.1 See Figure 1for an example of a bipartite graph.

Figure 1. An example of a bipartite graph.


A matching in a graph G occurs if no two edges have a common end-vertex. A matching with the largest possible number of edges is called amaximum matching. If M is considered to be a matching of a graph G, avertex v is said to be saturated or covered by M if any edge of M isincident with v. A vertex that is unsaturated is also called free. A path,tree or cycle is alternating, relative to M, if its edges are alternately inEðGÞ nM and M, where EðGÞ denotes the set of edges in G. A path is anaugmenting path if it is an alternating path with free origin and terminus.A graph H is a subgraph of G if VðHÞ � VðGÞ and EðHÞ � EðGÞ de-noted by H � G. H is a spanning subgraph of G when VðGÞ ¼ VðHÞ.

The following property of matchings illustrates the importance ofaugmenting paths (Ratian et al., 1998):

Property 1. Let M be a matching of G and P is an augmenting pathrelative to M. The set difference of M and P, MDP, is also a matchingfor G and jMDPj ¼ jMj þ 1.

The exploitation of this property is integral to most maximummatching algorithms because it permits them to incrementally solveAssignment Problems. Thus, this property can be exploited for enablingfast computation of Vickrey payments.

3.3. Fast Vickrey payments for the Assignment Problem

To compute Vickrey payments quickly we exploit the incrementality ofthe Hungarian Method. In particular, we compute the best matchingsMi ¼ MðG n xiÞ for i ¼ 1; . . . ;m where agent xi participates in theoverall optimal solution, MðGÞ. Recall that optimal solutions are re-quired for each agent absent in turn in order to determine Vickreypayments for each agent.

The Hungarian Method can solve the problem incrementally,recomputing the optimal matching in a single iteration when a singleedge is discarded at a node of the search tree. After computing thesolution to the original minimum cost matching problem, we can dis-card all the edges incident with the vertex representing the agent whosepayment is being determined. An extra stage of the Hungarian Methodwill then lead to an optimal solution without that agent present.

We can, in fact, demonstrate that Vickrey pricing for n providersbidding for m tasks, where m < n, in the VCG mechanism, can becomputed in Oðmn2Þ time complexity using the Hungarian Method.


Firstly, we consider the complexity of computing Vickrey prices fromscratch each time. Each stage of the Hungarian Method augments thematching by one edge, therefore there is a maximum of mþ 1 stages tobe considered. To examine the complexity of each stage, the complex-ities for the search and dual variable modifications must be consideredseparately. Search requires Oðn2Þ operations, because each vertex isexamined sequentially and never re-examined. The removal of a vertexfrom X requires OðnÞ operations. However, for dual variable modifi-cations we either have a new vertex that is labeled or we have an aug-mentation. We can therefore have a maximum of n dual variablemodifications at each stage. Each modification takes OðnÞ time so eachstage requires Oðn2Þ operations. Solving m problems from scratch incursmðmþ 1Þ stages in total, therefore the overall time complexity becomesOððm2 þmÞðn2ÞÞ ¼ Oðm2n2Þ.

However, we can exploit the incrementality of the HungarianMethod to reduce the complexity of computing Vickrey prices by usingthe optimal solution to the original optimization problem. One of thevertices in X is altered, in turn, so that the bids associated with one ofthe agents that participates in the overall optimal solution all becomezero, effectively removing the agent from the problem. The subsequentproblem therefore only requires one further stage to modify the dualvariables and search for an augmenting path. The time complexity tosolve m subproblems in this manner becomes Oðmn2Þ.

Note that we only need to solve m subproblems, even though thereare n providers because only m providers were assigned tasks in theoriginal solution so each one of these providers is omitted from eachsubproblem in turn.

3.4. Empirical verification

We have used an implementation of the Hungarian Method based uponone made available by Knuth (1993) that uses data structures proposedin Papdimitriou and Steiglitz (1982) and gives a time complexity ofOðmn2Þ. When calculating prices we have mþ 1 problems to solve so wewould naturally expect the running time to become Oðm2n2Þ, but theincremental nature of the Hungarian Method allows us to change onerow of the matrix and recompute a solution in Oðn2Þ.

We present the results of our experiments in Figure 2. Our maininterest in this graph are the three lines representing the results for theincremental approach that solves the Vickrey payment problemsincrementally. The slopes of all three lines �1. This empirical evidence


confirms the time complexity is Oðmn2Þ. Also notice that the naiveapproach of solving all pricing problems from scratch has slope �2.This confirms its complexity is Oðm2n2Þ.

This result demonstrates a positive answer to the question posed byHershberger and Suri (2001): whether a lower bound for the auctioningof m tasks amongst n providers where m < n, can be reduced to less thanthat of computing mþ 1 optimization problems.

4. A Constraint Programming Approach

The approach presented in the previous section can be regarded as aclassical approach to fast Vickrey pricing: we match an algorithm to thecharacteristics of the problem we wish to solve. In the case of the taskallocation problem we have presented in the previous section, theAssignment Problem provides a convenient model for encoding theproblem, while the Hungarian Method is one technique which can beused to compute an optimal solution and then compute Vickrey pricesefficiently. In this section we present a generic approach to computingVickrey prices efficiently in the context of combinatorial auctions, thatare known to be NP-complete in general. The approach is based onConstraint Programming (Kumar, 1992; Dechter, 2003). Taking inspi-ration from our case-study, we will present a technique that learns as itsearches so that we can compute Vickrey prices more efficiently than if

0.001

0.01

0.1

1

10

100

10 100 1000

Tim

e (s

ecs)

m

Solution times for solving matching problems using Hungarian Method

n=100, solving incrementallyn=200, solving incrementallyn=300, solving incrementally

n=100, non-incrementallyn=200, non-incrementallyn=300, non-incrementally

Figure 2. Comparative results for solving Vickrey pricing problems incrementally vs.

solving all pricing problems from scratch.


we did not learn. Furthermore, the approach we present can be regardedas more robust than classical methods since additional arbitrary con-straints, which we will refer to as side constraints, on the auction can benaturally assimilated into the constraint model.

The Constraint Satisfaction Problem (CSP) (Kumar, 1992) is mod-eled as a triple comprising a set of n variables X ¼ fx1; . . . ;xng, a set ofdomains D ¼ fDðx1Þ; . . . ;DðxnÞg, where DðxiÞ is the set of finite pos-sible values for variable xi and a set C ¼ fC1; . . . ;Cmg of constraints,each restricting the assignments of some subset of the variables in X.Constraint satisfaction involves finding values for each of the problemvariables such that all constraints are satisfied. Its main advantages areits declarative nature and flexibility in tackling problems with arbitraryside constraints.

Constraint Optimization seeks to find a solution to a CSP thatoptimizes some objective function. A common approach for solvingconstraint optimization problems is to use branch-and-bound tech-niques that avoid exploring sub-trees that are known not to contain abetter solution than the best found so far. An initial bound can bedetermined by finding a solution that satisfies all constraints in C or byusing some heuristic methods.

4.1. Dynamic problems and nogood learning

Schiex and Verfaillie introduced the concept of nogood learning forConstraint Satisfaction Problems. This technique was designed to tacklethe solution maintenance problem in a Dynamic CSP where the prob-lem is subject to change. A Dynamic CSP is defined as a sequence ofstatic CSPs, each one resulting from a modification to the precedingone. This change may be a restriction (addition of a constraint) or arelaxation (removal of a constraint). The main motivation for usingnogoods for Dynamic CSPs is to improve the search for new solutionsto the problem as efficiently as possible as changes occur over time.

Nogoods also provide a basis for learning during search by helping toavoid using assignments that cannot lead to a solution. For example,consider the following nogood: fðx1 ¼ 1Þ; x1 � x2g. This nogood statesthat x1 cannot be assigned the value 1, because of the constraint x1 � x2.

Definition 1. A nogood is a pair ðA; JÞ, where A is an assignment ofvalues to a subset of the variables in the CSP and J � C is the set ofconstraints precluding A from any solution to the CSP ðX; JÞ. The set Jis termed the nogood justification (Schiex and Verfaillie, 1994).


These techniques have been applied to Constraint OptimizationProblems, where the notion of valued nogoods has been introduced(Dago and Verfaillie, 1996). A valued nogood incorporates a value vsuch that every complete extension of the assignment A has a valuationless than or equal to v. An example of a valued nogood isfðx1 ¼ 7; x2 ¼ 7Þ; 100g. This valued nogood implies that if x1 ¼ 7 andx2 ¼ 7, we will not be able to extend to a solution with an objectivefunction value greater than 100 (when the objective is to maximize theoverall solution value).

Definition 2. A valued nogood is a pair ðA; vÞ, where A is a partialassignment of values to a subset of variables in the CSP and v is avaluation such that every complete extension of A has a valuation lessthan or equal to v (Dago and Verfaillie, 1996).

Note that it is possible to have a valued nogood at every node of thesearch tree. A valued nogood may also become redundant when anothervalued nogood is placed above it in the search tree, so pruning redun-dant nogoods may become necessary depending on the size of the searchspace.

4.2. Constraint programming and combinatorial auctions

We have studied how Constraint Programming (CP) techniques can beused to improve the efficiency with which Vickrey payments can becomputed in a constraint-based approach to combinatorial auctions,where bidders may show preferences for bundles of items. Combina-torial auctions enhance economic efficiency because bidders can specifypreferences over combinations of items that suit their needs rather thanhaving the auctioneer impose restrictions on sets of items that can besold together.

In a combinatorial auction the auctioneer is facedwith determining thewinning bids that maximize revenue. This is a Weighted Set-PackingProblem, otherwise known as the Winner Determination Problem(WDP).TheWDP isNP-complete and inapproximable but there has beenconsiderable progress in tackling this problem recently (Sandholm, 2002).

Dynamic CSP offers the ability to accommodate a change to theproblem specification and re-solving it quickly. Subsequent pricingproblems in a GVA may be viewed as perturbations to the initialproblem formulation, representing the auction, and nogoods learnedwhile solving the initial problem are still useful.


While CP may be unable to compete with specially tailored algo-rithms for specific problem classes, such as the Hungarian Method forthe Assignment Problem, in terms of performance, it has considerablepotential when applied to auctions with arbitrary side constraints thatpreclude the use of tailored approaches.

4.3. Constraint-based Vickrey pricing

Calculating Vickrey payments may be viewed in terms of a DynamicCSP. However, we have an advantage in that we can restrict the possiblechanges to the CSP to the removal of a single agent and her bids fromthe original problem. Each Vickrey pricing problem is a restriction ofthe original problem in which a constraint is added stipulating that allthe bids of a particular bidder must lose. Nogoods learned in the ori-ginal optimization problem may be used in all subsequent Vickreypricing problems to improve pricing efficiency.

There are no new nogoods recorded after the original problem be-cause such nogoods learned on a subsequent Vickrey problem are notnecessarily applicable to other Vickrey problems, that may be consid-ered a relaxation, including parts of the search space not explored inanother pricing problem.

One drawback of nogood learning is its worst-case exponential spacecomplexity. To establish a polynomial bound on the space complexityrequired by nogood learning, the cardinality of any assignment A in anogood may be restricted to being no greater than a given constant i,that we refer to as the order of the nogood (Dechter, 1990; Schiex andVerfaillie, 1994). Fortunately, smaller assignments, shorter nogoods, aremore useful because they eliminate larger branches of the search tree.We use the term ‘‘0th-order nogood’’ to refer to the situation where wedo not learn nogoods.

4.4. Experimental analysis

We used the Combinatorial Auction Test Suite (CATS) (Leyton-Brownet al., 2002) to generate sample auction data in order to test the per-formance of nogood learning in improving the efficiency of constraint-based Vickrey pricing in a combinatorial auction. We generated sampleproblems ranging from 40 to 100 bids on 20 items. We used both thearbitrary-npv and regions-npv distribution types. Distribution types inCATS are analogous to real-life scenarios. The regions-npv simulates anauction for items that complement each other because of their adja-


cency, such as a radio spectrum auction. The arbitrary-npv distributionsimulates agents’ preferences that exhibit arbitrary complementarities.2

We generated Constraint Optimization Problems from the CATSoutput files by representing bids as 0–1 variables. An item shared be-tween bids induces a binary constraint precluding the instantiation ofboth relevant variables to 1. We adopted a conservative approach togrouping bids to agents, whereby any bids not containing the samedummy item were regarded as being from different bidders. CATS usesdummy items in bids to simulate XOR-bids or substitutability.3 Teninstances of each problem were used to generate average results. Oursolver is implemented in Java (jdk 1.4.2) and all experiments wereconducted on a 1.8GHz Pentium 4 machine running Windows 2000.The variables were considered lexicographically during search.

Nogood learning leads to significant improvements over basicbranch-and-bound search (using 0th-order nogoods, i.e. not learningduring search at all) in the Vickrey pricing problems, as can be clearlyseen from Figure 3. The overhead incurred by recording nogoods isnegated by the performance improvement in the original problems. Infact, all initial problems (the winner determination phase) are alsosolved more quickly when learning and exploiting nogoods.

In the WDP, no classical nogoods are learned because there is asolution under every valid node of the search tree (all unset bid-vari-ables become zero). However, the valued nogoods alone significantlyimprove the performance. We found that 2nd-order nogood recordingoutperforms 1st-order and thus offers significant potential in tacklinglarger problems. However, there is a limit to the order of nogood that isworthwhile given the worst-case complexity of nogood recording.

4.5. Advantages of CP approach

One major benefit of CP over OR algorithms is its simplicity andstraightforward implementation. Its compact program structure permitsmore flexibility when different input constraints are required and offerseasier problem maintenance. OR algorithms are often difficult toimplement efficiently and rely on specialized data structures for goodperformance; Papdimitriou and Steiglitz (1982) describes a specializeddata structure for the Hungarian Method, for example.

Solutions to all the pricing sub-problems in the GVA must be opti-mal, thus precluding non-deterministic search algorithms. Simulated-annealing and genetic algorithms are both hill-climbing algorithms withrandom components that allow them to escape from local maxima, but


they are not guaranteed to find the optimal solution. A systematicsearch is necessary in order to guarantee optimality. Caseau and La-burthe (1997) and Focacci et al. (1999) provide evidence that constraintsoffer a promising alternative when more than one solution to amatching problem is required.

CP can offer other benefits to auctions such as incremental solving incases where perturbations occur that render a solution infeasible. Per-turbations for combinatorial auctions may include:

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

1.2

40 50 60 70 80 90 100

Tim

e lo

g10

(sec

)

Bids

Arbitrary Distribution - Vickrey Pricing

0th-order1st-order

2nd-order

-1

-0.5

0

0.5

1

1.5

40 50 60 70 80 90 100

Tim

e lo

g_{1

0}(s

ec)

Bids

Regions Distribution - Vickrey Pricing

0th order1st order

2nd order

-1

-0.5

0

0.5

1

1.5

40 50 60 70 80 90 100

Tim

e lo

g_{1

0}(s

ec)

Bids

0th order1st order

2nd order

(a) Arbitrary

(b) Regions

Figure 3. Effect of nogood learning for Vickrey-pricing.


– bid retraction;– bid addition;– change of valuation on a bid;– change in the set of desired items in a bid.

These perturbations can be represented as variable and constraintremovals or additions, and are relevant to areas such as Supply ChainManagement. Walsh, et al. (2000) have proposed using combinatorialauctions for the formation of efficient supply chains. Nogood learningcan offer performance enhancements when such unpredictable changesto the problem definition are envisaged. The problem may become re-laxed rather than restricted however, so it is necessary to record thejustifications also (see Section 4.1) so that when a constraint is removedirrelevant nogoods are discarded. Recall that a Vickrey pricing problemis always a restricted version of the original problem so justifications arenot necessary.

5. Conclusions

Ensuring truthfulness amongst self-interested agents bidding againstone another in an auction can be computationally expensive whenpayments are determined using the Vickrey–Clarke–Groves mechanism.This mechanism guarantees that each agent’s dominant strategy is to tellthe truth, but it requires solving nþ 1 optimization problems when theoverall optimal solution comprises n agents.

This paper first examined a case-study example demonstrating howOperations Research techniques can be used to compute Vickrey pricesefficiently. In particular, the case-study focused on the AssignmentProblem. We showed how, in that case, Vickrey prices can be computedin the same asymptotic time complexity as that of the original optimi-zation problem. This case-study can be seen as serving a pedagogicalrole in the paper illustrating how Operations Research techniques canbe used for fast Vickrey pricing.

We have proposed a Constraint Programming approach that can beused in a more general context, where nothing is assumed about thenature of the constraints that must be satisfied or the structure of theunderlying problem. In an auction scenario, no assumptions are madeabout the structure of the auction. In particular, we have demonstratedhow nogood learning can be used to improve the efficiency of con-straint-based Vickrey pricing in combinatorial auctions. In contrast,


specialized state-of-the-art OR techniques are ideal for solving specifictypes of problems quickly, but are not robust to changes in the structureof the problem.

Finally, while not considered here, we believe that CP algorithms canwork in harmony with OR algorithms to minimize the punitive com-putational burden of ensuring truthfulness. Using propagation andinference techniques, CP can be combined with OR to aid search whenthe conditions for solutions are complicated by additional constraints.This hybridization of techniques for fast Vickrey pricing is just oneaspect of the very exciting research agenda that this area has to offer.

Acknowledgment

The research has received support from Enterprise Ireland through theirResearch Innovation Fund (grant number RIF-2001-317).

Notes

1 Note that this notation for bipartite matchings differs from general graph literaturewhere m denotes the number of edges in a graph and n for the number of vertices. Our

notation is derived from Papdimitriou and Steiglitz (1982).2 The CATS flags included int_prices with the bid_alpha parameter set to 1000.3 Dominated bids are excluded by CATS, but such bids may influence Vickrey payments.

Bids that are only dominated by the relevant agent’s bids in a pricing problem should beincluded, so as the problem size grows the relative effect of this omission is reduced.

References

Bikhchandani, S., de Vries, S., Schummer, J. & Vohra, R. (2002). Linear Programmingand Vickrey Auctions. In Mathematics of the Internet: E-Auction and Markets, 75–115.

Caseau, Y. & Laburthe, F. (1997). Solving Various Weighted Matching Problems with

Constraints. In Principles and Practice of Constraint Programming, 17–31.Dago, P. & Verfaillie, G. (1996). Nogood Recording for Valued Constraint Satisfaction

Problems. In Proceedings of the 8th International Conference on Tools with Artificial

Intelligence ðICTAI ’96Þ, 132–139.Dechter, R. (1990). Enhancement schemes for constraint processing: Backjumping,

learning and cutset decomposition. Artificial Intelligence 41(2): 273–312.

Dechter, R. (2003). Constraint Processing. Morgan Kaufmann.Dijkstra, E. W. (1959). A note on two problems in connexion with graphs. Numerische

Mathematik 1: 269–271.


Edmonds, J. & Karp, R. M. (1972). Theoretical Improvements in algorithmic efficiencyfor network flow problems. Journal of the Association of Computing Machinery

19(2): 248–264.Focacci, F., Lodi, A. & Milano, M. (1999). Integration of CP and OR methods for

matching problems. In CP-AI-OR’99 Workshop on Integration of AI and OR tech-

niques in Constraint Programming for Combinatorial Optimization Problems.Foster, I. (2001). The Anatomy of the Grid: Enabling Scalable Virtual Organizations.

Lecture Notes in Computer Science 2150.Fredman, M. L. & Tarjan, R. E. (1984). Network flow and testing graph connectivity.

In 25th FOCS, 338–346.Gondran, M. & Minoux, M. (1984). Graphs et Algorithmes. Wiley, English edition.

Translated by Steven Vajda.

Hershberger, J. & Suri, S. (2001). Vickrey Pricing in Network Routing: Fast PaymentComputation. In Proceedings of the 42nd IEEE Symposium on Foundations ofComputer Science, 252–259.

Hung, C.-N., Hsu, L.-H. & Sung, T.-Y. (1993). The Most Vital Edges in a BipartiteGraph. Networks 23(4): 309–313.

Knuth, D. E. (1993). The Stanford GraphBase. Addison Wesley.

Kuhn, H. W. (1955). The Hungarian Method for the Assignment Problem. Naval Re-search Quarterly 2: 83.

Kumar, V. (1992). Algorithms for constraint-satisfaction problems: A survey. AIMagazine 13(1): 32–44.

Leyton-Brown, K. Pearson, M. & Shoham, M. (2000). Towards a universal test suite forcombinatorial auction algorithms. In ACM Conference on Electronic Commerce, 66–76.

Mas-Collel, A., Whinston, M. D. & Green, J. R. (1995). Microeconomic Theory. OxfordUniversity Press.

Nisan, N. & Ronen, A. (1999). Algorithmic Mechanism Design. In Proceedings of the

31st Annual ACM Symposium on Theory Computing.Nisan, N. & Ronen, A. (2000). Computationally feasible VCG mechanisms. In ACM

Conference on Electronic Commerce, 242–252.Papdimitriou, C. H. & Steiglitz, K. (1982). Combinatorial Optimisation. Prentice-Hall.

Parkes, D. C. (2001). Iterative Combinatorial Auctions: Achieving Economic and Com-putational Efficiency. Ph.D. Thesis, Department of Computer and InformationScience, University of Pennsylvania, May 2001.

Ratian, A. S., Denley, T. M. & Haggkvist, R. (1998). Bipartite Graphs and theirApplications. Cambridge University Press.

Sandholm, T. (2002). Algorithm for Optimal Winner Determination in Combinatorial

Auctions. Artificial Intelligence 135(1–2): 1–54.Schiex, T. & Verfaillie, G. (1994). Nogood Recording for Static and Dynamic Con-

straint Satisfaction Problem. International Journal on Artificial Intelligence Tools

(IJAIT) 3(2): 187–207.Vickrey, W. (1961). Counterspeculation, auctions, and competitive sealed tenders.

Journal of Finance: 8–37.Walsh, W. Wellman, M. & Ygge, F. (2000). Combinatorial Auctions for Supply Chain

Formulation. ACM Conference on Electronic Commerce.


towards fast vickrey pricing using constraint programming

Documents