Truthful Mechanism Design for Multidimensional Covering Problems^{1}^{1}1A preliminary version appeared as [24]. Theorem 13 in [24] is incorrect; the correct statements appear as Theorem 4.10 and Corollary 4.11 here.
Abstract
We investigate multidimensional covering mechanismdesign problems, wherein there are items that need to be covered and agents who provide covering objects, with each agent having a private cost for the covering objects he provides. The goal is to select a set of covering objects of minimum total cost that together cover all the items.
We focus on two representative covering problems: uncapacitated facility location (UFL) and vertex cover (VC). For multidimensional UFL, we give a blackbox method to transform any Lagrangianmultiplierpreserving approximation algorithm for UFL to a truthfulinexpectation, approx. mechanism. This yields the first result for multidimensional UFL, namely a truthfulinexpectation 2approximation mechanism.
For multidimensional VC (MultiVC), we develop a decomposition method that reduces the mechanismdesign problem into the simpler task of constructing threshold mechanisms, which are a restricted class of truthful mechanisms, for simpler (in terms of graph structure or problem dimension) instances of MultiVC. By suitably designing the decomposition and the threshold mechanisms it uses as building blocks, we obtain truthful mechanisms with the following approximation ratios ( is the number of nodes): (1) for dimensional VC; and (2) for dimensional VC on any proper minorclosed family of graphs (which improves to if no two neighbors of a node belong to the same player). These are the first truthful mechanisms for MultiVC with nontrivial approximation guarantees.
1 Introduction
Algorithmic mechanism design (AMD) deals with efficientlycomputable algorithmic constructions in the presence of strategic players who hold the inputs to the problem, and may misreport their input if doing so benefits them. The challenge is to design algorithms that work well with the true (privatelyknown) input. In order to achieve this task, a mechanism specifies both an algorithm and a pricing or payment scheme that can be used to incentivize players to reveal their true inputs. A mechanism is said to be truthful, if each player maximizes his utility by revealing his true input regardless of the other players’ declarations.
In this paper, we initiate a study of multidimensional covering mechanismdesign problems, often called reverse auctions or procurement auctions in the mechanismdesign literature. These can be abstractly stated as follows. There are items that need to be covered and agents who provide covering objects, with each agent having a private cost for the covering objects he provides. The goal is to select (or buy) a suitable set of covering objects from each player so that their union covers all the items, and the total covering cost incurred is minimized. This costminimization (CM) problem is equivalent to the socialwelfare maximization (SWM) (where the social welfare is (total cost incurred by the players and the mechanism designer)), so ignoring computational efficiency, the classical VCG mechanism [28, 4, 15] yields a truthful mechanism that always returns an optimal solution. However, the CM problem is often NPhard, so we seek to design a polytime truthful mechanism where the underlying algorithm returns a nearoptimal solution to the CM problem.
Although multidimensional packing mechanismdesign problems have received much attention in the AMD literature, multidimensional covering CM problems are conspicuous by their absence in the literature. For example, the packing SWM problem of combinatorial auctions has been studied (in various flavors) in numerous works both from the viewpoint of designing polytime truthful, approximation mechanisms [10, 21, 9, 13], and from the perspective of proving lower bounds on the capabilities of computationally (or query) efficient truthful mechanisms [20, 14, 11]. In contrast, the lack of study of multidimensional covering CM problems is aptly summarized by the blank table entry for results on truthful approximations for procurement auctions in Fig. 11.2 in [27] (a recent result of [12] is an exception; see “Related work”). In fact, to our knowledge, the only multidimensional problem with a covering flavor that has been studied in the AMD literature is the makespanminimization problem on unrelated machines [26, 22, 2], which is not an SWM problem.
Our results and techniques.
We study two representative multidimensional covering problems, namely (metric) uncapacitated facility location (UFL), and vertex cover (VC), and develop various techniques to devise polytime, truthful, approximation mechanisms for these problems.
For multidimensional UFL (Section 3), wherein players own (known) different facility sets and the assignment costs are public, we present a blackbox reduction from truthful mechanism design to algorithm design. We show that any approximation algorithm for UFL satisfying an additional Lagrangianmultiplierpreserving (LMP) property (that indeed holds for various algorithms) can be converted in a blackbox fashion to a truthfulinexpectation approximation mechanism (Theorem 3.1). This is the first such blackbox reduction for a multidimensional covering problem, and it leads to the first result for multidimensional UFL, namely, a truthfulinexpectation, 2approximation mechanism. Our result builds upon the convexdecomposition technique in [21]. Lavi and Swamy [21] primarily focus on packing problems, but remark that their convexdecomposition idea also yields results for singledimensional covering problems, and leave open the problem of obtaining results for multidimensional covering problems. Our result for UFL identifies an interesting property under which a approximation algorithm for a covering problem can be transformed into a truthful, approximation mechanism in the multidimensional setting.
In Section 4, we consider multidimensional VC, where each player owns a (known) set of nodes. Although, algorithmically, VC is one of the simplest covering problems, it becomes a surprisingly challenging mechanismdesign problem in the multidimensional mechanismdesign setting, and, in fact, seems significantly more difficult than multidimensional UFL. This is in stark contrast with the singledimensional setting, where each player owns a single node. Before detailing our results and techniques, we mention some of the difficulties encountered. We use MultiVC to distinguish the multidimensional mechanismdesign problem from the algorithmic problem.
For singledimensional problems, a simple monotonicity condition characterizes the implementability of an algorithm, that is, whether it can be combined with suitable payments to obtain a truthful mechanism. This condition allows for ample flexibility and various algorithmdesign techniques can be leveraged to design monotone algorithms for both covering and packing problems (see, e.g., [3, 21]). For singledimensional VC, many of the known 2approximation algorithms for the algorithmic problem (based on LProunding, primaldual methods, or combinatorial methods) are either already monotone, or can be modified in simple ways so that they become monotone, and thereby yield truthful 2approximation mechanisms [7]. However, the underlying algorithmdesign techniques fail to yield algorithms satisfying weak monotonicity (WMON)—a necessary condition for implementability (see Theorem 2)—even for the simplest multidimensional setting, namely, 2dimensional VC, where every player owns at most two nodes. We show this for various LProunding methods in Appendix B, and for primaldual algorithms in Appendix C.
Furthermore, various techniques that have been devised for designing polytime truthful mechanisms for multidimensional packing problems (such as combinatorial auctions) do not seem to be helpful for MultiVC. For instance, the wellknown technique of constructing a maximalinrange, or more generally, a maximalindistributionalrange (MIDR) mechanism—fix some subset of outcomes and return the best outcome in this set—does not work for MultiVC [12] (and more generally, for multidimensional covering problems). (More precisely, any algorithm for MultiVC whose range is a proper subset of the collection of minimal vertex covers, cannot have bounded approximation ratio.) This also rules out the convexdecomposition technique of [21], which we exploit for multidimensional UFL, because, as noted in [21], this yields an MIDR mechanism.
Thus, we need to develop new techniques to attack MultiVC (and multidimensional covering problems in general). We devise two main techniques for MultiVC. We introduce a simple class of truthful mechanisms called threshold mechanisms (Section 4.1), and show that despite their restrictions, threshold mechanisms can achieve nontrivial approximation guarantees. We next develop a decomposition method for MultiVC (Section 4.2) that provides a general way of reducing the mechanismdesign problem for MultiVC into simpler—either in terms of graph structure, or problem dimension—mechanismdesign problems by using threshold mechanisms as building blocks. We believe that these techniques will also find use in other mechanismdesign problems.
By leveraging the decomposition method along with threshold mechanisms, we obtain various truthful, approximation mechanisms for MultiVC, which yield the first truthful mechanisms for multidimensional vertex cover with nontrivial approximation guarantees. Let be the number of nodes. Our decomposition method shows that any instance of dimensional VC can be broken up into instances of singledimensional VC; this in turn leads to a truthful, approximation mechanism for dimensional VC (Theorem 4.8). In particular, for any fixed , we obtain an approximation for any graph. We give another decomposition method that yields an improved truthful, approximation mechanism (Theorem 4.10) for any proper minorclosed family of graphs (such as planar graphs). This guarantee improves to for any proper minorclosed family, when no two neighbors of a node belong to the same player.
It is worthwhile to note that in addition to their usefulness in the design of truthful, approximation mechanisms for MultiVC, some of the mechanisms we design also enjoy good frugality properties. We obtain (Theorem 4.13) the first mechanisms for MultiVC that are polytime, truthful and simultaneously achieve bounded approximation ratio and bounded frugality ratio with respect to the benchmarks in [5, 19]. This nicely complements a result of [5], who devise such a mechanism for singledimensional VC.
Related work.
As mentioned earlier, there is little prior work on the CM problem for multidimensional covering problems. Dughmi and Roughgarden [12] give a general technique to convert an FPTAS for an SWM problem to a truthfulinexpectation FPTAS. However, for covering problems, they obtain an additive approximation, which does not translate to a (worstcase) multiplicative approximation. In fact, as they observe, a multiplicative approximation ratio is impossible (in polytime) using their technique, or any other technique that constructs a MIDR mechanism whose range is a proper subset of all outcomes.
For singledimensional covering problems, various other results, including blackbox results, are known. Briest et al. [3] consider a closelyrelated generalization, which one may call the “singlevalue setting”; although this is a multidimensional setting, it admits a simple monotonicity condition sufficient for implementability, which makes this setting easier to deal with than our multidimensional settings. They show that a pseudopolynomial time algorithm (for covering and packing problems) can be converted into a truthful FPTAS. Lavi and Swamy [21] mainly consider packing problems, but mention that their technique also yields results for singledimensional covering problems.
Singledimensional covering problems have been well studied from the perspective of frugality. Here the goal is to design mechanisms that have bounded (over)payment with respect to some benchmark, but one does not (typically) care about the cost of the solution returned. Starting with the work of Archer and Tardos [1], various benchmarks for frugality have been proposed and investigated for various problems including VC, edgedisjoint paths, spanning tree,  cut; see [18, 6, 19, 5] and the references therein. Some of our mechanisms for MultiVC are inspired by the constructions in [19, 5], and simultaneously achieve bounded approximation ratio and bounded frugality ratio.
Our decomposition method, where we combine mechanisms for simpler problems into a mechanism for the given problem, is somewhat in the same spirit as the construction in [25]. They give a toolkit for combining truthful mechanisms, identifying sufficient conditions under which this combination preserves truthfulness. But they work only with the singledimensional setting, which is much more tractable to deal with.
2 Preliminaries
In a multidimensional covering mechanismdesign problem, we have items that need to be covered, and agents/players who provide covering objects. Each agent provides a set of covering objects. All this information is public knowledge. We use to denote the set . Each agent has a private cost (or type) vector , where is the cost he incurs for providing object ; for , we use to denote . A feasible solution or allocation selects a subset for each agent , denoting that provides the objects in . Given this solution, each agent incurs the private cost . Also, the mechanism designer incurs a publiclyknown cost . The goal is to minimize the total cost incurred. We call this the cost minimization (CM) problem. Note that we can encode any feasibility constraints in the covering problem by simply setting if is not a feasible allocation. Observe that if we view the mechanism designer also as a player, then the CM problem is equivalent to maximizing the social welfare, which is given by .
Various covering problems can be cast in the above framework. For example, in the mechanismdesign version of vertex cover (Section 4), the items are edges of a graph. Each agent provides a subset of the nodes of the graph and incurs a private cost if node is used to cover an edge. We can set if is a vertex cover, and otherwise, to encode that the solution must be a vertex cover. It is also easy to see that the mechanismdesign version of uncapacitated facility location (UFL; Section 3), where each agent provides some facilities and has private facilityopening costs, and the clientassignment costs are public, can be modeled by letting be the total clientassignment cost given the set of open facilities.
Let denote the set of all possible cost functions of agent , and be the (finite) set of all possible allocations. Let . For a tuple , we use to denote . Similarly, let . For an allocation , we sometimes use to denote , to denote . A (direct revelation) mechanism for a covering problem consists of an allocation algorithm and a payment function for each agent , and works as follows. Each agent reports a cost function (that might be different from his true cost function). The mechanism computes the allocation , and pays to each agent . Throughout, we use to denote the true cost function of . The utility that player derives when he reports and the others report is , and each agent aims to maximize his own utility (rather than the social welfare).
A desirable property for a mechanism to satisfy is truthfulness, wherein every agent maximizes his utility by reporting his true cost function. All our mechanisms will also satisfy the natural property of individual rationality (IR), which means that every agent has nonnegative utility if he reports his true cost.
Definition 2.1
A mechanism is truthful if for every agent , every , and every , we have . is IR if for every , every and every , we have .
To ensure that truthfulness and IR are compatible, we consider monopolyfree settings: for every player , there is a feasible allocation (i.e., ) with . (Otherwise, if there is no such allocation, then needs to be paid at least for IR, so he can lie and increase his utility arbitrarily.)
For a randomized mechanism , where or the ’s are randomized, we say that is truthful in expectation if each agent maximizes his expected utility by reporting his true cost. We now say that is IR if for every coin toss of the mechanism, the utility of each agent is nonnegative upon bidding truthfully.
Since the CM problem is often NPhard, our goal is to design a mechanism that is truthful (or truthful in expectation), and where is a approximation algorithm; that is, for every input , the solution satisfies . We call such a mechanism a truthful, approximation mechanism.
The following theorem gives a necessary and sometimes sufficient condition for when an algorithm is implementable, that is, admits suitable payment functions such that is a truthful mechanism. Say that satisfies weak monotonicity (WMON) if for all , all , and all , if , , then . Define the dimension of a covering problem to be . It is easy to see that for a singledimensional covering problem—so for all —WMON is equivalent to the following simpler condition: say that is monotone if for all , all , and all , if then .
Theorem 2.2 (Theorems 9.29 and 9.36 in [27])
If a mechanism is truthful, then satisfies WMON. Conversely, if the problem is singledimensional, or if is convex for all , then every WMON algorithm is implementable.
3 A blackbox reduction for multidimensional metric Ufl
In this section, we consider the multidimensional metric uncapacitated facility location (UFL) problem and present a blackbox reduction from truthful mechanism design to algorithm design. We show that any approximation algorithm for UFL satisfying an additional property can be converted in a blackbox fashion to a truthfulinexpectation approximation mechanism (Theorem 3.1). This is the first such result for a multidimensional covering problem. As a corollary, we obtain a truthfulinexpectation, 2approximation mechanism (Corollary 3.3).
In the mechanismdesign version of UFL, we have a set of clients that need to be serviced by facilities, and a set of locations where facilities may be opened. Each agent may provide facilities at the locations in . By making multiple copies of a location if necessary, we may assume that the s are disjoint. Hence, we will simply say “facility ” to refer to the facility at location . For each facility that is opened, incurs a private opening cost of , and assigning client to an open facility incurs a publicly known assignment/connection cost . To simplify notation, given a tuple of facility costs, we use to denote for . The goal is to open a subset of facilities, so as to minimize . We will assume throughout that the s form a metric. It will be notationally convenient to allow our algorithms to have the flexibility of choosing the open facility to which a client is assigned (instead of ); since assignment costs are public, this does not affect truthfulness, and any approximation guarantee achieved also clearly holds when we drop this flexibility.
We can formulate (metric) UFL as an integer program, and relax the integrality constraints to obtain the following LP. Throughout, we use to index facilities in and to index clients in .
(FLP) 
Here, is the vector of reported facility costs. Variable denotes if facility is opened, and denotes if client is assigned to facility ; the constraints encode that each client is assigned to a facility, and that this facility must be open.
Say that an algorithm is a Lagrangian multiplier preserving (LMP) approximation algorithm for UFL if for every instance, it returns a solution such that . The main result of this section is the following blackbox reduction.
Theorem 3.1
Given a polytime, LMP approximation algorithm for UFL, one can construct a polytime, truthfulinexpectation, individually rational, approximation mechanism for multidimensional UFL.
Proof.
We build upon the convexdecomposition idea used in [21]. The randomized mechanism works as follows. Let be the vector of reported facilityopening costs, and be the public connectioncost metric.

