Frugal Mechanism Design via Spectral Techniques
Abstract
We study the design of truthful mechanisms for set systems, i.e., scenarios where a customer needs to hire a team of agents to perform a complex task. In this setting, frugality [2] provides a measure to evaluate the “cost of truthfulness”, that is, the overpayment of a truthful mechanism relative to the “fair” payment.
We propose a uniform scheme for designing frugal truthful mechanisms for general set systems. Our scheme is based on scaling the agents’ bids using the eigenvector of a matrix that encodes the interdependencies between the agents. We demonstrate that the outofsystem mechanism and the mechanism for buying a path in a graph [21] can be viewed as instantiations of our scheme. We then apply our scheme to two other classes of set systems, namely, vertex cover systems [6, 10] and path systems, in which a customer needs to purchase edgedisjoint sourcesink paths. For both settings, we bound the frugality of our mechanism in terms of the largest eigenvalue of the respective interdependency matrix.
We show that our mechanism is optimal for a large subclass of vertex cover systems satisfying a simple local sparsity condition. For path systems, while our mechanism is within a factor of from optimal, we show that it is, in fact, optimal, when one uses a modified definition of frugality proposed in [10]. Our lower bound argument combines spectral techniques and Young’s inequality, and is applicable to all set systems. As both outof systems and single path systems can be viewed as special cases of path systems, our result improves the lower bounds of [21] and answers several open questions proposed in [21].
1 Introduction
Consider a scenario where a customer wishes to purchase the rights to have data routed on his behalf from a source to a destination in a network where each edge is owned by a selfishly motivated agent. Each agent incurs a privately known cost if the data is routed through his edge, and wants to be compensated for this cost, and, if possible, make a profit. The customer needs to decide which edges to buy, and wants to minimize his total expense.
This problem is a special case of the hiringateam problem [27, 21, 20, 5, 10]: Given a set of agents , a customer wishes to hire a team of agents capable of performing a certain complex task on his behalf. A subset is said to be feasible if the agents in can jointly perform the complex task. This scenario can be described by a set system , where is the set of agents and is the collection of feasible sets. Each agent can perform a simple task at a privately known cost . In such environments, a natural way to make the hiring decisions is by means of mechanisms — Each agent submits a bid , i.e., the payment that he wants to receive, and based on these bids the customer selects a feasible set (the set of winners), and determines the payment to each agent in .
A desirable property of mechanisms is that of truthfulness: It should be in the best interest of every agent to bid his true cost, i.e. to set no matter what bids other agents submit; that is, truthtelling should be a dominant strategy for every agent. Truthfulness is a strong and very appealing concept: it obviates the need for agents to perform complex strategic computations, even if they do not know the costs and strategies of others. This property is especially important in the Internet and electronic commerce settings, as most protocols are executed instantly.
One of the most celebrated truthful designs is the VCG mechanism [28, 7, 18], where the feasible set with the smallest total bid wins, and the payment to each agent in the winning set is his threshold bid, i.e., the highest value that could have bid to still be part of a winning set. While VCG mechanism is truthful, on the negative side, it can make the customer pay far more than the true cost of the winning set, or even the cheapest alternative, as illustrated by the following example: There are two parallel paths and from to , has one edge with cost 1 and has edges with cost 0 each. VCG selects as the winning path and pays 1 to every edge in . Hence, the total payment of VCG is , the number of edges in , which is far more than the total cost of both and .
The VCG overpayment property illustrated above is clearly undesirable from the customer’s perspective, and thus motivates the search for truthful mechanisms that are frugal, i.e., select a feasible set and induce truthful cost revelation without resulting in high overpayment. However, formalizing the notion of frugality is a challenging problem, as it is not immediately clear what the payment of a mechanism should be compared to. A natural candidate for this benchmark is the total cost of the closest competitor, i.e., the cost of the cheapest feasible set among those that are disjoint from the winning set. This definition coincides with the second highest bid in singleitem auctions and has been used in, e.g., [1, 2, 27, 11]. However, as observed by Karlin, Kempe and Tamir [21], such feasible set may not exist at all, even in monopolyfree set systems (i.e., set systems where no agent appears in all feasible sets). To deal with this problem, [21] proposed an alternative benchmark, which is bounded for any monopolyfree set system and is closely related to the buyeroptimal Nash equilibrium of firstprice auctions (see Definition 2.2). Nash equilibrium corresponds to a stable outcome of the bargaining process, and therefore provides a natural lower bound on the total payment of any dominant strategy mechanism. Throughout the paper, we use the benchmark of [21], as well as its somewhat more relaxed variant suggested in [10] to study frugality of truthful mechanisms.
1.1 Our Results
Uniform Frugal Truthful Mechanisms.
We propose a uniform scheme, which we call PruningLifting Mechanism, to design frugal truthful mechanisms for set systems. At a highlevel view, this mechanism consists of two key steps: pruning and lifting.

