Truthful Mechanism Design for Multidimensional Covering Problems111A preliminary version appeared as . Theorem 13 in  is incorrect; the correct statements appear as Theorem 4.10 and Corollary 4.11 here.
We investigate multidimensional covering mechanism-design 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 black-box method to transform any Lagrangian-multiplier-preserving -approximation algorithm for UFL to a truthful-in-expectation, -approx. mechanism. This yields the first result for multidimensional UFL, namely a truthful-in-expectation 2-approximation mechanism.
For multidimensional VC (Multi-VC), we develop a decomposition method that reduces the mechanism-design 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 Multi-VC. 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 minor-closed 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 Multi-VC with non-trivial approximation guarantees.
Algorithmic mechanism design (AMD) deals with efficiently-computable 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 (privately-known) 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 mechanism-design problems, often called reverse auctions or procurement auctions in the mechanism-design 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 cost-minimization (CM) problem is equivalent to the social-welfare 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 NP-hard, so we seek to design a polytime truthful mechanism where the underlying algorithm returns a near-optimal solution to the CM problem.
Although multidimensional packing mechanism-design 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  (a recent result of  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 makespan-minimization 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 black-box reduction from truthful mechanism design to algorithm design. We show that any -approximation algorithm for UFL satisfying an additional Lagrangian-multiplier-preserving (LMP) property (that indeed holds for various algorithms) can be converted in a black-box fashion to a truthful-in-expectation -approximation mechanism (Theorem 3.1). This is the first such black-box reduction for a multidimensional covering problem, and it leads to the first result for multidimensional UFL, namely, a truthful-in-expectation, 2-approximation mechanism. Our result builds upon the convex-decomposition technique in . Lavi and Swamy  primarily focus on packing problems, but remark that their convex-decomposition idea also yields results for single-dimensional 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 mechanism-design problem in the multidimensional mechanism-design setting, and, in fact, seems significantly more difficult than multidimensional UFL. This is in stark contrast with the single-dimensional setting, where each player owns a single node. Before detailing our results and techniques, we mention some of the difficulties encountered. We use Multi-VC to distinguish the multidimensional mechanism-design problem from the algorithmic problem.
For single-dimensional 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 algorithm-design techniques can be leveraged to design monotone algorithms for both covering and packing problems (see, e.g., [3, 21]). For single-dimensional VC, many of the known 2-approximation algorithms for the algorithmic problem (based on LP-rounding, primal-dual methods, or combinatorial methods) are either already monotone, or can be modified in simple ways so that they become monotone, and thereby yield truthful 2-approximation mechanisms . However, the underlying algorithm-design techniques fail to yield algorithms satisfying weak monotonicity (WMON)—a necessary condition for implementability (see Theorem 2)—even for the simplest multidimensional setting, namely, 2-dimensional VC, where every player owns at most two nodes. We show this for various LP-rounding methods in Appendix B, and for primal-dual 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 Multi-VC. For instance, the well-known technique of constructing a maximal-in-range, or more generally, a maximal-in-distributional-range (MIDR) mechanism—fix some subset of outcomes and return the best outcome in this set—does not work for Multi-VC  (and more generally, for multidimensional covering problems). (More precisely, any algorithm for Multi-VC whose range is a proper subset of the collection of minimal vertex covers, cannot have bounded approximation ratio.) This also rules out the convex-decomposition technique of , which we exploit for multidimensional UFL, because, as noted in , this yields an MIDR mechanism.
Thus, we need to develop new techniques to attack Multi-VC (and multidimensional covering problems in general). We devise two main techniques for Multi-VC. We introduce a simple class of truthful mechanisms called threshold mechanisms (Section 4.1), and show that despite their restrictions, threshold mechanisms can achieve non-trivial approximation guarantees. We next develop a decomposition method for Multi-VC (Section 4.2) that provides a general way of reducing the mechanism-design problem for Multi-VC into simpler—either in terms of graph structure, or problem dimension—mechanism-design problems by using threshold mechanisms as building blocks. We believe that these techniques will also find use in other mechanism-design problems.
By leveraging the decomposition method along with threshold mechanisms, we obtain various truthful, approximation mechanisms for Multi-VC, which yield the first truthful mechanisms for multidimensional vertex cover with non-trivial 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 single-dimensional 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 minor-closed family of graphs (such as planar graphs). This guarantee improves to for any proper minor-closed 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 Multi-VC, some of the mechanisms we design also enjoy good frugality properties. We obtain (Theorem 4.13) the first mechanisms for Multi-VC 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 , who devise such a mechanism for single-dimensional VC.
As mentioned earlier, there is little prior work on the CM problem for multidimensional covering problems. Dughmi and Roughgarden  give a general technique to convert an FPTAS for an SWM problem to a truthful-in-expectation FPTAS. However, for covering problems, they obtain an additive approximation, which does not translate to a (worst-case) 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 single-dimensional covering problems, various other results, including black-box results, are known. Briest et al.  consider a closely-related generalization, which one may call the “single-value 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  mainly consider packing problems, but mention that their technique also yields results for single-dimensional covering problems.
Single-dimensional 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 , various benchmarks for frugality have been proposed and investigated for various problems including VC, -edge-disjoint paths, spanning tree, - cut; see [18, 6, 19, 5] and the references therein. Some of our mechanisms for Multi-VC 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 . They give a toolkit for combining truthful mechanisms, identifying sufficient conditions under which this combination preserves truthfulness. But they work only with the single-dimensional setting, which is much more tractable to deal with.
In a multidimensional covering mechanism-design 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 publicly-known 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 mechanism-design 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 mechanism-design version of uncapacitated facility location (UFL; Section 3), where each agent provides some facilities and has private facility-opening costs, and the client-assignment costs are public, can be modeled by letting be the total client-assignment 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.
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 monopoly-free 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 NP-hard, 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 single-dimensional 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 )
If a mechanism is truthful, then satisfies WMON. Conversely, if the problem is single-dimensional, or if is convex for all , then every WMON algorithm is implementable.
3 A black-box reduction for multidimensional metric Ufl
In this section, we consider the multidimensional metric uncapacitated facility location (UFL) problem and present a black-box 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 black-box fashion to a truthful-in-expectation -approximation mechanism (Theorem 3.1). This is the first such result for a multidimensional covering problem. As a corollary, we obtain a truthful-in-expectation, 2-approximation mechanism (Corollary 3.3).
In the mechanism-design 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 .
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 black-box reduction.
Given a polytime, LMP -approximation algorithm for UFL, one can construct a polytime, truthful-in-expectation, individually rational, -approximation mechanism for multidimensional UFL.
We build upon the convex-decomposition idea used in . The randomized mechanism works as follows. Let be the vector of reported facility-opening costs, and be the public connection-cost 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 (FL-P) for . Note that If then this follows since (because then is also an optimal solution to (FL-P) 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. ∎
The convex decomposition in step 2 can be computed in polytime.
(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. ∎
There is a polytime, IR, truthful-in-expectation, 2-approximation mechanism for multidimensional UFL.
4 Truthful mechanisms for multidimensional Vc
We now consider the multidimensional vertex-cover problem (VC), and devise various polytime, truthful, approximation mechanisms for it. We often use Multi-VC to distinguish multidimensional VC from its algorithmic counterpart.
Recall that in Multi-VC, 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 cost-vector , we use to denote for . Notice that monopoly-free then means that each is an independent set. In Remark 4.6 we argue that many of the results obtained in this disjoint-s 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 minimum-cost vertex cover, i.e., a min-cost set such that every edge is incident to a node in .
As mentioned earlier, VC becomes a rather challenging mechanism-design problem in the multidimensional mechanism-design setting. Whereas for single-dimensional VC, many of the known 2-approximation algorithms for VC are implementable, none of these underlying techniques yield implementable algorithms even for the simplest multidimensional setting, 2-dimensional VC, where every player owns at most two nodes; see Appendix B and C for examples. Moreover, no maximal-in-distributional-range (MIDR) mechanism whose range is a proper subset of all outcomes can achieve a bounded multiplicative approximation guarantee .222If is a randomized MIDR algorithm and is an inclusion-wise minimal vertex cover such that the range of does not include a distribution that returns with probability 1, then incurs non-zero 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 convex-decomposition technique of , which yields MIDR mechanisms.
We develop two main techniques for Multi-VC 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 non-trivial approximation guarantees. In Section 4.2, we develop a decomposition method for Multi-VC that uses threshold mechanisms as building blocks and gives a general way of reducing the mechanism-design problem for Multi-VC into simpler mechanism-design problems.
By leveraging the decomposition method along with threshold mechanisms, we obtain various truthful, approximation mechanisms for Multi-VC, which yield the first truthful mechanisms for multidimensional vertex cover with non-trivial approximation guarantees. (1) We show that any instance of -dimensional VC can be decomposed into single-dimensional 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 minor-closed 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 Multi-VC that are polytime, truthful, and achieve bounded approximation ratio and bounded frugality ratio. This nicely complements a result of , who devise such mechanisms for single-dimensional VC.
4.1 Threshold Mechanisms
A threshold mechanism for Multi-VC 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 neighbor-set of , for all (note that if ), we call a neighbor-threshold mechanism. A special case of a neighbor-threshold mechanism is an edge-threshold 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.
Every threshold mechanism for Multi-VC is IR and truthful.
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 edge-threshold mechanism as follows: fix a vector , where for all , and set for every edge . We abuse notation and use to denote both the resulting edge-threshold mechanism and its allocation algorithm. Also, define to be the neighbor-threshold mechanism where we set . Define .
and output feasible solutions and have a tight approximation ratio .
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 min-cost 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. ∎
(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 Perron-Frobenius theorem) gives (see ), 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 neighbor-threshold mechanisms are more general than edge-threshold 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 . A well-known 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  (see also , Chapter 7, Exer. 20); since is minor-closed, this also implies that is everywhere -sparse, and hence for all .
A (feasible) neighbor-threshold mechanism for graph with approximation ratio , yields an -approximation edge-threshold mechanism for . This implies an approximation ratio of (i) if is an everywhere -sparse graph; (ii) if belongs to a proper minor-closed family of graphs (where the constant in the depends on the graph family).
Any neighbor-threshold mechanism with approximation ratio that works under the disjoint-s assumption can be modified to yield a truthful, -approximation mechanism when we drop this assumption. Let . Set for each and let be the neighbor-threshold 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 tie-breaking 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 Multi-VC that uses threshold mechanisms as building blocks to reduce the task of designing truthful mechanisms for Multi-VC to the task of designing threshold mechanisms for simpler (in terms of graph structure or the dimensionality of the problem) Multi-VC problems. This reduction is useful because designing good threshold mechanisms appears to be a much more tractable task for Multi-VC. By utilizing the threshold mechanisms designed in Section 4.1 in our decomposition method, we obtain an -approximation mechanism for any proper minor-closed 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 .
The decomposition mechanism described above is IR and truthful. If are the approximation ratios of respectively, then has approximation ratio .
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 vertex-cover cost for . It is clear that outputs , which has cost at most . ∎
For any -dimensional instance of Multi-VC on , one can obtain a polytime, -approximation, decomposition mechanism, even when the s are not disjoint.
We decompose into single-dimensional 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 single-dimensional VC instance (where a node may be owned by multiple players). Any truthful mechanism for a 1D-problem is a threshold mechanism. So we can use any truthful, 2-approximation mechanism for single-dimensional VC for the s and obtain an -approximation for -dimensional VC. ∎
The following lemma shows that the decomposition obtained above into single-dimensional subgraphs is essentially the best that can hope for, for .
There are instances of -dimensional VC that require single-dimensional subgraphs in any decomposition of .
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 single-dimensional subgraphs needed to decompose . Suppose the claim is true for all and we have decomposed into single-dimensional 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.
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 minor-closed family of graphs. These guarantees also hold when the s are not disjoint.
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 (edge-threshold) 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