With probability : (a) output the solution ; (b) pay to agent , where if , and otherwise.
Clearly, runs in polynomial time. Fix a player . Let and be the true and reported cost vector of . Let be the reported cost vectors of the other players. Let be an optimal solution to (FLP) for . Note that If then this follows since (because then is also an optimal solution to (FLP) when player does not participate). Otherwise, this follows since for all . So where the last equality is again because for all . Since and are respectively the payment to and the assignment computed for input by the fractional VCG mechanism, which is truthful, it follows that player maximizes his utility in the VCG mechanism, and hence, his expected utility under mechanism , by reporting his true opening costs. Thus, is truthful in expectation.
This also implies the approximation guarantee because the convex decomposition obtained in Step 2 shows that the expected cost of the solution computed by for input (where we may assume that is the true cost vector) is at most . Finally, since the fractional VCG mechanism is IR, for any agent , the VCG payment satisfies , and therefore . So is IR. ∎
Lemma 3.2
The convex decomposition in step 2 can be computed in polytime.
Proof.
It suffices to show that the LP (P) can be solved in polynomial time and its optimal value is . Recall that is the set of all integral solutions to (FLP).
(P)  
s.t.  (1)  
(2)  
(3)  
(D) s.t. (4)
Since (P) has an exponential number of variables, we consider the dual (D). Here the s, and are the dual variables corresponding to constraints (1), (2), and (3) respectively. Clearly, since , for all is a feasible dual solution. If there is a feasible dual solution of value smaller than 1, then the rough idea is that by running on the UFL instance with facility costs and connection costs , we can obtain an integral solution whose constraint (4) is violated. (This idea needs be modified a bit since could be negative; see below.) Hence, we can solve (D) efficiently via the ellipsoid method using to provide the separation oracle. This also yields an equivalent dual LP consisting of only the polynomially many violated inequalities found during the ellipsoid method. The dual of this compact LP gives an LP equivalent to (P) with polynomially many variables whose solution yields the desired convex decomposition.
We now fill in the details. Suppose is feasible to (D) and . Define ; for a vector , define . Consider the UFL instance with facility costs and connection costs . (Clearly is also a metric.) Running on this input, we can obtain an integral solution such that
Clearly the facilities with contribute 0 to the LHS and RHS of the above inequality. Now consider the integer solution where is 1 if and is otherwise. Adding to the LHS and to the RHS of the above inequality, since for all and when , we infer that
which contradicts that is feasible to (D). Hence, .
Thus, we can add the constraint to (D) without altering anything. If we solve the resulting LP using the ellipsoid method, and take the inequalities corresponding to the violated inequalities (4) found by during the ellipsoid method, then we obtain a compact LP with only a polynomial number of constraints that is equivalent to (D). The dual of this compact LP yields an LP equivalent to (P) with a polynomial number of variables which we can solve to obtain the desired convex decomposition. ∎
By using the polytime LMP 2approximation algorithm for UFL devised by Jain et al. [17], we obtain the following corollary of Theorem 3.1.
Theorem 3.3
There is a polytime, IR, truthfulinexpectation, 2approximation mechanism for multidimensional UFL.
4 Truthful mechanisms for multidimensional Vc
We now consider the multidimensional vertexcover problem (VC), and devise various polytime, truthful, approximation mechanisms for it. We often use MultiVC to distinguish multidimensional VC from its algorithmic counterpart.
Recall that in MultiVC, we have a graph with nodes. Each agent provides a subset of nodes. For simplicity, we first assume that the s are disjoint, and given a costvector , we use to denote for . Notice that monopolyfree then means that each is an independent set. In Remark 4.6 we argue that many of the results obtained in this disjoints setting (in particular, Theorems 4.8 and 4.10) also hold when the s are not disjoint (but each is still an independent set). The goal is to choose a minimumcost vertex cover, i.e., a mincost set such that every edge is incident to a node in .
As mentioned earlier, VC becomes a rather challenging mechanismdesign problem in the multidimensional mechanismdesign setting. Whereas for singledimensional VC, many of the known 2approximation algorithms for VC are implementable, none of these underlying techniques yield implementable algorithms even for the simplest multidimensional setting, 2dimensional VC, where every player owns at most two nodes; see Appendix B and C for examples. Moreover, no maximalindistributionalrange (MIDR) mechanism whose range is a proper subset of all outcomes can achieve a bounded multiplicative approximation guarantee [12].^{2}^{2}2If is a randomized MIDR algorithm and is an inclusionwise minimal vertex cover such that the range of does not include a distribution that returns with probability 1, then incurs nonzero cost on the instance where the cost of a node is 0 if and is 1 (say) otherwise, and so its approximation ratio is unbounded. This also rules out the convexdecomposition technique of [21], which yields MIDR mechanisms.
We develop two main techniques for MultiVC in this section. In Section 4.1, we introduce a simple class of truthful mechanisms called threshold mechanisms, and show that although seemingly restricted, threshold mechanisms can achieve nontrivial approximation guarantees. In Section 4.2, we develop a decomposition method for MultiVC that uses threshold mechanisms as building blocks and gives a general way of reducing the mechanismdesign problem for MultiVC into simpler mechanismdesign problems.
By leveraging the decomposition method along with threshold mechanisms, we obtain various truthful, approximation mechanisms for MultiVC, which yield the first truthful mechanisms for multidimensional vertex cover with nontrivial approximation guarantees. (1) We show that any instance of dimensional VC can be decomposed into singledimensional VC instances; this leads to a truthful, approximation mechanism for dimensional VC (Theorem 4.8). In particular, for any fixed , we obtain an approximation. (2) For any proper minorclosed family of graphs (such as planar graphs), we obtain an improved truthful, approximation mechanism (Theorem 4.10); this improves to an approximation if no two neighbors of a node belong to the same agent (Corollary 4.11).
Theorem 4.13 shows that our mechanisms also enjoy good frugality properties. We obtain the first mechanisms for MultiVC that are polytime, truthful, and achieve bounded approximation ratio and bounded frugality ratio. This nicely complements a result of [5], who devise such mechanisms for singledimensional VC.
4.1 Threshold Mechanisms
Definition 4.1
A threshold mechanism for MultiVC works as follows. On input , for every and every node , computes a threshold (i.e., does not depend on ’s reported costs). then returns the solution as the output, and pays to agent .
If only depends on the costs in the neighborset of , for all (note that if ), we call a neighborthreshold mechanism. A special case of a neighborthreshold mechanism is an edgethreshold mechanism: for every edge we have edge thresholds , , and the threshold of a node is given by .
In general, threshold mechanisms may not output a vertex cover, however it is easy to argue that threshold mechanisms are always truthful and IR.
Lemma 4.2
Every threshold mechanism for MultiVC is IR and truthful.
Proof.
IR is immediate from the definition of payments. To see truthfulness, fix an agent . For every we have . It follows that ’s utility is maximized by reporting . ∎
Inspired by [19, 5], we define an scaled edgethreshold mechanism as follows: fix a vector , where for all , and set for every edge . We abuse notation and use to denote both the resulting edgethreshold mechanism and its allocation algorithm. Also, define to be the neighborthreshold mechanism where we set . Define .
Lemma 4.3
and output feasible solutions and have a tight approximation ratio .
Proof.
Clearly, every node selected by is also selected by . So it suffices to show that is feasible, and to show the approximation ratio for . For any edge , either and is output, or and is output. So returns a vertex cover.
Let be the output of on input , and let be a mincost vertex cover. We have . Note that is an independent set since is a vertex cover, so . Hence . The tightness of the approximation guarantee follows from Example 1 below. ∎
Corollary 4.4
(i) Setting gives , which is the maximum degree of a node in , so has approximation ratio at most .
(ii) Taking to be the eigenvector corresponding to the largest eigenvalue of the adjacency matrix of ( by the PerronFrobenius theorem) gives (see [5]), so has approximation ratio .
Example 1 (Tightness of approximation ratio of and )
Let and achieve the maximum in the definition of . Now consider the instance where , for all and for all . The mechanism will choose in the output, whereas is a vertex cover of cost . So, has approximation ratio at least .
Although neighborthreshold mechanisms are more general than edgethreshold mechanisms, Lemma 4.5 (proved in Appendix A) shows that this yields limited dividends in the approximation ratio. Define , where . Note that . If is everywhere sparse, i.e., for all , then ; this follows from Hakimi’s theorem [16]. A wellknown result in graph theory states that for every proper family of graphs that is closed under taking minors (e.g., planar graphs), there is a constant , such that every is has at most edges [23] (see also [8], Chapter 7, Exer. 20); since is minorclosed, this also implies that is everywhere sparse, and hence for all .
Lemma 4.5
A (feasible) neighborthreshold mechanism for graph with approximation ratio , yields an approximation edgethreshold mechanism for . This implies an approximation ratio of (i) if is an everywhere sparse graph; (ii) if belongs to a proper minorclosed family of graphs (where the constant in the depends on the graph family).
Remark 4.6
Any neighborthreshold mechanism with approximation ratio that works under the disjoints assumption can be modified to yield a truthful, approximation mechanism when we drop this assumption. Let . Set for each and let be the neighborthreshold of for the input . Note that depends only on for every . Set for all . Consider the threshold mechanism with thresholds, where we use a fixed tiebreaking rule to ensure that we pick for at most one agent with . Then the outputs of on , and of on input coincide. Thus, is a truthful, approximation mechanism.
4.2 A decomposition method
We now propose a general reduction method for MultiVC that uses threshold mechanisms as building blocks to reduce the task of designing truthful mechanisms for MultiVC to the task of designing threshold mechanisms for simpler (in terms of graph structure or the dimensionality of the problem) MultiVC problems. This reduction is useful because designing good threshold mechanisms appears to be a much more tractable task for MultiVC. By utilizing the threshold mechanisms designed in Section 4.1 in our decomposition method, we obtain an approximation mechanism for any proper minorclosed family of graphs, and an approximation mechanism for dimensional VC.
A decomposition mechanism for is constructed as follows.