Pruning. In a general set system, the relationships among the agents can be arbitrarily complicated. Thus, in the pruning step, we remove agents from the system so as to expose the structure of the competition. Intuitively, the goal is to keep only the agents who are going to play a role in determining the bids in Nash equilibrium; this enables us to compare the payoffs of our mechanism to the total equilibrium payment. Since we decide which agents to prune based on their bids, we have to make our choices carefully so as to preserve truthfulness.

Lifting. The goal of the lifting process is to “lift” the bid of each remaining agent so as to take into account the size of each feasible set. For this purpose, we use a graphtheoretic approach inspired by the ideas in [21]. Namely, we construct a graph whose vertices are agents, and there is an edge between two agents and if removing both and results in a system with no feasible solution. We call the dependency graph of the pruned system. We then compute the largest eigenvalue of (or, more precisely, the maximum of the largest eigenvalues of its connected components), which we denote by , and scale the bid of each agent by the respective coordinate of the eigenvector that corresponds to .
A given set system may be pruned in different ways, thus leading to different values of . We will refer to the largest of them, i.e., , as the eigenvalue of our set system. It turns out that this quantity plays an important role in our analysis.
We show that the outofsystem mechanism and the mechanism for the single path problem that were presented in [21] can be viewed as instantiations of our PruningLifting Mechanism. We then apply our scheme to two other classes of set systems: vertex cover systems, where the goal is to buy a vertex cover in a given graph, and path systems, where the goal is to buy edgedisjoint paths between two vertices of a given graph.
The path problem generalizes both the outof problem and the single path problem, and captures many other natural scenarios. However, this problem received limited attention from the algorithmic mechanism design community so far (see, however, [19]), perhaps due to its inherent difficulty: the interactions among the agents can be quite complex, and, prior to this work, it was not known how to characterize Nash equilibria of the firstprice auctions for this setting in terms of the network structure. In this paper, we obtain a strong lower bound on the total payments in Nash equilibria. We then use this bound to show that a natural variant of the PruningLifting Mechanism that prunes all edges except those in the cheapest flow of size has frugality ratio . Moreover, we show that this bound can be improved by a factor of if we consider a weaker payment bound suggested in [10], which corresponds to a buyerpessimal rather than buyeroptimal Nash equilibrium (i.e., the difference between two frugality bounds is akin to that between the price of anarchy and the price of stability).
For the vertex cover problem, an earlier paper [10] described a mechanism with frugality ratio , where is the maximum degree of the input graph. Our approach results in a mechanism whose frugality ratio equals to the largest eigenvalue of the adjacency matrix of the input graph. As for any graph , this means that we improve the result of [10] by at least a factor of 2 for all graphs. Surprisingly, this stronger bound can be obtained by a simple modification of the analysis in [10].
Lower Bounds.
We complement the bounds on the frugality of the PruningLifting Mechanism by proving strong lower bounds on the frugality of (almost) any truthful mechanism. In more detail, we exhibit a family of cost vectors on which the payment of any measurable truthful mechanism can be lowerbounded in terms of , where we call a mechanism measurable if the payment to any agent — as a function of other agents’ bids — is a Lebesgue measurable function. Lebesgue measurability is a much weaker condition than continuity or monotonicity; indeed, a mechanism that does not satisfy this condition is unlikely to be practically implementable! Our argument relies on Young’s inequality and applies to any set system.
To turn this lower bound on payments into a lower bound on frugality, we need to understand the structure of Nash equilibria for the bid vectors employed in our proof. For path systems, we can achieve this by using our characterization of Nash equilibria in such systems. As a result, we obtain a lower bound on frugality of any “measurable” truthful mechanism that shows that our mechanism is within a factor of from optimal. Moreover, it is, in fact, optimal, with respect to the weaker payment bound of [10]. For outof systems and single path systems, our bound improves the lower bounds on frugality given in [21] by a factor of and , respectively. Our results give strong evidence that simply choosing the cheapest flow mechanism, which generalizes the mechanism [21] for , is indeed an optimal frugal mechanism for paths systems.
For the vertex cover problem, characterizing the Nash equilibria turns out to be a more difficult task: in this case, the graph is equal to the input graph, and therefore is not guaranteed to have any regularity properties. However, we can still obtain nontrivial upper bounds on the payments in Nash equilibria. These bounds enable us to show that our mechanism for vertex cover is optimal for all trianglefree graphs, and, more generally, for all graphs that satisfy a simple local sparsity condition.
1.2 Related Work
There is a substantial literature on designing mechanisms with small payment for shortest path systems [2, 11, 12, 8, 9, 19, 29] as well as for other set systems [27, 6, 4, 21, 10], starting with the seminal work of Nisan and Ronen [26]. Our work is most closely related to [21], [10] and [29]: we employ the frugality benchmark defined in [21], improve the bounds of [21] and [10], and generalize the result of [29].
Simultaneously and independently, the idea of bounding frugality ratios of set system auctions in terms of eigenvalues of certain matrices was proposed by Kempe et al. [23]. In contrast with our work, in [23] the authors only study the frugality ratio of their mechanisms with respect to the relaxed payment bound (see Section 5). Their approach results in a 2competitive mechanism for vertex cover systems, 2(k+1)competitive mechanism for path systems, and a competitive mechanism for cut auctions.
2 Preliminaries
A set system is given by a set of agents and a collection of feasible sets. We restrict our attention to monopolyfree set systems, i.e., we require . Each agent has a privately known cost that represents the expenses that agent incurs if he is involved in performing the task.
A mechanism for a set system takes a bid vector as input, where for any , and outputs a set of winners and a payment for each . We require mechanisms to satisfy voluntary participation, i.e. for each and for each .
Given the output of a mechanism, the utility of an agent is if is a winner and 0 otherwise. We assume that agents are rational, i.e. aim to maximize their own utility. Thus, they may lie about their true costs, i.e. bid if they can profit by doing so. We say that a mechanism is truthful if every agent maximizes his utility by bidding his true value, no matter what bids other agents submit. A weaker solution concept is that of Nash equilibrium: a bid vector constitutes a (pure) Nash equilibrium if no agent can increase his utility by unilaterally changing his bid. Nash equilibria describe stable states of the market and can be seen as natural outcomes of a bargaining process.
There is a wellknown characterization of winner selection rules that yield truthful mechanisms.
Theorem 2.1 ([24, 2]).
A mechanism is truthful if and only if its winner selection rule is monotone, i.e., no losing agent can become a winner by increasing his bid, given the fixed bids of all other agents. Further, for a given monotone selection rule, there is a unique truthful mechanism with this selection rule: the payment to each winner is his threshold bid, i.e. the highest value he could bid and still win.
An example of a truthful set system auction is given by the VCG mechanism [28, 7, 18]. However, as discussed in Section 1, VCG often results in a large overpayment to winners. Another natural mechanism for buying a set is the firstprice auction: given the bid vector , pick a subset minimizing , and pay each winner his bid . While the firstprice auction is not truthful, and more generally, does not possess dominant strategies, it essentially admits a Nash equilibrium with a relatively small total payment. (More accurately, as observed by [19], a firstprice auction may not have a pure strategy Nash equilibrium. However, this nonexistence result can be circumvented in several ways, e.g. by considering instead an Nash equilibrium for arbitrarily small or using oracle access to the true costs of agents to break ties.) The payment in a buyeroptimal Nash equilibrium would constitute a natural benchmark for truthful mechanisms. However, due to the difficulties described above, we use instead the following benchmark proposed by Karlin et al. [21], which captures the main properties of a Nash equilibrium.
Definition 2.2 (Benchmark [21]).
Given a set system , and a feasible set of minimum total cost w.r.t. , let be the value of an optimal solution to the following optimization problem:
s.t.  
Intuitively, in the optimal solution of the above system, is the set of winners in the firstprice auction. By condition (3), no winner can improve his utility by increasing his bid , as he would not be a winner anymore. In addition, by conditions (1) and (2), no agent can obtain a positive utility by decreasing his bid. Hence, gives the value of the cheapest Nash equilibrium of the firstprice auction assuming that the most “efficient” feasible set wins.
Definition 2.3 (Frugality Ratio).
Let be a truthful mechanism for the set system and let denote the total payment of when the true costs are given by a vector . Then the frugality ratio of on is defined as . Further, the frugality ratio of is defined as .
3 PruningLifting Mechanism
In this section, we describe a general scheme for designing truthful mechanisms for set systems, which we call PruningLifting Mechanism. For a given set system , the mechanism is composed of the following steps:

Pruning. The goal of the pruning process is to drop some elements of to expose the structure of the competition between the agents; we denote the set of surviving agents by . We require the process to satisfy the following properties:

Monotonicity: for any given vector of other agents’ bids, if an agent is dropped when he bids , he is also dropped if he bids any . We set .

Bidindependence: for any given vector of other agents’ bids, let and be two bids of agent such that is not dropped when he submits either of them. Then for both of these bids the set of remaining agents is the same. That is, cannot control the outcome of the pruning process as long as he survives. Monotonicity and bidindependence conditions are important to ensure the truthfulness of the mechanism.

Monopolyfreeness: the remaining set system must remain monopolyfree, i.e., , where . This condition is necessary because in the winner selection stage we will choose a winning feasible set from . Therefore, we have to make sure that no winning agent can charge an arbitrarily high price due to lack of competition.


Lifting. The goal of the lifting process is to assign a weight to each agent in in order to take into account the size of each feasible set. To this end, construct an undirected graph by (a) introducing a node for each , and (b) connecting and if and only if any feasible set in contains either or . We will refer to as the dependency graph of . For each connected component of , compute the largest eigenvalue of its adjacency matrix , and let be the eigenvector of associated with . That is, , where . Set .

Winner selection. Define for each , and select a feasible set with the smallest total bids w.r.t. . Let be the threshold bid for to be selected at this stage.

