# 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 -out-of--system 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] and -path systems, in which a customer needs to purchase edge-disjoint source-sink 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 -out-of- 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].

## 1Introduction

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 *hiring-a-team* problem [27]: 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, truth-telling 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], 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 single-item auctions and has been used in, e.g., [1]. However, as observed by Karlin, Kempe and Tamir [21], such feasible set may not exist at all, even in monopoly-free 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 monopoly-free set system and is closely related to the buyer-optimal Nash equilibrium of first-price auctions (see Definition ?). 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.1Our Results

**Uniform Frugal Truthful Mechanisms.** We propose a uniform scheme, which we call Pruning-Lifting Mechanism, to design frugal truthful mechanisms for set systems. At a high-level 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 graph-theoretic 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 -out-of--system mechanism and the -mechanism for the single path problem that were presented in [21] can be viewed as instantiations of our Pruning-Lifting 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 edge-disjoint paths between two vertices of a given graph.

The -path problem generalizes both the -out-of- 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 first-price 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 Pruning-Lifting 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 buyer-pessimal rather than buyer-optimal 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 Pruning-Lifting 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 lower-bounded 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 -out-of- 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 non-trivial upper bounds on the payments in Nash equilibria. These bounds enable us to show that our mechanism for vertex cover is optimal for all triangle-free graphs, and, more generally, for all graphs that satisfy a simple local sparsity condition.

### 1.2Related Work

There is a substantial literature on designing mechanisms with small payment for shortest path systems [2] as well as for other set systems [27], 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 2-competitive mechanism for vertex cover systems, 2(k+1)-competitive mechanism for -path systems, and a -competitive mechanism for cut auctions.

## 2Preliminaries

A *set system* is given by a set of *agents* and a collection of *feasible sets*. We restrict our attention to *monopoly-free* 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 well-known characterization of winner selection rules that yield truthful mechanisms.

An example of a truthful set system auction is given by the VCG mechanism [28]. However, as discussed in Section 1, VCG often results in a large overpayment to winners. Another natural mechanism for buying a set is the *first-price auction*: given the bid vector , pick a subset minimizing , and pay each winner his bid . While the first-price 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 first-price auction may not have a pure strategy Nash equilibrium. However, this non-existence 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 buyer-optimal 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.

Intuitively, in the optimal solution of the above system, is the set of winners in the first-price 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 first-price auction assuming that the most “efficient” feasible set wins.

## 3Pruning-Lifting Mechanism

In this section, we describe a general scheme for designing truthful mechanisms for set systems, which we call Pruning-Lifting 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 eb’.

Bid-independence: 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 bid-independence conditions are important to ensure the truthfulness of the mechanism.

Monopoly-freeness: the remaining set system must remain monopoly-free, 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 monopoly-free 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.)

In the rest of this section, we will show that the mechanisms for -out-of- systems and single path systems proposed in [21] can be viewed as instantiations of our Pruning-Lifting Mechanism. By Theorems ? and ?, we can ignore the payment rule in the following discussion.

### 3.1-out-of- Systems Revisited

In an -out-of- 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 non-decreasing 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 -out-of- 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 Pruning-Lifting Mechanism for -out-of- systems.

In [21] it is shown that the frugality ratio of this mechanism is , and that the frugality ratio of any truthful mechanism for -out-of- systems is at least . As -out-of- systems can be viewed as a special case of -path systems, Theorem ? allows us to improve this lower bound to .

### 3.2Single 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 edge-disjoint - 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 Pruning-Lifting Mechanism. It is shown that the frugality ratio of the -mechanism is within a factor of from optimal; Theorem ? 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).

## 4Vertex 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 pruning-lifting 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 pruning-lifting scheme. Indeed, on one hand, it is straightforward to apply the Pruning-Lifting 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 Pruning-Lifting Mechanism for vertex cover systems: we set for all , pick any G 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 ? and ?.

We will now bound the frugality of Pruning-Lifting Mechanism for vertex cover systems.

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 Pruning-Lifting 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.1Computational Issues