Let be subgraphs of such that ,

Let be threshold mechanisms for respectively. For any , let be ’s threshold in if , and otherwise.

Define to be the threshold mechanism obtained by setting the threshold for each node to for any . The payments of are then as specified in Definition 4.1. Notice that if all the s are neighbor threshold mechanisms, then so is .
Lemma 4.7
The decomposition mechanism described above is IR and truthful. If are the approximation ratios of respectively, then has approximation ratio .
Proof.
Since is a threshold mechanism, it is IR and truthful by Lemma 4.2. The optimal vertex cover for induces a vertex cover for each subgraph . So outputs a vertex cover of cost at most , where is the optimal vertexcover cost for . It is clear that outputs , which has cost at most . ∎
Theorem 4.8
For any dimensional instance of MultiVC on , one can obtain a polytime, approximation, decomposition mechanism, even when the s are not disjoint.
Proof.
We decompose into singledimensional subgraphs, by which we mean subgraphs that contain at most one node from each . Initialize , . While, , we do the following: for every agent , we pick one of the nodes of uniformly at random and add it to . We also add all the nodes in to . Let be the induced subgraph on ; set .
For any edge , the probability that both appear in some subgraph is at least . So, the expected value of decreases by a factor of at least with . Hence, the expected number of subgraphs produced above is (this also holds with high probability). Each yields a singledimensional VC instance (where a node may be owned by multiple players). Any truthful mechanism for a 1Dproblem is a threshold mechanism. So we can use any truthful, 2approximation mechanism for singledimensional VC for the s and obtain an approximation for dimensional VC. ∎
The following lemma shows that the decomposition obtained above into singledimensional subgraphs is essentially the best that can hope for, for .
Lemma 4.9
There are instances of dimensional VC that require singledimensional subgraphs in any decomposition of .
Proof.
Define to be the bipartite graph with vertices and edges . Each agent owns vertices and .
For the claim is obvious. Let be the minimum number of singledimensional subgraphs needed to decompose . Suppose the claim is true for all and we have decomposed into singledimensional subgraphs . We may assume that (if has less than nodes, pad it with extra nodes). Let and be the subgraphs of induced by and , respectively. The graphs in must contain a decomposition of and a decomposition of . So , and hence, by induction, we obtain that . ∎
Complementing Theorem 4.8, we next present another decomposition mechanism that exploits the graph structure to obtain an improved approximation guarantee. Given a graph and a set , we use to denote the set of edges having both end points in , and to denote the neighbors of . Also, let denote the set of edges of having one end point each in and . When we subscript a quantity (e.g., or ) with a specific graph, we are referring to the quantity in that specific graph.
Theorem 4.10
If is everywhere sparse, then one can devise a polytime, approximation decomposition mechanism for dimensional VC on . Hence, there is a polytime, truthful, approximation mechanism for dimensional VC on any proper minorclosed family of graphs. These guarantees also hold when the s are not disjoint.
Proof.
Set , and let . Since , there are at most nodes in with degree larger than . Let . Let be the subgraph of induced by . Also, consider the bipartite subgraph . Now, (i.e., we delete the nodes in and the edges incident to them to obtain ) is also sparse. So, we can similarly find a subgraph that contains at least half of the nodes of , and the bipartite subgraph of . Continuing this process, we obtain subgraphs that partition , where for every , each node of and each node on one of the sides of has degree (in that subgraph) at most , and . Hence, . Using the (edgethreshold) mechanism defined in Corollary 4.4, for each subgraph gives a approximation for each . Let , where , and .
Let , . Note that a node could lie in . We replace each such node with two distinct “copies” and , and place in and in . If for some player , then we include both in