Payment. The payment to each winner is , where and are the two thresholds defined above.
Recall that the largest eigenvalue of the adjacency matrix of a connected graph is positive and its associated eigenvector has strictly positive coordinates [15]. Therefore, for all .
We will now define a quantity that will be instrumental in characterizing the frugality ratio of truthful mechanisms on . Let be the collection of all monopolyfree subsets of , i.e., set . The elements of are the possible outcomes of the pruning stage. For any subset , let be its dependency graph and be the adjacency matrix of . Let be the largest eigenvalue of (or the maximum of the largest eigenvalues of the adjacency matrices of the connected components of , if is not connected). Set ; we will refer to as the eigenvalue of the set system .
Note that once is selected in the pruning step, the computation of and the weight vector does not depend on the bid vector. This property is crucial for showing that our mechanism is truthful. (Due to space limits, most proofs in the paper are relegated to the Appendix.)
Theorem 3.1.
PruningLifting Mechanism is truthful for any set system .
In the rest of this section, we will show that the mechanisms for outof systems and single path systems proposed in [21] can be viewed as instantiations of our PruningLifting Mechanism. By Theorems 2.1 and 3.1, we can ignore the payment rule in the following discussion.
3.1 outof Systems Revisited
In an outof system, the set of agents is a union of disjoint subsets and the feasible sets are unions of exactly of those subsets. Given a bid vector , renumber the subsets in order of nondecreasing bids, i.e., .
The mechanism proposed in [21] deletes all but the first subsets, and then solves a system of equations given by
It then scales the bid of each set by setting , discards the set with the highest scaled bid w.r.t. , and outputs the remaining sets.
Now, clearly, the first step of this mechanism can be interpreted as a pruning stage. Further, for outof systems the graph constructed in the lifting stage of our mechanism is a complete partite graph. It is not hard to verify that for any positive solution of the system (), gives the largest eigenvalue of the adjacency matrix of and is the corresponding eigenvector. Thus, the mechanism of [21] implements PruningLifting Mechanism for outof systems.
3.2 Single Path Mechanisms Revisited
In a single path system, agents are edges of a given directed graph with two specified vertices and , i.e. and consists of all sets of edges that contain a path from to .
Given a bid vector , the mechanism [21] first selects two edgedisjoint  paths and that minimize . Assume that and intersect at , in the order in which they appear in and . Let and be the subpaths of and from to , respectively. The mechanism sets for , for , and chooses a cheapest path in w.r.t. .
As in the previous case, the selection of and can be viewed as the pruning process. The corresponding graph consists of connected components, where the th component is a complete bipartite graph with parts of size and . Its largest eigenvalue is given by , and the coordinates of the corresponding eigenvector are given by for and for . Thus, the mechanism can be viewed as a special case of the PruningLifting Mechanism. It is shown that the frugality ratio of the mechanism is within a factor of from optimal; Theorem 6.5 below shows that this bound can be improved by a factor of (this has also been shown by Yan [29] via a proof that is considerably more complicated than ours).
4 Vertex Cover Systems
In the vertex cover problem, we are given a graph whose vertices are owned by selfish agents. Our goal is to purchase a vertex cover of . That is, we have , and is the collection of all vertex covers of . Let denote the adjacency matrix of , and let , and denote, respectively, the maximum degree of , the largest eigenvalue of and the corresponding eigenvector.
We will use the pruninglifting scheme to construct a mechanism whose frugality ratio is ; this improves the bound of given in [10] by at least a factor of 2 for all graphs, and by as much as a factor of for some graphs (e.g., the star).
Observe first that the vertex cover system plays a special role in the analysis of the performance of the pruninglifting scheme. Indeed, on one hand, it is straightforward to apply the PruningLifting Mechanism to this system: since removing any agent will make each of its neighbors a monopolist, the pruning stage of our scheme is redundant, i.e., . That is, there is a unique implementation of PruningLifting Mechanism for vertex cover systems: we set for all , pick any to be the winning set, and pay each agent his threshold bid . On the other hand, for general set systems, any feasible set in the pruned system corresponds to a vertex cover of : indeed, by construction of the graph , any feasible set must contain at least one endpoint of any edge of . In general, the converse is not true: a vertex cover of is not necessarily a feasible set. However, for path systems it is possible to show that any cover of corresponds to a flow. We can use this fact to provide an alternative proof of Theorems 5.1 and 5.6.
We will now bound the frugality of PruningLifting Mechanism for vertex cover systems.
Theorem 4.1.
The frugality ratio of PruningLifting Mechanism for vertex cover systems on a graph is at most .
Proof.
Since our mechanism is truthful, we have for all . By optimality of we have , and therefore . Thus, we can bound the total payment of our mechanism given a bid vector as
Lemma 8 in [10] shows that for any cost vector we have . Therefore, the frugality ratio of PruningLifting Mechanism for vertex cover on is at most . ∎
In Section 6.1 we show that our mechanism is optimal for a large class of graphs.
4.1 Computational Issues
To implement PruningLifting Mechanism for vertex cover, we need to select the vertex cover that minimizes the scaled costs given by , i.e., to solve an NPhard problem. However, the argument in Theorem 4.1 applies to any truthful mechanism that selects a locally optimal solution, i.e., a vertex cover that satisfies for all . Paper [10] argues that any monotone winner selection algorithm for vertex cover can be transformed into a locally optimal one, and shows that a variant of the classic 2approximation algorithm for this problem [3] is monotone. This leads to the following corollary.
Corollary 4.2.
There exists a truthful polynomialtime vertex cover auction that given a graph outputs a solution whose cost is within a factor of from optimal and whose frugality ratio is at most .
5 Multiple Paths Systems
In this section, we study in detail paths systems for a given integer . In these systems, the set of agents is the set of edges of a directed graph with two specified vertices . The feasible sets are sets of edges that contain edgedisjoint  paths. Clearly, these set systems generalize both outof systems and single path systems.
Our mechanism for paths systems for a given directed graph , which we call PruningLifting Paths Mechanism, is a natural generalization of the mechanism [21]: In the pruning stage of our mechanism, given a bid vector , we pick edgedisjoint  paths so as to minimize their total bid w.r.t. the bid vector . Clearly, this procedure is monotone and bidindependent. Let denote the subgraph composed of these paths. The remaining steps of the mechanism (lifting, winner selection, payment determination) are the same as in the general case (Section 3). Since the PruningLifting Paths Mechanism is an implementation of the PruningLifting Mechanism, Theorem 3.1 implies that it is truthful.
Let denote the set of all subgraphs of that can be represented as a union of edgedisjoint  paths in . For any , let denote the dependency graph of , and let denote the maximum of the largest eigenvalues of the connected components of . Set . We can bound the frugality ratio of our mechanism as follows.
Theorem 5.1.
The frugality ratio of PruningLifting Paths Mechanism is at most .
To prove Theorem 5.1, we need the following definition.
Definition 5.2 (Minimum Longest Path ).
For any edgedisjoint  paths in a directed graph , let denote the length of the longest  path w.r.t. cost vector in the subgraph composed of (if contains a positive length cycle, set ). Define
It turns out that we can give a lower bound on in terms of .
Lemma 5.3.
For any paths system on a given graph with costs , we have .
Let be the length of the longest path in , where is the output of our pruning process on the bid vector . Our second lemma gives an upper bound on the payment of our mechanism in terms of
Lemma 5.4.
For any paths system on a given graph with costs , the total payment of PruningLifting Paths Mechanism on is at most .
Theorem 5.1 now follows from Lemmas 5.3 and 5.4 and the observation that and (see Appendix B for details).
In Section 6.2, we show a lower bound of on the frugality ratio of essentially any truthful path mechanism; thus the frugality ratio of our mechanism is within a factor of from optimal. This gap leaves the question of whether there is a better truthful mechanism for paths systems. One might hope that a different pruning approach could lead to a smaller frugality ratio. In particular, the proof of Theorem 5.1 suggests that we could get a stronger result by pruning the graph so as to minimize the length of the longest path in the surviving graph . While the argument above shows that — under truthful bidding — such mechanism would have an optimal frugality ratio, unfortunately, it turns out that this pruning process is not monotone [22].
We can, however, show that our mechanism is optimal with respect to a weaker benchmark, namely, one that corresponds to a buyerpessimal rather than buyeroptimal Nash equilibrium. This benchmark was introduced in [10], and has been recently used by Kempe et al. [23]. As argued in [10] and [23], unlike , this benchmark enjoys natural monotonicity properties and is easier to work with.
Definition 5.5 (Benchmark [10]).
Given a set system , and a feasible set of minimum total cost w.r.t. , let be the value of an optimal solution to the following optimization problem:
s.t.  
We will refer to the quantity as the frugality ratio of a mechanism , where is the total payment of mechanism on a bid vector .
The programs for and differ in their objective function only: while minimizes the total payment, maximizes it. In particular, this means that in the program for we can omit constraint (3), i.e., can be obtained as a solution to a linear program. Kempe et al. [23] show that the frugality ratio of PruningLifting Paths Mechanism is within a factor of from optimal. Our next result, combined with the observation that our lower bound on the performance of “all” truthful mechanisms also holds for the frugality ratio, shows that PruningLifting Paths Mechanism is, in fact, optimal with respect to . The proof proceeds by constructing a bid vector that satisfies constraints (1) and (2) in the definition of and pays at least , and uses the observation that for any fixed network the cost of a flow of size is a convex piecewiselinear function of . Details of the proof are given in Appendix C.
Theorem 5.6.
The frugality ratio of PruningLifting Paths Mechanism is at most .
6 Lower Bounds
We say that a mechanism for a set system is measurable if the payment of any agent is a Lebesque measurable function of all agents’ bids. We will now use Young’s inequality to give a lower bound on total payments of any measurable truthful mechanism with bounded frugality ratio.
Theorem 6.1 (Young’s inequality).
Let , be two Lebesgue measurable functions that are bounded on their domain. Assume that whenever for some , , we have . Then
Fix a set system with and let be a subset with . For any , let denote a bid vector where bids , all agents in bid , and all agents in bid .
Lemma 6.2.
For any set system and any measurable truthful mechanism with bounded frugality ratio, there exists an agent and a real value such that the total payment of on bid vector is at least .
Proof.
Set , , , . We will assume from now on that is connected; if this is not the case, our argument can be applied without change to the connected component of that corresponds to . Let be the eigenvector of that is associated with . By normalization, we can assume that .
The proof is by contradiction: assume that there is a truthful mechanism that pays less than on any bid vector of the form for all and all . Recall that for any such bid vector the cost of each agent in is . Since and , this implies that never picks any agents from on any , i.e., effectively operates on . For any edge of and any , let denote the payment to on the bid vector . Observe that measurability of implies that is measurable (since it is a restriction of a measurable function). In this notation, our assumption can be restated as
(1) 
for all and any .
It is easy to see that given a bid vector with , never selects as a winner. Indeed, suppose that wins given . Then by the truthfulness of , if we reduce ’s true cost from to , still wins and receives a payment of at least . Since the set system restricted to is monopolyfree, the resulting cost vector satisfies conditions (1)–(3) in the definition of , and hence . Thus the frugality ratio of is , a contradiction. By the construction of , this means that any with wins given .
Now, fix some such that and , and consider a situation where bids , bids , all agents in bid , and all agents in bid . Clearly, in this situation agent loses and thus wins with a payment of at least . By the truthfulness of , the same holds if lowers his bid to . Thus, for any , implies .
By our assumption, we have , for . Hence, for any the functions and satisfy all conditions of Young’s inequality on .
Let , and consider the scalar product . We have . As we normalized so that , by Young’s inequality, we can bound by . Therefore,
where the last inequality follows from (1). This is a contradiction, so the proof is complete. ∎
6.1 Vertex Cover Systems
For vertex cover systems, deleting any of the agents would result in a monopoly. Therefore, Lemma 6.2 simply says that for any measurable truthful mechanism on a graph , there exists a such that the total payment on bid vector is at least , where is the largest eigenvalue of the adjacency matrix of and is the cost vector given by if , and if .
Given a graph and a vertex , let denote the set of all maximal cliques in that contain . Let denote the size of the smallest clique in .
Lemma 6.3.
We have for any .
Theorem 6.4.
For any graph , the frugality ratio of any measurable truthful vertex cover auction on is at least , where is the largest eigenvalue of the adjacency matrix of , and .
The bound given in Lemma 6.3 is not necessarily optimal; we can construct a family of graphs where for some vertex the quantity is linear in the size of the graph, while . Nevertheless, Theorem 6.4 shows that the mechanism described in Section 4 has optimal frugality ratio for, e.g., all trianglefree graphs and, more generally, all graphs such that the for each vertex , the subgraph induced on the neighbors of contains an isolated vertex.
6.2 Multiple Path Systems
Let be a path system on a graph . Consider a set with . It is not hard to see that is a union of edgedisjoint paths; this follows, e.g., from the proof of Theorem B.1. Hence, we have .
As before, for any , let denote the cost vector with , for all , for all . It is easy to see that we have for any , . Combining this observation with Lemma 6.2, we obtain the following result.
Theorem 6.5.
For any graph , both the frugality ratio and the frugality ratio of any measurable truthful path auction on are at least .
In Section 5, we show that the frugality ratio and the frugality ratio of PruningLifting Paths Mechanism are bounded by, respectively, and . Together with Theorem 6.5 this implies that PruningLifting Paths Mechanism has optimal frugality ratio, and its frugality ratio is within a factor of from optimal.
7 Conclusions and Open Problems
In this paper, we propose a uniform scheme for designing frugal truthful mechanisms. We show that several existing mechanisms can be viewed as instantiations of our scheme, and describe its applications to path systems and vertex cover systems. We demonstrate that our scheme produces mechanisms with good frugality ratios for path systems and a large subclass of vertex cover systems; for path systems, we show that our mechanism has the optimal frugality ratio. Moreover, all mechanisms described in this paper are polynomialtime computable. We believe that our scheme can be applied to many other set systems, resulting in mechanisms with nearoptimal frugality ratios.
It would be interesting to understand the limits of applicability of our scheme. Indeed, for some set systems the minimal monopolyfree subsystem does not necessarily exhibit a lot of connections between agents, i.e., the corresponding dependency graph is rather sparse. It seems that for such cases our scheme does not produce mechanisms with good frugality ratio. Formalizing this intuition and developing alternative approaches for designing frugal mechanisms in such settings is an interesting research direction.
8 Acknowledgements
We thank David Kempe, Christos Papadimitriou, and Yaron Singer for helpful discussions.
References
 [1] A. Archer, É. Tardos, Truthful Mechanisms for OneParameter Agents, FOCS 2001, 482491.
 [2] A. Archer, É. Tardos, Frugal Path Mechanisms, SODA 2002, 991999.
 [3] R. BarYehuda, S. Even, A Local Ratio Theorem for Approximating the Weighted Vertex Cover Problem, Annals of Discrete Mathematics, V.25, 2746, 1985.
 [4] S. Bikhchandani, S. de Vries, J. Schummer, R. Vohra, Linear Programming and Vickrey Auctions, IMA Volume in Mathematics and its Applications, Mathematics of the Internet: Eauction and Markets, V.127, 75116, 2001.
 [5] N. Chen, A. R. Karlin, Cheap Labor Can Be Expensive, SODA 2007, 707715.
 [6] G. Calinescu, Bounding the Payment of Approximate Truthful Mechanisms. ISAAC 2004, 221233.
 [7] E. H. Clarke, Multipart Pricing of Public Goods, Public Choice, V.11, 1733, 1971.
 [8] A. Czumaj, A. Ronen, On the Expected Payment of Mechanisms for Task Allocation, PODC 2004, 98106.
 [9] E. Elkind, True Costs of Cheap Labor are Hard to Measure: Edge Deletion and VCG Payments in Graphs, EC 2005, 108116.
 [10] E. Elkind, L. A. Goldberg, P. W. Goldberg, Frugality Ratios and Improved Truthful Mechanisms for Vertex Cover, EC 2007, 336345.
 [11] E. Elkind, A. Sahai, K. Steiglitz, Frugality in Path Auctions, SODA 2004, 701709.
 [12] J. Feigenbaum, C. H. Papadimitriou, R. Sami, S. Shenker, A BGPBased Mechanism for LowestCost Routing, PODC 2002, 173182.
 [13] L. R. Ford, D. R. Fulkerson, Maximal Flow through a Network, Canadian Journal of Mathematics, V.8, 399404, 1956.
 [14] S. Fortune, J. Hopcroft, J. Wyllie, The Directed Subgraph Homeomorphism Problem, Theoretical Computer Science, V.10(2), 111121, 1980.
 [15] C. Godsil, G. Royle, Algebraic Graph Theory, Graduate Texts in Mathematics, V.207, Springer, 2001.
 [16] A. V. Goldberg, R. E. Tarjan, Finding Minimum Cost Circulation by Canceling Negative Cycles, Journal of the ACM, V.36(4), 873886, 1989.
 [17] N. Gravin, N. Chen, A Note on Shortest Paths Problem, accepted by Journal of Graph Theory.
 [18] T. Groves, Incentives in Teams, Econometrica, V.41, 617631, 1973.
 [19] N. Immorlica, D. Karger, E. Nikolova, R. Sami, FirstPrice Path Auctions, EC 2005, 203212.
 [20] A. Iwasaki, D. Kempe, Y. Saito, M. Salek, M. Yokoo, FalseNameProof Mechanisms for Hiring a Team, WINE 2007, 245256.
 [21] A. R. Karlin, D. Kempe, T. Tamir, Beyond VCG: Frugality of Truthful Mechanisms, FOCS 2005, 615626.
 [22] D. Kempe, personal communication.
 [23] D. Kempe, M. Salek, C. Moore, Frugal and Truthful Auctions for Vertex Covers, Flows, and Cuts, arXiv:0912.3310.
 [24] V. Krishna, Auction Theory, Academic Press, 2002.
 [25] C. L. Li, S. T. McCormick, D. SimchiLevi, The Complexity of Finding Two Disjoint Paths with minmax Objective Function, Discrete Applied Mathematics, V.26(1), 105115, 1990.
 [26] N. Nisan, A. Ronen, Algorithmic Mechanism Design, STOC 1999, 129140.
 [27] K. Talwar, The Price of Truth: Frugality in Truthful Mechanisms, STACS 2003, 608619.
 [28] W. Vickrey, Counterspeculation, Auctions and Competitive Sealed Tenders, Journal of Finance, V.16, 837, 1961.
 [29] Q. Yan, On the Price of Truthfulness in Path Auctions, WINE 2007, 584589.