To implement Pruning-Lifting Mechanism for vertex cover, we need to select the vertex cover that minimizes the scaled costs given by , i.e., to solve an NP-hard problem. However, the argument in Theorem ? 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 2-approximation algorithm for this problem [3] is monotone. This leads to the following corollary.

## 5Multiple 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 edge-disjoint - paths. Clearly, these set systems generalize both -out-of- systems and single path systems.

Our mechanism for -paths systems for a given directed graph , which we call Pruning-Lifting -Paths Mechanism, is a natural generalization of the -mechanism [21]: In the pruning stage of our mechanism, given a bid vector , we pick edge-disjoint - paths so as to minimize their total bid w.r.t. the bid vector . Clearly, this procedure is monotone and bid-independent. 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 Section 3). Since the Pruning-Lifting -Paths Mechanism is an implementation of the Pruning-Lifting Mechanism, Theorem ? implies that it is truthful.

Let denote the set of all subgraphs of that can be represented as a union of edge-disjoint - 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.

To prove Theorem ?, we need the following definition.

It turns out that we can give a lower bound on in terms of .

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

Theorem ? now follows from Lemmas ? and ? 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 ? 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 buyer-pessimal rather than buyer-optimal 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.

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 Pruning-Lifting -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 Pruning-Lifting -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 piecewise-linear function of . Details of the proof are given in Appendix C.

## 6Lower 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.

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 .

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

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 monopoly-free, 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.1Vertex Cover Systems

For vertex cover systems, deleting any of the agents would result in a monopoly. Therefore, Lemma ? 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 .

Combining Lemma ? with Lemma ? yields the following result.

The bound given in Lemma ? 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 ? shows that the mechanism described in Section 4 has optimal frugality ratio for, e.g., all triangle-free graphs and, more generally, all graphs such that the for each vertex , the subgraph induced on the neighbors of contains an isolated vertex.

### 6.2Multiple 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 edge-disjoint paths; this follows, e.g., from the proof of Theorem ?. 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 ?, we obtain the following result.

In Section 5, we show that the frugality ratio and the -frugality ratio of Pruning-Lifting -Paths Mechanism are bounded by, respectively, and . Together with Theorem ? this implies that Pruning-Lifting -Paths Mechanism has optimal -frugality ratio, and its frugality ratio is within a factor of from optimal.

## 7Conclusions 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 polynomial-time computable. We believe that our scheme can be applied to many other set systems, resulting in mechanisms with near-optimal frugality ratios.

It would be interesting to understand the limits of applicability of our scheme. Indeed, for some set systems the minimal monopoly-free 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.

## 8Acknowledgements

We thank David Kempe, Christos Papadimitriou, and Yaron Singer for helpful discussions.

## AProof of Theorem

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 bid-independence 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 bid-independence, 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.

## BAnalysis of Pruning-Lifting -Paths Mechanism

### b.1Lower Bound on

Our analysis of Pruning-Lifting -Paths Mechanism relies on the characterization of Nash flows presented in [17].

We will first show how Theorem ? implies Lemma ?. For completeness, we will then present a proof of Theorem ?; this proof also appears in [17].

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 edge-disjoint - paths. By condition (2), no agent in can obtain more revenue by increasing his bid. That is, for any , there are edge-disjoint - paths in with the same total bid as . Applying Theorem ? with , we obtain that there are edge-disjoint shortest - paths with length each w.r.t . Consider the subgraph composed by these edge-disjoint 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 ?.

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 edge-disjoint paths in corresponds to a flow of size in . In addition, the minimality of implies that achieves the minimum cost (which is ) for all *integer*-valued 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 edge-disjoint - paths with the same total weight , we know that in the network , there still is an integer-valued flow of size and cost . So is also an integer-valued flow of size and cost in . Define a real-valued 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 non-negative in . Further, satisfies the capacity constrains. This follows from the facts that and the above property established for .

The cost of is smaller than because , which is smaller than as by the assumption.

