Matroid-Constrained Vertex Cover
Abstract
In this paper, we introduce the problem of Matroid-Constrained Vertex Cover: given a graph with weights on the edges and a matroid imposed on the vertices, our problem is to choose a subset of vertices that is independent in the matroid, with the objective of maximizing the total weight of covered edges. This problem is a generalization of the much studied max -vertex cover problem, in which the matroid is the simple uniform matroid, and it is also a special case of the problem of maximizing a monotone submodular function under a matroid constraint.
In the first part of this work, we give a Fixed-Parameter Tractable Approximation Scheme (FPT-AS) when the given matroid is a partition matroid, a laminar matroid, or a transversal matroid. Precisely, if is the rank of the matroid, we obtain approximation using time for partition and laminar matroids and using time for transversal matroids. This extends a result of Manurangsi for uniform matroids [34]. We also show that these ideas can be applied in the context of (single-pass) streaming algorithms. Besides, our FPT-AS introduces a new technique based on matroid union, which may be of independent interest in extremal combinatorics.
In the second part, we consider general matroids. We propose a simple local search algorithm that guarantees approximation. For the more general problem where two matroids are imposed on the vertices and a feasible solution must be a common independent set, we show that a local search algorithm gives a approximation in time, for any integer . We also provide some evidence to show that with the constraint of one or two matroids, the approximation ratio of is likely the best possible, using the currently known techniques of local search.
Keywords
Vertex cover, matroid, kernel, local search
Acknowledgements
This work was funded by the grants ANR-19-CE48-0016 and ANR-18-CE40-0025-01 from the French National Research Agency (ANR).
Related version
The first part of the present work has been presented at SWAT 2022 [27].
1 Introduction
The Matroid-Constrained Vertex Cover Problem
Let be a graph. A weight is associated with each edge . By convention, we set and . For a vertex we define the set of edges that are incident to . The degree of a vertex , denoted , is the size of , and we define the weighted degree of a vertex as the sum . For two sets of vertices in a graph , we denote the sum of the weights of the edges that have at least one endpoint in and at least one endpoint in . Then , abbreviated , denotes the sum of the weights of the edges that are covered by (i.e. having at least one of its endpoints in ).
Let be a matroid on the ground set . Recall that is a matroid if the following three conditions hold: (1) , (2) if , then , and (3) if , there exists an element so that . The sets in are the independent sets and the rank of the matroid is defined as . For more details about matroids, we refer the reader to [41]. In this paper, given a set and , we will denote by and by for conciseness.
The problem that we consider in this paper is to choose an independent set of vertices , with the objective of maximizing , namely, the total weight of the edges covered by .
Let us put our problem in a larger picture. When the given matroid is a uniform matroid (see below for a formal definition), our problem reduces to the max -vertex-cover problem, where we want to choose arbitrary vertices so as to maximize the total weight of covered edges. This is a classical problem with a long history: the greedy heuristic is known to give approximation as shown by Hochbaum and Pathria [26]. Ageev and Sviridenko [1] propose an LP-based approach and the technique of pipage rounding to obtain approximation. Using SDP, Feige and Langberg [15] improve this ratio to for some small constant . The current best approximation ratio is , achieved by Manurangsi [34]. For some special cases of the problem, different ratios are also obtained, e.g., see [4, 24, 25]. On the hardness side, to our knowledge, the best inapproximability ratio is due to Austrin and Stankovic [2], which is .
The max -vertex-cover has also been studied through the lens of fixed-parameterized-tractability. Guo et al. [22] show the problem to be -hard with as parameter, thus showing the unlikelihood of getting an exact solution in FPT time. Nonetheless, Marx [36] shows that it is possible to get a near-optimal solution in FPT time. Precisely, he gives an FPT approximation scheme (FPT-AS), that delivers a -approximate solution in time. This running time is later improved by Gupta et al. [23] and Manurangsi [34].
Here we recall the definition of an FPT-AS [36]:
Definition 1.
Given a parameter function associating a natural number to each instance of a given problem, a Fixed-Parameter Tractable Approximation Scheme (FPT-AS) is an algorithm that can provide a approximation in time.
In our case, the instances are made of a graph and a matroid, and the parameter of an instance is the rank of its matroid.
Regarding the more general case of an arbitrary matroid of rank , one can obtain approximation in polynomial time by combining known techniques.111Ageev and Sviridenko [1] show that, for the case of a uniform matroid, the optimal fractional solution of the LP has at least of the optimal value. They then use the pipage rounding to transform it into an integral solution with value no less than . The same LP approach can be generalized for arbitrary matroids. The optimal fractional solution can be obtained by the Ellipsoid algorithm: even though the linear program to describe the independent sets of an arbitrary matroid may use exponentially many constraints, we can design a separation oracle using an algorithm of Cunningham [13]. What remains is just the pipage rounding with a general matroid—this is already known to be do-able by Calinescu et al. [8]. We thank Pasin Manurangsi for communicating to us this method. This is also a special case of maximizing a submodular function (more precisely, a coverage function) under matroid constraint, for which a approximation can be achieved in polynomial time [7, 20]. In this work, we try to do better than this ratio for some special cases of matroids, in the context of fixed-parameter algorithms. We also show that the ideas developed here can be applied in the streaming setting [39]. In streaming, maximizing a submodular function under a general matroid constraint has received much attention recently [9, 11, 16]. Then we also show how local search can be used to obtain simple algorithms for this problem and what are the limitations of local search algorithms.
FPT-AS for Special Cases of Matroids
Let us recall some definitions. A uniform matroid of rank is a matroid where the independent sets are the sets of cardinality at most . A partition matroid is a matroid where we are given a partition of the ground set and bounds such that a set is independent if for all , . A laminar matroid is given as a laminar family of , i.e. given , then either , or , or , along with bounds ; a set is independent if for all , . Finally, a transversal matroid is given in a family , where s are not necessarily disjoint, and a set is independent if and only if for each element , there exists a distinct so that . These simple types of matroid have been extensively studied in a large variety of contexts.
A uniform matroid is a special case of a partition matroid, which is again a special case of a laminar or a transversal matroid. However, laminar matroids and transversal matroids are not inclusive of each other [40]. Transversal matroids were introduced in the 60s, by Edmonds and Fulkerson [14] and by Mirsky and Perfect [38]. They unified many results in transversal theory and are generally considered an important class of matroids, e.g., see [43]. Laminar matroids receive much attention recently in the community of theoretical computer science, especially in the context of matroid secretary problem, e.g., see [3, 10, 17, 28, 42]. Our FPT-AS involves these kinds of matroids.
Theorem 2.
For every , we can extract an approximate kernel in polynomial time so that a -approximate solution is contained in . The size of the kernel depends on the type of the given matroid .
-
(i)
when is a partition matroid;
-
(ii)
when is a laminar matroid;
-
(iii)
when is a transversal matroid.
Furthermore, by a brute force enumeration, we can find the desired approximation in time for partition and laminar matroids and time for transversal matroids.
Note that the result for transversal matroids has since been improved in [29] to get a kernel of size . Besides, by a straightforward modification of our proofs in Section 2 (see Appendix A), we can show the following corollary.
Corollary 3.
Suppose that we are given a hypergraph with edge size bounded by a constant . We can compute a approximation using time for partition and laminar matroids and time for transversal matroids.
Put slightly differently, when is a hypergraph with edge size at most , we can obtain a approximation in or time, depending on the type of matroid. To see the interest of this corollary, we recall that recently Manurangsi [35] showed that if is unbounded, one cannot obtain an approximation ratio better than , assuming GAP-ETH, in FPT time (where the matroid rank is the parameter). This result holds even for the simplest uniform matroid. Thus Corollary 3 implies that one can circumvent this lower bound by introducing another parameter , even for more general matroids.
Our algorithm is inspired by that of Manurangsi [34] for the case of uniform matroid. So let us briefly summarize his approach: an approximate kernel222In the rest of the paper, we will just say kernel, dropping the adjective. Roughly speaking, a -approximate kernel is a kernel which contains a -approximate solution of the original problem. The interest for this kind of kernel has risen recently [18, 33]. is first extracted from , where is simply made of the vertices with the largest weighted degrees. Let be an optimal solution. Apparently, a vertex of is either part of the kernel , or its weighted degree is dominated by all vertices in . To recover the optimal value, we can potentially use the vertices in to replace the vertices in . However, there is a risk in doing this: an edge among the vertices in can be double-counted, if both of its endpoints are chosen to replace the vertices in . To circumvent this issue, Manurangsi uses a random sampling argument to show that in expectation such double counting is negligible. Therefore, by the averaging principle, there exists a -approximate solution in the kernel , which can be found using brute force.
To generalize the approach of Manurangsi for more general matroids, one has to answer the quintessential question: how does one guarantee that the sampled vertices, along with , are independent in ? To overcome this difficulty, we introduce a new technique. We take the union of some number of matroids . Such a union is still a matroid, which we denote as . We then apply a greedy algorithm on (based on non-increasing weighted degrees) to construct an independent set in . We show that such a set is “robust” (see Definition 6) in the sense that we can sample vertices from so that they, along with , are always independent and in expectation cover edges of weight at least times that of .
We note that the value of automatically gives an upper bound on the kernel size , which is . Theorem 8 shows the required scale of , depending on the type of the given matroid. We leave as an open question whether, for matroids more general than considered in the paper, a larger can always yield the kernel.
In Section 4 we consider the problem in the semi-streaming model [39]. In that context, the edges in arrive over time but we have only limited space (for instance, ) and cannot afford to store all edges in . In this context we can also obtain a approximation using space in a single pass.333Here we assume that the matroid is given in the form of an oracle, which can be accessed by the algorithm freely—this is a standard assumption in the streaming setting when matroids are involved. The idea of using (parameterized) kernels for streaming algorithms has recently been introduced, for instance in [12, 37]. We also show that an FPT-streaming algorithm can be derived from our ideas to get a approximation for a special form of maximization of a coverage function with bounded frequency (see Theorem 16, Remark 17 and Appendix B for details).
Local Search for General Matroids
In the second part of the paper, we consider general matroids. As mentioned above, we aim for a ratio better than . Combining known techniques involving LP, approximation can be achieved in polynomial time, as we mentioned earlier. However, the aforementioned LP-based approach involves quite heavy machinery, and is likely to be slow and hard to implement. Here we seek for simple approaches. A natural candidate is the local search technique. However, if we try to optimize according to the original objective function (in the literature, this is called oblivious local search [19]), we show in Appendix C that one cannot achieve better than approximation, even if we allow large exchanges.
What we do is an adaptation of a technique of Filmus and Ward [19], originally designed for a general coverage function. Their idea is to optimize a special potential function, which takes the form of a linear sum of the covered elements, but with the modification that elements covered multiple times have larger coefficients.
Theorem 4.
Given a general matroid as constraint, we can obtain:
-
(i)
A approximation algorithm using arithmetic operations and matroid oracle calls.
-
(ii)
A approximation algorithm using arithmetic operations and matroid oracle calls.
See Section 5.1 for this result. Here we have fast running time thanks to the fact that small exchanges (of 1 element) are enough to establish the desired ratio. In Section 5.2, we show that by a slight modification, we can improve the approximation ratio to in FPT time–precisely, in time. Thus if , we still use only polynomial time.
We next consider the more general case where two matroids are imposed on the graph vertices. A solution is feasible only if it is a common independent set in both matroids.
Theorem 5.
Given two general matroids and as constraints, we can obtain approximation, using arithmetic operations and matroid oracle calls.
This result is presented in Section 5. To see the interest of Theorem 5, observe that it implies that when the submodular function is a coverage function of frequency 2, we can obtain an approximation ratio significantly better than [6, 31], which is known for a general submodular function, under the constraint of two matroids. The only other special case where this ratio is improved upon that we are aware of, is when the submodular function is a weighted rank function [32], where the ratio of exactly is attained.
Some Remarks on Local Search
Considering the closeness of the approximation ratios with regard to one or two matroids, it is tempting to ask if one can do better than if there is just one matroid—maybe by trying larger exchanges.
We show in Section 5.3 that using the same type of potential functions [19] (linear sum with modified coefficients based on the number of times an edge is covered), approximation is the best possible even if we allow larger exchanges.
Besides, another naturally related question is whether one can do better when the graphs are simpler, for instance, when the vertex degree is bounded by some constant . Again we show in Section 5.3 that the same type of potential functions cannot achieve better than approximation, even if large exchanges are allowed.
These examples seem to indicate a certain limitation on the power of currently known local search techniques. Other than the approach of [19, 21], we are unaware of any other type of local search for coverage (or general submodular) functions. To do better than (say up to ), a significantly different new idea may be required.
2 Kernelization Framework
In this section, we give a general framework to construct the kernel by a greedy procedure and show how such a kernel contains a -approximate solution.
Definition 6.
Let be a matroid with weights . We say is -robust if given any base , there is a bijection from the elements to subsets so that
-
(i)
the s are mutually disjoint and ,
-
(ii)
all elements in have weights no less than ,
-
(iii)
by taking an arbitrary element for all , is a base in .
We next recall the definition of matroid union.
Definition 7.
Suppose that is a matroid. Then we can define as the union of matroids , as follows: if can be partitioned into so that each .
Recall that the union of matroids is still a matroid and here the rank of is at most times the rank of , e.g., see [41, Chapter 42]. We can now state our main theorem.
Theorem 8.
Let be a matroid with weights and rank . Consider the following greedy procedure on to construct : initially . Process the elements in by non-increasing weights . For each element , if , add into , otherwise, ignore it. The final is -robust
-
(i)
if is a partition matroid and ,
-
(ii)
if is a laminar matroid and ,
-
(iii)
if is a transversal matroid and .
Notice that the rank of the matroid gives an upper-bound on the size of . The next section will give the proof of this theorem for each type of matroid considered. In the following we show how it can be used to construct the approximation.
Let the weight be the weighted degrees in the graph , that is, . Apply Theorem 8 by setting . Then is -robust. Note that we suppose that is an integer, otherwise we could take .
Based on , we create a new graph , where an original edge is retained in if both of its endpoints are in . In case only one endpoint, say is in , we add a self-loop to in to represent this edge.
Lemma 9.
Suppose that is the constructed set that is -robust. Then contains a set such that and where denotes an optimal solution of the problem.
Proof.
Let be an optimal solution. We denote , . Then by -robustness, we have mutually disjoint sets for each , each of size . We set . We construct a set as follows: is initialized as . Then from each set , for all , pick an element at random and add it into . By definition of -robustness, is independent in .
Next we will show that
Let , i.e. those elements that are added into randomly. First, we have that:
We bound as follows. By construction, for all . Then,
Furthermore, the value can be rearranged as follows:
where the first inequality comes from the fact that .
Recall that by robustness, for all , the elements of have weighted degrees no less than that of . Therefore,
As a result, we get:
By averaging principle, there exists such that and . ∎
3 Proof of Theorem 8
3.1 Partition Matroids
Consider a partition matroid defined by a partition of and bounds . Given , we take in each set of the partition the elements having the largest weighted degrees. We denote these extracted sets as and their union as . Clearly, this is the same as the greedy algorithm stated in Theorem 8 applied on .
To see that is -robust, let be a base. We denote , , , , , and we set as an arbitrary subset of cardinality , for (it is possible as implies that ). We then partition into , , , each one of size . It is easy to verify that the generated sets satisfy the three conditions stated in Definition 6.
3.2 Laminar Matroids
Recall that a laminar matroid is given as a laminar family along with bounds . Without loss of generality, we can assume that with bound (being the rank of ) is a member in the family. Furthermore, we can also assume that each vertex by itself is also a member with bound in this family.
Such a laminar matroid can be naturally associated with a laminar tree where each tree node corresponds to , and the structure of the tree reflects the inclusion relationship of the members in the laminar family. In such a tree corresponds to the root of the tree.
For ease of our study, we will assume that such a tree is binary (so in total contains nodes, with ). Such an assumption can be easily justified by adding more sets into the laminar family with the appropriately defined bounds .
In the following, the elements of will be referred as “nodes”, whereas the elements of will be referred as “vertices”. We are given . To choose the vertices that are to be added into the kernel, we employ the following greedy procedure. We process the vertices in non-increasing order with respect to their weighted degrees. At the beginning, is empty. When we consider a new vertex , if for all such that , we have , then is added to , otherwise is simply ignored. This procedure is equivalent to the greedy algorithm described in Theorem 8 applied on .
A node of the tree is called saturated if . Let be an arbitrary solution. As in the previous subsection we will use the notations , , and . In the following, we say that a vertex or a set of vertices is “contained” in a tree node if they are part of (equivalently, the leaves corresponding to these elements of are in the subtree of root ).
For every element , there exists a leaf in the laminar tree such that , and we have a unique path from the root to . If a vertex is not in , it means that some node along the path from to was already saturated when was processed: the blocking node of is the deepest saturated node along this path (see Figure 2). For each node , we denote by the set of vertices of that are blocked by the node , and we set . Then, when is not saturated. Moreover, the s are mutually disjoint and .
Then for each vertex , we construct a set of at least vertices drawn from . Then an arbitrary subset of vertices is retained. We will argue that the generated sets s ensure the robustness.
Constructing the sets s for all
We want the constructed sets s to satisfy the following three properties.
-
(i)
The sets s are mutually disjoint and are drawn from .
-
(ii)
For each and each , .
-
(iii)
Choosing an arbitrary for each , the set is independent in the laminar matroid .
The formal algorithm for constructing the sets is given in Algorithm 1. Here we give the intuition behind it.
To guarantee Property (i), we first mark all elements in as unusable. Then, each is chosen among the usable vertices. Once a set is allocated, all its vertices will be marked as unusable.
To guarantee Property (ii), first recall that each vertex has a corresponding blocking node (and ). By our greedy procedure to build the kernel , we know that there exist vertices in the set , all of whom are contained in and . What we do is to choose a deepest blocking node and to process one of its vertex (Lines 6-7). As we will show later (Claim 12), such a blocking node must contain at least usable vertices. We climb down the tree from the blocking node until we reach a node neither of whose child nodes contains more than usable vertices (Lines 9-10). Recall that our tree is binary, as a result, the number of usable vertices contained in is between and . All these usable vertices constitute a new set and then are marked as unusable.
How to guarantee Property (iii) is the most tricky part of the algorithm. Recall that we will choose an arbitrary vertex from to construct a solution stated in (iii). Apparently we have no control over the choice of the arbitrary vertex from , nonetheless, we need to ensure that does not violate any of the rank constraints . What we do is to associate a variable with each tree node . This variable indicates how many vertices contained in will certainly be part of , according to and the sets s that have been constructed so far. Once is set to , it is a warning that we should not use any more remaining usable vertices contained in to construct the future sets .
Initially, . Each time that we have decided on a tree node to form a new set (Lines 9-12), we increase the value of from all the way up to the root (Lines 13-14). If any node has its variable , we say such a node is fully-booked and we mark all its (remaining) usable vertices as unusable (Lines 15-16).
We want to show that Algorithm 1 manages to build the sets s of size at least satisfying the aforementioned properties.
Claim 10.
At any time during the execution of Algorithm 1, for a saturated node that is not a descendant of a fully-booked node (no node above it is fully-booked), the number of usable vertices in is at least .
Proof.
As is saturated, contains exactly vertices. The unusable vertices in fall into three categories:
-
(i)
the vertices in (see Line 4), but that are not contained in any fully booked descendent node of ,
-
(ii)
the vertices made unusable during the allocation of a set (see Line 12), but that are not contained in any fully booked descendent node of ,
-
(iii)
the vertices that are contained in a fully-booked descendent node of (see Line 16).
The vertices in the first category each has a contribution of in the value of . Then, we can observe that an allocated set is either entirely contained in a fully-booked node or has no element at all in any fully-booked node. Let us denote the allocated sets contained in that are not contained in any fully-booked node. In addition, by construction, each set contains at most vertices (otherwise we would be able to go deeper in the binary tree for the allocation, see Lines 9-10, because at least one child would contain at least usable elements). Each set has a contribution of in the value of . Finally, among the fully-booked nodes in the subtree of root , we consider the nodes that are inclusion-wise maximal (i.e. the roots of the fully-booked parts of the subtree). A fully-booked subtree of root has to bring a contribution to (otherwise it would not be fully-booked, and observe that a set is included in at most one such fully-booked maximal node), and is making at most vertices of unusable (the worst case being that was also a saturated node). We also have the equality . As a result, we have at most unusable vertices in . ∎
Claim 11.
At any time during the execution of the algorithm, for all , we have as an invariant.
Proof.
As , these inequalities hold at the beginning of Algorithm 1. To see this, note that and . For the induction step, observe that Line 6 guarantees that the node selected is the only one with a non-zero value in the subtree of root . As a result, when the set is allocated, for the nodes between and the allocated node, the augmentation by one of the values is not an issue because these nodes are chosen to be non-fully-booked, i.e. . For each node above , the value is increased by one but as was decreased by one, the total value remains unchanged. ∎
Claim 12.
If , contains at least usable vertices. Consequently, Algorithm 1 (Lines 6-11) always builds the set of size at least .
Proof.
The above claim lower-bounds the size of each . The fact that the constructed s are mutually disjoint follows from the algorithm (Line 12). Now we want to show that the s have the desired properties regarding independence and weighted degrees.
Claim 13.
At any time during the execution of Algorithm 1, if we build a set by taking the elements of and one arbitrary element in each set that has already been constructed, then is independent. Moreover, for a node that does not contain only unusable vertices in , any arbitrary choice of elements in the s will lead to the equality .
Proof.
We proceed by induction. These properties are clearly satisfied at the beginning of the algorithm (because then ). Now suppose that these properties hold at some time, and then we allocate a new set for some . Let be made of and an arbitrary choice for the s that were constructed so far (excluding ). By the induction hypothesis, . The vertices of are supposed to be usable, so the nodes containing them are not fully-booked and these nodes contain usable vertices. By induction on the second part of the claim, a usable element in such a node can be selected, as any choice for the other s will use exactly vertices of the laminar constraint of that node. Therefore any vertex added to does not cause any constraint to be violated, and . Let be the node used for the allocation at Line 11 of Algorithm 1. All the nodes in the subtree of root will be subsequently ignored by the algorithm, as all the nodes inside it are marked as unusable. The values of the nodes in that subtree are not updated by the algorithm, but it is not an issue given that the second part of the claim does not affect them. The nodes above are updated, and it is true that for any vertex chosen in , that vertex will count in the laminar inequalities for these nodes as a . This concludes the induction. ∎
Claim 14.
For all , for all , it holds that .
Proof.
By construction, where is the blocking node of . As is the blocking node of , all the elements in have a larger weighted degree than . ∎
3.3 Transversal Matroids
Recall that a transversal matroid can be represented as a bipartite graph with representing the transversal sets. A subset is independent in if and only if there is a matching where all of are matched to some subset of . Let . The matroid union can be regarded as making the capacity of each vertex in increased to (equivalently, create copies of each and modify the edge set accordingly). Our algorithm is as follows. Again process the vertices in non-increasing order of their weighted degrees. We start with an empty matching, and we maintain a matching throughout the execution of the algorithm. For each new vertex , try to find an augmenting path so that it can be matched. If we cannot find such a path, is discarded. At any time during the execution of the algorithm, the current kernel is simply the set of vertices in that are matched in the current matching. We can observe that a vertex in cannot be evicted once it belongs to . In the following, we write to denote the vertices in that are matched to in the current kernel .
First we argue that our procedure is the same as the greedy described in Theorem 8 applied on . We need to show that a vertex , if discarded, is spanned by vertices in that arrived earlier than it. To see this, observe that, at the moment arrives, is independent in . Moreover, as we cannot find an augmenting path when is added to , is means that is not independent, i.e. is spanned by and this holds until the end of the algorithm.
Now let us consider the robustness. Let be an arbitrary base in . We can assume that is assigned to for all in the corresponding matching. For an element , when it was discarded, some elements (exactly ) that arrived earlier were already assigned to . As no augmenting path could go through when was discarded, the set of elements assigned to would not have changed till the end: otherwise, that would mean that at some point an augmenting path passed through , which is not possible as was discarded because no augmenting path passing through was found at that point. As a result the elements of assigned to are all of weighted degrees larger than that of . As there remain at least elements of that can be used to build a set of cardinality as stated in Definition 6.
4 Streaming Algorithms
In this section, we turn our algorithms into streaming form.
First, we show that it is easy to compute a approximation in two passes, using space ( depends on the type of matroids involved, as defined in Theorem 8). In the first pass, we compute the weighted degrees of all vertices to define the kernel . This requires space. In the second pass, we retain a subset of edges , those both of whose end-points are in . Clearly, . Using , we can compute the exact value for each feasible independent set . Then an enumeration of all such sets gives the desired approximation.
We now explain how to achieve the same goal in one pass, at the expense of higher space requirement.
Theorem 15.
In the edge arrival streaming model (each edge appearing exactly once in the stream), one can extract a -approximate solution of the matroid-constrained maximum vertex cover using variables for uniform, partition, laminar, and transversal matroids.
Proof.
Let . During the streaming phase, we keep track of the weighted degrees of all the vertices, as well as for each vertex the set of the edges incident to that have the largest weight. We denote the set of memorized edges as .
Then, we can choose, depending on the type of matroid, the value corresponding to the right type of matroid (as prescribed in Theorem 8) for the parameter and we build the kernel that is supposed to contain a approximation of the maximum cover. However, we do not know all the edges between the elements in , as only the heaviest incident edges are known for each vertex.
We will compute the value of pretending that the edges in are not present. Precisely, for each set , we define
Notice that . Let be the independent set reaching the maximum . This set will be our final output. We next lower-bound its real value .
Let denote the original optimal solution (with respect to the entire graph), and denote the optimal vertex cover in the kernel (also with respect to the entire graph), so that , , and . Then
To compare the real value of with , we just need to compute the total weight of the edges in :
where the first inequality comes from the fact that the edges that are not among the heaviest edges incident on must be of weight at most . Therefore the real value is at least . ∎
Next we consider a particular kind of stream of edges, where each edge appears twice: given an arbitrary order of the vertices, for each vertex, all its incident edges are given in a row. For this incidence streaming model [5] (sometimes called adjacency list model [37]), the next theorem shows that we can use much less space with just a single pass.
Theorem 16.
In the incidence streaming model, one can extract a -approximate solution using variables for uniform, partition, laminar, and for transversal matroids.
Proof.
Let . Given the type of the matroid , choose the corresponding value of as prescribed in Theorem 8. Start with an empty kernel . Through the execution of the algorithm, will contain the largest independent set in with respect to the sum of the weighted degrees. When we process a vertex (i.e. its set of incident edges) we can compute its weighted degree and store the edges linking to elements of . If is not independent in , consider the element with the smallest weighted degree in the circuit formed in . Then, set . If is added into , we keep in memory all the edges linking to other vertices of . When an element is discarded or evicted from , all its incident edges are deleted. As a result, at any time during the execution of the algorithm, only edges are stored, so the overall memory consumption is .
In the end, we obtain exactly the approximate kernels described in the previous sections, and because we know all the values of the weighted degrees of as well as the weights of the edges between them we can find the largest vertex cover in that kernel using brute force. ∎
Remark 17.
This model has an interesting interpretation in the context of coverage function444A coverage function over a ground set , associated with a universe of weighted elements and sets , where for all , is defined over all so that is the sum of the weight of the elements in . The frequency of an element of the universe is the number of sets it appears in. Here in our problem of maximum vertex cover, the vertices correspond to the ground set and the edges to the universe . Note that for the special case of a vertex cover, the frequency (the maximum number of sets where an element of the universe appears in) is exactly 2, as an edge has only two endpoints. maximization in the streaming setting— here the sets arrive over time in such a way that the values of singletons , for , are revealed one by one. In case where a coverage function has bounded frequency larger than , we also present in Appendix B a streaming algorithm.
5 Local Search Algorithms for General Matroids
5.1 A Polynomial-Time Local Search Approximation Algorithm
In this part we borrow ideas from [19], using a non-oblivious local search technique, meaning that instead of optimizing our objective function we use a potential function to guide the algorithm. Precisely, we define a potential function :
(1) |
where denotes the number of times the edge is covered by vertices of (hence, in practice). The values , , and have to be chosen carefully to optimize the approximation ratio. We suppose that , which is a quite intuitive assumption of decreasing marginal returns. Moreover, this guarantees that the function is submodular (as in [19]). We set and and will decide the value of later.
Let . The algorithm starts by a standard greedy step, which outputs a approximation of the maximum value of for a basis of . Then, we have a local search phase that tries to improve by exchanging an element of with another element if the following inequality holds:
where the factor allows us to bound the number of improvement steps by .
Suppose that the optimal base of our initial problem is , and that our local search algorithm stopped at some solution . Then there exists a bijection such that for all we have and elements of are fixed points of (Corollary 39.12a in [41]). Hence,
and therefore
Now we define a partition of of , where , as follows: the set contains the elements if is covered by vertices in , by vertices in , and by vertices in . By this definition of the partition of , we can re-write the previous inequality as
(2) |
where the values of are:
The only tricky case is when , , and because we do not know whether the two elements and covering satisfy or , giving respectively coefficients of or , and so we choose the smaller one, using the fact that .
By adding to both sides of (2) and re-arranging terms, we have
(3) |
We define the coefficients on the left-hand side as
If, for all we have and when ,
then .
Now we write down all these coefficients:
By setting we get . We have thus a approximation. To get a clean approximation, we can use the partial enumeration technique of Filmus and Ward [19]. For the sake of completeness, we provide the details here.
Algorithm 3 proceeds by guessing the vertex with the largest weighted degree and then applying the previous algorithm on the subgraph , with the contracted matroid as constraint, and the error term . For an element we set as the contracted matroid of by such that . Note that is still a matroid.
Let be the solution returned by the procedure and . Then . Adding to both sides we obtain
The left-hand side can be re-written , where the inequality holds because as is the vertex with the largest weighted degree in , . We have thus established that Algorithm 3 gives a approximation.
In terms of time complexity, Algorithm 3 performs a total of arithmetic operations and oracle queries. To see this, observe that a local improvement step in Algorithm 2 sees each edge at most twice, thus taking arithmetic operations and matroid oracle queries. Moreover, there are at most such steps after the greedy step, which takes arithmetic operations and oracle queries.
Theorem 18.
Algorithm 3 is a local search algorithm providing a approximation, and uses arithmetic operations and matroid oracle queries.
5.2 A FPT Approximation Algorithm
We show how to improve the approximation ratio to , if one is allowed to use FPT time. The key insight here is that if the local optimal is totally disjoint from the optimal , then in the preceding proof, we no longer need to be concerned with the coefficients and their corresponding constraints.
We can slightly modify our algorithm as follows (formally stated in Algorithm 4): each time a local optimum is reached, we guess one of its vertices to be part of the optimal solution and proceed recursively. There can be at most guesses. By setting we can ensure that . Again, using the partial enumeration technique allows us to get a clean approximation.
5.3 Allowing Exchanges of Size Does Not Improve the Ratio
One could think that exchanging elements at the same time instead of only one during an improvement step might allow us to get a better ratio than in Section 5.1. We show in this section that it is not possible, for any choice of .
When , let and consider the example in Figure 3, where the constraint is imposed by a uniform matroid of rank . In fact, the subset of size which optimizes is , as , but the optimal solution for the maximum cover problem is , giving a value . Therefore the solution given by a local search algorithm using cannot have a better approximation guarantee than .
When , we use the example depicted in Figure 4, where the constraint is a uniform matroid of rank . We show that for any , if is large enough, the set is a local optimum of , even if simultaneous exchanges at the same time are allowed. As the solution has value while the optimal solution has value , the approximation guarantee of such an algorithm cannot be better than .
We can observe that the most interesting exchanges have to be of the form . If we perform such exchanges, for instance then the gain for the value of is:
for such that | |||
for such that | |||
for such that | |||
as , when is big enough the gain becomes negative. Therefore, with a large , is a local optimum even if exchanges are allowed.
What if the degrees are bounded?
Our previous example uses vertices of large degrees, so one is naturally led to ask what happens if the vertex degree is bounded. Could one obtain approximation ratios significantly better than in this case? In the following, we can assume that (otherwise the first example in Figure 3 shows the approximation ratio cannot be better than ).
Let be the desired bound for the degrees in our graph. We proceed somehow similarly to Lee et al. [31]. Using the result of [30], we know there exists a bipartite, -regular graph of girth at least (i.e. the smallest circuit in the graph is of length at least ).555In [30] the construction is specific for a prime power , but we can use their construction to obtain our -regular bipartite graph for some easily: by removing iteratively a perfect matching from the graph. Such a perfect matching exists because of Hall’s marriage theorem, e.g., [41]. Let and be the bi-partition of the graph, so that . As it is a bipartite regular graph, there exists a perfect matching in that graph. We denote such a matching. We build a graph as follows: we take the vertices and the edges of , we add a set of vertices , then we add edges for and we delete the edges of the matching for . Clearly in the degree bound is still . We define the weights for and (we will set the value of later).
We define a partition matroid with the partition and a bound of one element per set .
We want to show that is a local optimum, whereas the real optimum is . In fact, and . The only relevant exchanges are of the form , as taking is clearly less interesting. Consider the indexes of the exchanges tried during a local search step.
edges in | |||
for , for | |||
edges in | |||
As and |
where denote the number of “saved” edges. Precisely, these are the edges between and in the graph . We call them “saved” because they are still covered after the exchange, unlike other edges incident to the s. We now claim that . Recall that as the original graph has girth at least , there cannot be a cycle among the vertices in . So the subgraph of induced by these vertices forms a forest, with at most edges. Recall that when constructing , we have removed the edges for all . Therefore edges in the subgraph are gone. We conclude that at most edges of that forest can be the saved edges.
Setting , the gain becomes non-positive, and , so
This implies that the approximation ratio is bounded by , as .
6 Local Search Algorithm for Two Matroids
In this section, we assume that two matroids and are imposed on the vertex set .
The idea of the exchange graph [41, Section 41.2], is defined as follows. Given , an oriented (bipartite) digraph has the following two types of edges:
-
•
for and there is an arc if
-
•
for and there is an arc if
In this exchange graph, a dipath/dicycle (whose vertices are denoted ) is called feasible if is in and if for any sub-dipath of such that the endpoints of are in (or are the endpoints of ) then is also in .
The following exchange lemma from [31] will be extremely useful for our purpose.
Lemma 19 (Lemma 2.5 in [31]).
Let . Then there exists an integer and a collection of dipaths/dicycles (possibly with repetitions), feasible in the digraph , using only elements of , so that each element of appears in exactly dipaths/dicycles .
Suppose that we have a solution . Let be the global optimum. By Lemma 19 with and , there exists and a collection of dipaths/dicycles such that each element of appears exactly times in these dipaths/dicycles. We could potentially perform local search exchanges corresponding to these dipaths and dicycles to improve our solution . However, such paths and cycles can be arbitrarily long, thus implying a prohibitively high running time. To overcome this issue, we will use an idea of Lee et al. [31, Lemma 3.1], in which these long paths and cycles are cut into pieces of length for some constant . Such pieces will then allow us to perform local search in polynomial time.
Precisely, for each dipath/dicycle , we number the vertices of along the path consecutively. For each , we create copies and in the copy we throw away vertices that are labeled modulo . By cutting these dipaths/dicycles, now the corresponding exchanges contain only up to vertices from and at most vertices from . Notice that these shortened paths remain feasible, i.e., .
Algorithm 5, a local search algorithm allowing exchanges size up to , exploits exactly the above idea. Here the potential function is defined by (1) as in Section 5.1. Again , , and we decide the value of later.
Consider the family and all the exchanges they contain, which are denoted . Each element of appears in exactly exchanges and each element of in exchanges. As is a local optimum, all these exchanges satisfy the inequality of Algorithm 5:
and summing over all these inequalities:
Using the sets as defined in Section 5, we have the inequality analogous to inequality (2):
where the are equal to:
There are only two nontrivial cases: when , the worst situation is when, for a given edge , all the exchanges involve both of its two endpoints. To see this, recall that the two endpoints appear in total of times in the family , so if exchanges involve both endpoints, the coefficient for this edge is , which is minimized when . For the other case , the worst situation for an edge is similarly when all the exchanges involve both of its endpoints.
Similar to the previous section, we can derive an inequality analogous to (3):
Similar to the previous section, we define
If for all we have , and if we have , then . We write down all these coefficients and their corresponding constraints:
setting we get , and therefore
If we denote the minimum rank among the two matroids, then we know that , therefore we get:
Using the same partial enumeration technique as in Section 5, one can get, for a fixed , a polynomial-time algorithm providing a approximation.
Theorem 20.
Algorithm 5 is a local search algorithm providing a approximation using arithmetic operations and matroid oracle calls.
7 Conclusion and Open Questions
Theorem 8 allows us to generalize the cardinality constraint to some special cases of matroid constraints, and these ideas could be useful for other kernelization algorithms. Regarding the bounds of Theorem 8, tight examples can be built to show that the values of provided are the best possible for partition and laminar matroids. For transversal matroids it is less clear whether the bound for can be improved or not. The most important open question regarding this result is whether Theorem 8 can be generalized to other types of matroids.
Regarding local search, we have shown some limitations of the current techniques, which cannot exceed a approximation. Thus to close the gap between local search and LP techniques one would have to use new techniques, for instance by introducing a new type of objective function for this problem.
References
- [1] Alexander A. Ageev and Maxim Sviridenko. Approximation algorithms for maximum coverage and max cut with given sizes of parts. In Gérard Cornuéjols, Rainer E. Burkard, and Gerhard J. Woeginger, editors, Integer Programming and Combinatorial Optimization, 7th International IPCO Conference, Graz, Austria, June 9-11, 1999, Proceedings, volume 1610 of Lecture Notes in Computer Science, pages 17–30. Springer, 1999.
- [2] Per Austrin and Aleksa Stankovic. Global cardinality constraints make approximating some max-2-CSPs harder. In Dimitris Achlioptas and László A. Végh, editors, Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, APPROX/RANDOM 2019, September 20-22, 2019, Massachusetts Institute of Technology, Cambridge, MA, USA, volume 145 of LIPIcs, pages 24:1–24:17. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019.
- [3] Moshe Babaioff, Nicole Immorlica, and Robert Kleinberg. Matroids, secretary problems, and online mechanisms. In Nikhil Bansal, Kirk Pruhs, and Clifford Stein, editors, Proceedings of the Eighteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2007, New Orleans, Louisiana, USA, January 7-9, 2007, pages 434–443. SIAM, 2007.
- [4] Édouard Bonnet, Bruno Escoffier, Vangelis Th. Paschos, and Georgios Stamoulis. Purely combinatorial approximation algorithms for maximum k-vertex cover in bipartite graphs. Discret. Optim., 27:26–56, 2018.
- [5] Vladimir Braverman, Zaoxing Liu, Tejasvam Singh, N. V. Vinodchandran, and Lin F. Yang. New bounds for the CLIQUE-GAP problem using graph decomposition theory. Algorithmica, 80(2):652–667, 2018.
- [6] Niv Buchbinder, Moran Feldman, Joseph Naor, and Roy Schwartz. A tight linear time (1/2)-approximation for unconstrained submodular maximization. In 53rd Annual IEEE Symposium on Foundations of Computer Science, FOCS 2012, New Brunswick, NJ, USA, October 20-23, 2012, pages 649–658. IEEE Computer Society, 2012.
- [7] Gruia Călinescu, Chandra Chekuri, Martin Pál, and Jan Vondrák. Maximizing a submodular set function subject to a matroid constraint (extended abstract). In Matteo Fischetti and David P. Williamson, editors, Integer Programming and Combinatorial Optimization, 12th International IPCO Conference, Ithaca, NY, USA, June 25-27, 2007, Proceedings, volume 4513 of Lecture Notes in Computer Science, pages 182–196. Springer, 2007.
- [8] Gruia Călinescu, Chandra Chekuri, Martin Pál, and Jan Vondrák. Maximizing a monotone submodular function subject to a matroid constraint. SIAM J. Comput., 40(6):1740–1766, 2011.
- [9] Amit Chakrabarti and Sagar Kale. Submodular maximization meets streaming: Matchings, matroids, and more. In Jon Lee and Jens Vygen, editors, Integer Programming and Combinatorial Optimization - 17th International Conference, IPCO 2014, Bonn, Germany, June 23-25, 2014. Proceedings, volume 8494 of Lecture Notes in Computer Science, pages 210–221. Springer, 2014.
- [10] Sourav Chakraborty and Oded Lachish. Improved competitive ratio for the matroid secretary problem. In Yuval Rabani, editor, Proceedings of the Twenty-Third Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2012, Kyoto, Japan, January 17-19, 2012, pages 1702–1712. SIAM, 2012.
- [11] Chandra Chekuri, Shalmoli Gupta, and Kent Quanrud. Streaming algorithms for submodular function maximization. In Magnús M. Halldórsson, Kazuo Iwama, Naoki Kobayashi, and Bettina Speckmann, editors, Automata, Languages, and Programming - 42nd International Colloquium, ICALP 2015, Kyoto, Japan, July 6-10, 2015, Proceedings, Part I, volume 9134 of Lecture Notes in Computer Science, pages 318–330. Springer, 2015.
- [12] Rajesh Chitnis, Graham Cormode, Hossein Esfandiari, MohammadTaghi Hajiaghayi, Andrew McGregor, Morteza Monemizadeh, and Sofya Vorotnikova. Kernelization via sampling with applications to finding matchings and related problems in dynamic graph streams. In Robert Krauthgamer, editor, Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, Arlington, VA, USA, January 10-12, 2016, pages 1326–1344. SIAM, 2016.
- [13] William H. Cunningham. Testing membership in matroid polyhedra. J. Comb. Theory, Ser. B, 36(2):161–188, 1984.
- [14] Jack Edmonds and D.R. Fulkerson. Transversals and matroid partition. Journal of Research National Bureau of Standards Section B, 69:147–153, 1965.
- [15] Uriel Feige and Michael Langberg. Approximation algorithms for maximization problems arising in graph partitioning. J. Algorithms, 41(2):174–211, 2001.
- [16] Moran Feldman, Paul Liu, Ashkan Norouzi-Fard, Ola Svensson, and Rico Zenklusen. Streaming submodular maximization under matroid constraints. In Mikolaj Bojanczyk, Emanuela Merelli, and David P. Woodruff, editors, 49th International Colloquium on Automata, Languages, and Programming, ICALP 2022, July 4-8, 2022, Paris, France, volume 229 of LIPIcs, pages 59:1–59:20. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2022.
- [17] Moran Feldman, Ola Svensson, and Rico Zenklusen. A simple O(log log(rank))-competitive algorithm for the matroid secretary problem. In Piotr Indyk, editor, Proceedings of the Twenty-Sixth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2015, San Diego, CA, USA, January 4-6, 2015, pages 1189–1201. SIAM, 2015.
- [18] Andreas Emil Feldmann, Karthik C. S., Euiwoong Lee, and Pasin Manurangsi. A survey on approximation in parameterized complexity: Hardness and algorithms. Algorithms, 13(6):146, 2020.
- [19] Yuval Filmus and Justin Ward. The power of local search: Maximum coverage over a matroid. In Christoph Dürr and Thomas Wilke, editors, 29th International Symposium on Theoretical Aspects of Computer Science, STACS 2012, February 29th - March 3rd, 2012, Paris, France, volume 14 of LIPIcs, pages 601–612. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2012.
- [20] Yuval Filmus and Justin Ward. A tight combinatorial algorithm for submodular maximization subject to a matroid constraint. In 53rd Annual IEEE Symposium on Foundations of Computer Science, FOCS 2012, New Brunswick, NJ, USA, October 20-23, 2012, pages 659–668. IEEE Computer Society, 2012.
- [21] Yuval Filmus and Justin Ward. Monotone submodular maximization over a matroid via non-oblivious local search. SIAM J. Comput., 43(2):514–542, 2014.
- [22] Jiong Guo, Rolf Niedermeier, and Sebastian Wernicke. Parameterized complexity of generalized vertex cover problems. In Frank K. H. A. Dehne, Alejandro López-Ortiz, and Jörg-Rüdiger Sack, editors, Algorithms and Data Structures, 9th International Workshop, WADS 2005, Waterloo, Canada, August 15-17, 2005, Proceedings, volume 3608 of Lecture Notes in Computer Science, pages 36–48. Springer, 2005.
- [23] Anupam Gupta, Euiwoong Lee, and Jason Li. Faster exact and approximate algorithms for k-cut. In Mikkel Thorup, editor, 59th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2018, Paris, France, October 7-9, 2018, pages 113–123. IEEE Computer Society, 2018.
- [24] Qiaoming Han, Yinyu Ye, Hantao Zhang, and Jiawei Zhang. On approximation of max-vertex-cover. Eur. J. Oper. Res., 143(2):342–355, 2002.
- [25] Qiaoming Han, Yinyu Ye, and Jiawei Zhang. An improved rounding method and semidefinite programming relaxation for graph partition. Math. Program., 92(3):509–535, 2002.
- [26] Dorit S Hochbaum and Anu Pathria. Analysis of the greedy approach in covering problems. Naval Research Quarterly, 45:615–627, 1998.
- [27] Chien-Chung Huang and François Sellier. Matroid-constrained maximum vertex cover: Approximate kernels and streaming algorithms. In Artur Czumaj and Qin Xin, editors, 18th Scandinavian Symposium and Workshops on Algorithm Theory, SWAT 2022, June 27-29, 2022, Tórshavn, Faroe Islands, volume 227 of LIPIcs, pages 27:1–27:15. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2022.
- [28] Sungjin Im and Yajun Wang. Secretary problems: Laminar matroid and interval scheduling. In Dana Randall, editor, Proceedings of the Twenty-Second Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2011, San Francisco, California, USA, January 23-25, 2011, pages 1265–1274. SIAM, 2011.
- [29] Naoyuki Kamiyama. A note on robust subsets of transversal matroids. CoRR, abs/2210.09534, 2022.
- [30] Felix Lazebnik, Vasiliy A Ustimenko, and Andrew J Woldar. A new series of dense graphs of high girth. Bulletin of the American mathematical society, 32(1):73–79, 1995.
- [31] Jon Lee, Maxim Sviridenko, and Jan Vondrák. Submodular maximization over multiple matroids via generalized exchange properties. Mathematics of Operations Res., 35(4):795–806, 2010.
- [32] André Linhares, Neil Olver, Chaitanya Swamy, and Rico Zenklusen. Approximate multi-matroid intersection via iterative refinement. In Andrea Lodi and Viswanath Nagarajan, editors, Integer Programming and Combinatorial Optimization - 20th International Conference, IPCO 2019, Ann Arbor, MI, USA, May 22-24, 2019, Proceedings, volume 11480 of Lecture Notes in Computer Science, pages 299–312. Springer, 2019.
- [33] Daniel Lokshtanov, Fahad Panolan, M. S. Ramanujan, and Saket Saurabh. Lossy kernelization. In Hamed Hatami, Pierre McKenzie, and Valerie King, editors, Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, Montreal, QC, Canada, June 19-23, 2017, pages 224–237. ACM, 2017.
- [34] Pasin Manurangsi. A note on max k-vertex cover: Faster fpt-as, smaller approximate kernel and improved approximation. In Jeremy T. Fineman and Michael Mitzenmacher, editors, 2nd Symposium on Simplicity in Algorithms, SOSA 2019, January 8-9, 2019, San Diego, CA, USA, volume 69 of OASIcs, pages 15:1–15:21. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019.
- [35] Pasin Manurangsi. Tight running time lower bounds for strong inapproximability of maximum k-coverage, unique set cover and related problems (via t-wise agreement testing theorem). In Shuchi Chawla, editor, Proceedings of the 2020 ACM-SIAM Symposium on Discrete Algorithms, SODA 2020, Salt Lake City, UT, USA, January 5-8, 2020, pages 62–81. SIAM, 2020.
- [36] Dániel Marx. Parameterized complexity and approximation algorithms. Comput. J., 51(1):60–78, 2008.
- [37] Andrew McGregor, David Tench, and Hoa T. Vu. Maximum coverage in the data stream model: Parameterized and generalized. In Ke Yi and Zhewei Wei, editors, 24th International Conference on Database Theory, ICDT 2021, March 23-26, 2021, Nicosia, Cyprus, volume 186 of LIPIcs, pages 12:1–12:20. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2021.
- [38] L. Mirsky and H. Perfect. Applications of the notion of independence to problems of combinatorial analysis. Journal of Combinatorial Theory, 2:327–357, 1965.
- [39] S. Muthukrishnan. Data streams: Algorithms and applications. Found. Trends Theor. Comput. Sci., 1(2), 2005.
- [40] András Recski. Matroid Theory and its Applications in Electric Network Theory and in Statics. Springer-Verlag, 1989.
- [41] Alexander Schrijver. Combinatorial optimization: polyhedra and efficiency. Springer, 2003.
- [42] José A Soto. A simple ptas for weighted matroid matching on strongly base orderable matroids. Electronic Notes in Discrete Mathematics, 37(0):75–80, 2011.
- [43] D.J.A Welsh. Transversal theory and matroids. Canadian Journal of Mathematics, 21:1323–1302, 1969.
Appendix A An FPT-AS for Hypergraphs
Suppose that we are given a hypergraph with edge size bounded by a constant . We proceed as in Section 2. First, notice that:
We bound as follows. By construction, for all . Then,
using union bound and the fact that at most endpoints can be in . Furthermore, the value can be rearranged as follows:
Recall that by robustness, for all , the elements of have weighted degree no less than the one of . Therefore,
As a result, we get:
By averaging principle, there exists a set such that and such that .
Appendix B Streaming FPT-AS Algorithm for Hypergraphs
Here we suppose that we are given a hypergraph with edge size bounded by a constant as an adjacency list stream. Using the idea of Theorem 16 and the result of Appendix A, one can get in the incidence streaming model a approximation using memory, where depends on the type of matroid, as prescribed in Theorem 8. In fact, we can maintain through the execution of the algorithm for each subset of at most elements the sum of the weight of the hyper-edges such that (just like in the proof of Theorem 16 where we keep track of these values for pairs in ). For instance, for a uniform, a partition, or a laminar matroid, we could get a approximation using variables. This shows that for the special matroids that we studied of rank , a weighted coverage function with bounded frequency can be approximated in streaming. This extends a result of [37] to matroids.
Appendix C Local Search with the Objective Function
Let . When the cover function is used for the local search, we use the example depicted in Figure 5, where the constraint is a uniform matroid of rank . This example is very similar to the one in Section 5.3. We show that for any , if is large enough, the set is a local optimum of , even if simultaneous exchanges at the same time are allowed. As the solution has value while the optimal solution has value , the approximation guarantee of such an algorithm cannot be better than .
We can observe that the most interesting exchanges have to be of the form . If we perform such exchanges, for instance then the gain for the value of is:
for such that | |||
for such that | |||
as , when is big enough the gain becomes negative. Therefore, when is big enough, is a local optimum even if exchanges are allowed.