Appendix A Proof of Theorem 3.1
Proof.
For any agent and given bids of other agents, we will analyze the utility of in terms of his bid. There are the following two cases.
 Case 1.

Agent is not dropped out in the pruning process when bidding , i.e. . By the definition of , we know that . Consider the situation where bids another value . If , then and his utility is 0. If , by the bidindependence property, we know that the subset remains the same. Given this fact, the structure of the graph does not change, which implies that the eigenvectors and eigenvalues of its adjacency matrix do not change either. Hence, the threshold value will not change, which implies that the payment to agent , , will not change.
 Case 2.

Agent is dropped out in the pruning process when bidding , i.e. . Consider the situation where bids another value and is not dropped out. By monotonicity and bidindependence, we know that . Hence, even though could be a winner by bidding , his payment is at most , which implies that he cannot obtain a positive utility.
From the above two cases, we know that the utility of each agent is maximized by bidding his true cost, and hence the mechanism is truthful. ∎
Appendix B Analysis of PruningLifting Paths Mechanism
b.1 Lower Bound on
Our analysis of PruningLifting Paths Mechanism relies on the characterization of Nash flows presented in [17].
Theorem B.1 ([17]).
Let be a directed graph with weight on each edge . Given two specific vertices , assume that there are edgedisjoint paths from to . Let be such edgedisjoint  paths so that its total weight is minimized, where . Further, it is known that for every edge , the graph has edgedisjoint  paths with the same total weight . Then essentially there exist edgedisjoint  paths in such that each of them is a shortest path from to .
We will first show how Theorem B.1 implies Lemma 5.3. For completeness, we will then present a proof of Theorem B.1; this proof also appears in [17].
Proof of Lemma 5.3.
Fix a cost vector . Let be the winning set with respect to , and consider a bid vector that satisfies conditions (1)–(3) in the definition of . Let denote the total payment under . The set contains edgedisjoint  paths. By condition (2), no agent in can obtain more revenue by increasing his bid. That is, for any , there are edgedisjoint  paths in with the same total bid as . Applying Theorem B.1 with , we obtain that there are edgedisjoint shortest  paths with length each w.r.t . Consider the subgraph composed by these edgedisjoint paths. We know that as for any edge , i.e. the longest  path in w.r.t to is at most . Hence,
As this holds for any vector that satisfies conditions (1)–(3), it follows that . ∎
In the rest of this section, we prove Theorem B.1.
Proof of Theorem b.1.
Given the graph and integer , we construct a flow network as follows: We introduce two extra nodes and and two edges and . The set of vertices of is and the set of edges is . The capacity and cost per bulk capacity for each edge in is defined as follows:

and .

and , for .
Given the above construction, every path from to in naturally corresponds to a bulk flow from to in . Hence, the set of edgedisjoint paths in corresponds to a flow of size in . In addition, the minimality of implies that achieves the minimum cost (which is ) for all integervalued flows of size , i.e. maximum flow in . Since all capacities of are integers, we can conclude that has the minimum cost among all real maximum flows in . (The proof of this fact can be found in, e.g., [16].)
For simplicity, we denote the subgraph by . By the fact that for any , the subgraph has edgedisjoint  paths with the same total weight , we know that in the network , there still is an integervalued flow of size and cost . So is also an integervalued flow of size and cost in . Define a realvalued flow in by . We have the following observations:

It is clear that for every arc , where is the amount of flow on edge in , as we have taken the arithmetic average of the flows in the network.

has cost .

Since for any , we have . In addition, as each is a feasible flow that satisfies all conservation conditions and is defined by the arithmetic average of all ’s, we know that also satisfies all conservation conditions.
Therefore, is a minimum cost maximum flow in . In addition, has the following nice property, which plays a fundamental role for the proof:

For every edge except and , we have , as does not flow through , i.e. , and is either 0 or 1 for any .
Let . Suppose that there is a path from to which goes only along arcs in and is not a shortest path w.r.t from to in . Let . Since , we have . Let be a shortest path w.r.t from to in . Define a new flow from by adding amount of flow on path and removing amount of flow from path . We have the following observations about :

The size of flow is .

satisfies all conservation conditions as it is a linear combination of three flows from to .

By the definition of , the amount of flow of each edge is nonnegative in . Further, satisfies the capacity constrains. This follows from the facts that and the above property established for .

The cost of