Hence, is a flow of size in with cost smaller than , a contradiction. Thus, every path from to in along the edges in is a shortest path w.r.t .

Consider a new network obtained from by restricting edges in . (Note that the only difference between and is the capacity on edges and is rather than .) We claim that in this network there is an integer-valued flow of size . Suppose otherwise, by Ford-Fulkerson Theorem [13], there is a cut in with size less than or equal to . By definition, in we have and , which implies that and . By the definition of , we know that the total amount of flows of on the cut is . Since for any edge , we can conclude that there are at least edges from to in . This leads to a contradiction, because we have showed that the size of the cut is less than or equal to .

Therefore, we can find an integer-valued flow of size on edges in in the network . Such a flow can be thought as the union of edge-disjoint paths from to . We know that every such path going along edges in is a shortest path from to . This in turn concludes the proof, since we have found edge-disjoint shortest paths from to in .

### b.2Upper Bound on the Payment of Pruning-Lifting -Paths Mechanism

In this subsection, we will prove Lemma ?. Fix a cost vector and set , , . Observe that since is the cheapest collection of edge-disjoint paths in , it is necessarily cycle-free. We say that a vertex is an *articulation point* for if it lies on any - path in . Suppose that has *articulation points* that subdivide into parts . Denote by the induced subgraph of with vertex set , . For any graph , let and denote the sets of vertices and edges of , respectively. The following intermediate lemma describes the structure of the graph .

For each vertex , let be the corresponding edge in . Before we prove Lemma ?, we need the following two observations.

If there is a path such that , then in there are edge-disjoint - paths. Hence there is no edge between and . Conversely, if , then has edge-disjoint - paths. Removing these paths from leads to an - path going through and .

Since contains only edge-disjoint - paths, there is a cut of size in containing and this cut must contain an edge of . Thus, there exists a vertex with adjacent to in . For the first part of the claim, it remains to show that if is adjacent to and with , then so is for any with . Suppose otherwise, then by Claim ? there should be a path going through and for some . If goes through earlier than , we can construct a path in going through both and . Indeed, we can concatenate the prefix of that ends with and the suffix of that starts with ; this path is simple since is cycle-free. By a similar argument, if goes through earlier than , then we can construct a path in gong through and . For both cases we arrive at a contradiction with Claim ?, since and are adjacent to in .

This part can be derived from the first part and Claim ? applied to two pairs of vertices and .

We are now ready to prove Lemma ?.

Suppose that contains an articulation point . Then we can split into the union of two subgraphs (from to ) and (from to ). By the definition of , it can be seen that for any and , . Hence, if is connected, then has no articulation points.

On the other hand, suppose that has no articulation points. We can endow the set of nodes of with a partial order by putting if there is a path in from to . Suppose that is disconnected. Let be a connected component of . Let be the set of endpoints of the edges in corresponding to those vertices in . We claim that has a unique smallest element, denoted by . Suppose otherwise that has at least two different smallest elements and with and . Assume without loss of generality that . Then there is such that . There could not be a path going through both and , since in this case either or . Hence and are adjacent in , which implies that . But then we have and , a contradiction to the assumption that is a smallest element.

Since and are necessarily adjacent in , two different connected components and of cannot have the same smallest element, i.e. . Let us take the component with the smallest element . It is also clear by the definition of that . Let be a vertex of with the ending point at in . We want to show that is an articulation point for . Suppose otherwise that there is a path in which does not go through . Let correspond to and correspond to . Applying Claim ? to and , we get that is adjacent to in and there is a path from endpoint of in , i.e. , to the endpoint of . Thus we arrive at a contradiction, since and endpoint of is smaller than .

We will now prove Lemma ?.

Suppose first that has no articulation points. Let be a losing path in according to the mechanism. Then is the most expensive path in w.r.t. scaled cost vector. Assume that is represented as a sequence of vertices in and let be another vertex of . Let and be the two integers, , as defined in Claim ?. Note that the threshold bid of is at most