Hitting Sets when the Shallow Cell Complexity is Small
Sander Aarts, David B. Shmoys

TL;DR
This paper presents a simpler algorithm for the hitting set problem in geometric set systems with small shallow cell complexity, achieving improved approximation ratios by combining linear programming relaxation with probabilistic sampling.
Contribution
It introduces a straightforward algorithm that generalizes the net-finder approach, utilizing weighted epsilon-nets and a generalized packing lemma for better approximation.
Findings
Achieves improved asymptotic approximation ratios.
Simplifies the algorithmic approach compared to existing methods.
Extends packing lemmas to weighted epsilon-nets.
Abstract
The hitting set problem is a well-known NP-hard optimization problem in which, given a set of elements and a collection of subsets, the goal is to find the smallest selection of elements, such that each subset contains at least one element in the selection. Many geometric set systems enjoy improved approximation ratios, which have recently been shown to be tight with respect to the shallow cell complexity of the set system. The algorithms that exploit the cell complexity, however, tend to be involved and computationally intensive. This paper shows that a slightly improved asymptotic approximation ratio for the hitting set problem can be attained using a much simpler algorithm: solve the linear programming relaxation, take one initial random sample from the set of elements with probabilities proportional to the LP-solution, and, while there is an unhit set, take an additional sample from…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsOptimization and Packing Problems · Optimization and Search Problems · Computational Geometry and Mesh Generation
11institutetext: Cornell University, Ithaca NY 14580, USA
11email: [email protected], [email protected]
Hitting Sets when the Shallow Cell Complexity is Small
††thanks: This material is based on work supported by the NSF under Grant CNS-1952063.
Sander Aarts 11 0000-0003-1852-9116
David B. Shmoys 11 0000-0003-3882-901X
Abstract
The hitting set problem is a well-known NP-hard optimization problem in which, given a set of elements and a collection of subsets, the goal is to find the smallest selection of elements, such that each subset contains at least one element in the selection. Many geometric set systems enjoy improved approximation ratios, which have recently been shown to be tight with respect to the shallow cell complexity of the set system. The algorithms that exploit the cell complexity, however, tend to be involved and computationally intensive. This paper shows that a slightly improved asymptotic approximation ratio for the hitting set problem can be attained using a much simpler algorithm: solve the linear programming relaxation, take one initial random sample from the set of elements with probabilities proportional to the LP-solution, and, while there is an unhit set, take an additional sample from it proportional to the LP-solution. Our algorithm is a simple generalization of the elegant net-finder algorithm by Nabil Mustafa. To analyze this algorithm for the hitting set problem, we generalize the classic Packing Lemma, and the more recent Shallow Packing Lemma, to the setting of weighted epsilon-nets.
Keywords:
Hitting set Set cover Approximation algorithms Computational geometry Shallow cell complexity Wireless coverage
1 Introduction
The input to the hitting set problem is a finite set system – a ground set of elements, or points, and a collection of subsets, or ranges, of . This can also be understood as a hypergraph, with vertices and hyper-edges . A hitting set is a subset of elements such that every set is hit by , i.e. , for all . This is a vertex cover under the hypergraph view. The set system can be encoded as a set-element incidence matrix , in which the th entry is if range contains point , and [math] otherwise. The IP of the minimum hitting set problem is
[TABLE]
where variable indicates whether element is in the solution .
Hitting sets and set covers are intimately connected; a hitting set for is a set cover of . Both problems’ decision versions are NP-complete [10]. There exists an -approximation algorithm, and this bound is tight unless P = NP [9, 13]. However, there are algorithms that exploit additional structure in to attain improved approximation ratios111For example when has bounded row or column sums [2, 6].. Indeed, our work is motivated by the problem of exploiting structure when covering large numbers of wireless LoRaWAN transmitters with wireless receivers. Transmitters can be viewed as points, which are considered to be covered if they are in the line of sight of a wireless receiver, which in turn drives transmission quality in LoRaWAN [22]. The area in the line of sight of a receiver roughly resembles a simple shape.
Many geometric set systems enjoy better approximation ratios via epsilon-nets, or -nets. A set system is said to be geometric whenever its elements can be encoded as points in Euclidean space, and sets are derived from containment of the points in geometric shapes, such as half-spaces, balls or rectangles222Some definition allow for uncountably many geometric shapes in , e.g. all squares. However, because the number of points is finite, there are nevertheless a finite number of unique sets induced by these shapes.. The seminal work of Brönnimann and Goodrich [3], and Even et al. [8], connects the approximability of a hitting set instance to the size of weighted -nets. Given non-negative weights on the points, , a weighted -net with respect to weights is a subset that hits all -heavy sets:
[TABLE]
where the weight of any subset is defined as . Even et al. [8] reduce the problem of finding a small hitting set to finding a small -net via a reformulation of the linear programming relaxation of the hitting set problem (1). The reformulated LP (1) is a program for finding the largest , and corresponding weights , subject to the constraint that an -net with respect to weights is a hitting set.
[TABLE]
The first constraint requires that each set is -heavy; the second constraint normalizes the weights. Let denote an optimal solution to LP (1), with . Let be the optimal value to the LP relaxation of the original program (1). The first constraint ensures that an -net with respect to weights is a hitting set. Moreover, the reciprocal optimal value is equal to the optimal LP value [8]. In particular, an -net of size for some function is a hitting set of size of . Hence, to find a small hitting set it suffices to solve LP (1) and find a small -net with respect to weights .
Haussler and Welzl [12] show that set systems with bounded VC-dimension admit small -nets, and develop a simple algorithm to find them. The VC-dimension is a measure of the set system’s complexity. Given a subset , the projection of to is the set system formed by elements and sets . The VC-dimension of is the size of the largest subset such that shatters , i.e. the largest set such that contains all subsets of . In particular, Clarkson [7], and Haussler and Welzl [12], show that any set system with VC-dimension has a weighted -net of size . This is remarkable, as the size is independent of both the size of and . Moreover, the algorithm for finding such an -net is simple: Select a subset by sampling each element in independently.
Theorem 1.1 (-net Theorem [12, 14])
Let be a set system with VC-dimension , and let be element weights with . Then for any :
[TABLE]
is a weighted -net with respect to weights with probability at least .
Throughout, we define for all subsets . For general set systems of VC-dimension , this bound is tight in expectation [14]. However, there are alternative ways to parameterize the complexity of set systems.
1.1 Shallow Cell Complexity
The shallow cell complexity (SCC) is a finer parameterization of the complexity of set systems. [1, 4, 21]. Readers are referred to Mustafa and Varadarajan [20] for more background. A cell in a binary matrix is a collection of identical rows. A cell has depth if the number of ’s in any of its rows is exactly , i.e., if each set in the cell contains elements. For a non-decreasing function we say binary matrix has shallow cell complexity (SCC) if, for all , the number of cells of depth at most in any submatrix of of at most columns, is at most . A set system is said to have SCC if its set-element incidence matrix does. Often for some constant and single-variable function , in which case the dependence on is can be dropped and the SCC denoted by . Examples of geometric set systems with small shallow cell complexity are discs in the plane with , and axis-parallel rectangles with [18].
As is true for VC-dimension, there are algorithms that find hitting sets or -nets with sizes bounded in terms of the shallow cell complexity. A prominent example is the quasi-uniform sampling algorithm of Chan et al. [4]. Given non-negative weights , and a value , the algorithm finds a hitting set while maintaining an upper bound on the probability of selecting any given element.
Theorem 1.2 (Quasi-uniform sampling [4])
Suppose a set system defined by has SCC for some . Then there is a randomized poly-time algorithm that returns a hitting set of expected size times the LP optimum.
The algorithm attains the optimal approximation ratio with respect to the SCC333In addition, it is worth noting that this algorithm can solve the more general weighted hitting set problem, in which each element has a given weight, and the goal is to find the minimum weight hitting set.. However, the sampling procedure is involved, and may require enumeration over all sets , of which there can be for some constant [17].
Taking a different approach, Mustafa and colleagues [16, 17, 19] develop a net-finder for asymptotically optimal-sized unweighted -nets with respect to the SCC. The algorithm is remarkably simple: Take an initial sample from , and while there are unhit sets, choose an unhit set arbitrarily, and add randomly chosen elements from this set to the original sample. The algorithm assumes access to an oracle that returns an unhit set. This oracle is called at most times in expectation. While the size of the returned -net is asymptotically on par with the quasi-uniform sampling algorithm, there are large constants in the upper bound [17].
This algorithm is not directly applicable to the hitting set problem via the LP-reduction above, although it can be used via a standard reduction. The analysis of the algorithm applies to only uniform weights, and the optimal weights of the LP-formulation (1) are not generally uniform. Nevertheless, it is possible to reduce the problem of finding a weighted -net to that of finding a uniform -net following a standard reduction, in which an expanded instance is generated by copying each element a number of times roughly proportional to its weight [3, 4]. This can generate copies of each element, which can have notable consequences. First, to achieve a weighted -net in the original instance, one must use a smaller value for the expanded instance, on the order of . This results in an approximation ratio of . Secondly, generating copies can increase the number of elements from to . This can increase the runtime considerably. In particular, repeatedly sampling from sets of size can become prohibitive on large instances such as the wireless coverage problem motivating our work.
1.2 Our Contributions
This paper generalizes the elegant net-finder algorithm of Mustafa [17] to the setting of weighted -nets, in order to produce a fast and simple algorithm for the hitting set problem, which attains asymptotically optimal approximation ratios with respect to the shallow cell complexity. The algorithm enjoys a faster runtime that makes solving larger instances, such as LoRaWAN receiver placement at scale, feasible. This is achieved by combining the weighted -net finder with the reduction of Even et al. [8]. In doing so, we also improve on the asymptotic approximation ratio from to where is the optimal value to the linear relaxation of the hitting set program (1). While in the worst case , it is often the case that . However, the multiplicative constants in our analysis are relatively large, matching those of Mustafa [17]. In addition to the algorithm, our analysis generalizes the classic Packing Lemma of Haussler [11], as well as the Shallow Packing Lemma of Mustafa et al.. [19], to the weighted setting, which may be of independent interest.
Key to our approach are adaptations of Mustafa’s [19] Shallow Packing Lemma and Haussler’s [11] classic Packing Lemma that accommodate non-uniform weights. Our main technical contribution is to allow a notion of weighted packings. Consider any non-negative weights with , and extend it to element subsets via .444Any non-negative weights with can be normalized as . A -packing with respect to weights is a collection of sets in which (i) all sets in are at most -heavy, i.e., have bounded weight ; and (ii) all pairs of sets have symmetric differences of weight at least . (See Definition 1). Our weighted shallow packing lemma upper bounds the number of sets in as a function of the SCC. Our approach accommodates weights by sampling elements from a distribution with probability mass proportional to the weights, rather than from a uniform distribution as in the original proofs. Moreover, our proof uses sampling with replacement rather than without replacement to simplify the analysis. While more generally applicable, our result yields the same bound on the size of as in the unweighted setting. An analogous sampling approach is used in proving Theorem 1.1 [14]. Equipped with our generalized lemma, it is straightforward to adapt Mustafa’s [17] analysis to a weighted net-finder. A proof of our Weighted Packing Lemma is included in the extended online version.
2 Algorithm and Main Result
Our algorithm combines the LP-relaxation of Even et al. [8] with the generalized sampling approach of Mustafa [17]. Our procedure is summarized in Algorithm 1. The algorithm makes use of two global constants, and . These are assumed to be positive, and to satisfy and .
In the while loop, the weights denote the weight of set under the LP optimal weights .
Conceptually, the algorithm is simple; it randomly selects an initial set of elements from , and proceeds to add additional random subsets of elements to until this is a hitting set. The algorithm relies on an oracle that returns an arbitrary unhit set. This oracle is treated as a black box. Our main result is twofold: we bound the expected size of the solution hitting set as a function of the cell complexity, and bound the expected number of oracle calls.
Theorem 2.1
Let be a binary matrix encoding a hitting set instance with shallow cell complexity and . Let be LP optimal value. Then the algorithm returns a hitting set of expected size
[TABLE]
Furthermore it makes oracle calls in expectation.
Note that the algorithm always returns a hitting set; the randomness is in the size of the solution and the runtime. This is in contrast with the net-finder in Theorem 1.1. Both algorithms require knowing the VC dimension ; ours must additionally know the shallow cell complexity . If unknown, these can be searched for using a standard doubling trick [17].
3 The Weighted Shallow Packing Lemma
The Weighted Shallow Packing Lemma is key to proving Theorem 2.1. This section formally defines weighted shallow packings, states the lemma, and proves it. To this end, fix non-negative weights over , and define the weight of a subset of elements as . Assume that . To contrast, let denote the cardinality of any set . Note that the weights induce a probability distribution over the elements . Throughout, whenever an element of is randomly sampled, it is assumed to follow a distribution proportional to , in which case we say is sampled from , and denote this by . Note that an element sampled this way lies in subset with probability .
The main purpose of the weighted shallow packing lemma is to bound the number of sets in a set system in terms of its shallow cell complexity. Clearly, an arbitrary set systems can contain large numbers of sets. Instead, we focus on a particular kind of set system called a weighted packing. A set system is a packing if all its sets are “light”, and each pair of sets are sufficiently different from each other. Critically, we define “light” and “different” in reference to the weights.
Definition 1
Let be a set system with weights , and let be constants. If all sets in satisfy , and all pairs of distinct sets in have symmetric difference of weight at least , i.e.
[TABLE]
then we say is a weighted -packing with respect to .
We omit the “with respect to ”-statement whenever this is clear from context.
The shallow packing lemma bounds the number of sets in a packing as a function of the constants , the VC-dimension, and the shallow cell complexity.
Lemma 1 (Weighted shallow packing lemma)
Let be a set system on elements, equipped with weights , and let be a -packing with respect to for constants . Assume the set system has , and shallow cell complexity . Then
[TABLE]
The proof to this lemma makes use of our weighted Packing Lemma. The unweighted Packing Lemma is a classic result by Haussler [11] that bounds the number of sets in a packing. We generalize this to nonuniform weights.
Lemma 2 (Weighted packing lemma)
Let be a set system with sets and elements, equipped with weights . Let for some integer and assume there is a constant such that for all . Then
[TABLE]
where is the set of unique elements in a random sample of size , in which each element is sampled iid with replacement.
The proof of the latter lemma is in the appendix to the extended online version of the paper; Lemma 1 is proved next.
3.1 Proof of the Weighted Shallow Packing Lemma
Proof
Fix a -packing and let be a random sample of length , in which each element is sampled , , independently and with replacement. The number of elements sampled is . Let be the set of unique elements in . For every set , let denote number of (copies of) elements in that are in . Define as the sub-collection of “large” sets in packing that contain at least (copies of) elements in the random sample :
[TABLE]
It follows that the probability of a given range in being a member of is
[TABLE]
Our goal is to show that the collection of large sets has few members in expectation. To do so, it suffices to bound the probability that a fixed set is a member of . This is achieved using Markov’s inequality. Recalling that all sets have bounded weight gives
[TABLE]
where we used the fact that we sample from , which implies that . Now, Markov’s inequality bounds the probability of being in :
[TABLE]
Finally, because , we conclude that
[TABLE]
where the second-to-last inequality uses the shallow cell complexity of ; the system has at most elements, and sets have depth at most , as the system consists only of cells that are not “large”. The final inequality holds because . Finally, applying Lemma 2 completes the proof.
4 Proof of the Main Theorem
Equipped with the Weighted Shallow Packing Lemma, we follow a similar strategy as Mustafa [17]. We state and prove three key lemmas, and finally prove Theorem 2.1.
4.1 Key lemmas
The proof of our main theorem relies on all sets having similar weight. Let and be a feasible solution to the LP relaxation (1). By the constraints of the LP, each set has weight . Partition the collection of sets into groups of sets of similar weight; set belongs to group if and only if . Because the algorithm exclusively takes independent samples, we can view one run of the algorithm as multiple parallel, independent runs on each group of sets. All our bounds scale on the order , so summing over the groups gives a final bound on the order of . Hence, we assume henceforth that all sets have weight .
The key idea of the proof is to amortize the elements added from each processed unhit set throughout the run of the algorithm. We say a set is processed each time it is flagged as unhit by the oracle, and a sample is taken from it. We bound the total number of elements sampled using weighted -packings on two levels. The first-level packing is an arbitrary maximal packing of sets in . There are a bounded number of sets in . Next, each processed set is assigned to a set in the first-level packing . For a fixed set in the first-level packing, given that it has been assigned processed sets, we show that the collection of sets assigned to forms a second-level packing. Each second-level packing also has a bounded number of sets. Finally, by bounding the probability that a set in the first-level packing has any sets assigned to it, the total expected number of times the algorithm processes a set is bounded. Note that the assignments are only a tool for analysis; they need not be computed by the algorithm.
We begin by defining the first-level packing. Fix a maximal -packing , where denotes the number of sets in the packing. The Shallow Packing Lemma 1 upper bounds the number of sets in the packing by
[TABLE]
Now, suppose the algorithm runs for steps, processing sets in sequence. One given set may be processed multiple times. Denote the sets of sampled elements . The processed sets are assigned to sets in the first-level packing as follows. Arbitrarily assign each set to any index satisfying . Such an index exists because is a maximal -packing. It may be the case that . The next task is to bound the number of sets assigned to any set in the first-level packing.
Let denote the number of processed sets in assigned to . For now, condition on first-level packing set having at least one set assigned to it, i.e. . We study the probability of this event later. Relabel the sets and consider them in the order in which they were processed by the algorithm,
[TABLE]
Claim
For all , we have
[TABLE]
Proof. Fix . For all we have
[TABLE]
The first equality follows from straightforward accounting, and the second from the definition of symmetric difference. The inequality follows from the manner in which set is matched to the packing set . Finally, a simple rearrangement of terms yields the result.
This proves that the intersection of each set with its corresponding first-level packing set is heavy. This lets us define a second-level packing using the intersections .
Rather than directly bounding the the number of processed sets assigned to a first-level packing set, it is easier to first bound the length of a random subsequence of the assigned sets . For any , define the subsequence as the subsequence of processed sets in whose corresponding samples form -nets for the system :
[TABLE]
We proceed by bounding the length of the subsequence , and by choosing so as to make it likely for a set in to be in , using the -net Theorem 1.1. We use this to upper bound the expected number of sets in . Let denote the length of a sequence .
The following claim bounds the length of the subsequence above.
Claim
For any :
[TABLE]
Proof. Let and relabel the sets so that . Now consider an auxiliary sequence of sets based on intersecting the entries in with :
[TABLE]
This sequence of sets is used to generate a second-level packing. To do this, consider two distinct set-indices . The points are added before set is considered, so is a -net for , whereas the set – because it is subsequently considered by the algorithm – is not hit by this net. This implies that the intersection of and is of bounded weight, as it would be hit by the -net otherwise:
[TABLE]
This implies that the weight of the intersection of and is bounded above:
[TABLE]
The fact that sets in have pairwise intersections of small weight implies that their symmetric differences are heavy:
[TABLE]
where the first inequality uses Eq. 6, the second Eq. 8, and the last exploits the fact that sets , , and are each of measure at least and at most , and that . Thus, depending on the constants, the sequence may form a weighted packing.
Finally, reviewing two cases for the constants and makes the above more precise. First, if , the inequality above implies that the symmetric difference of and is strictly larger than . This cannot be the case as both sets are subsets of . Thus, the only sequence for which can be less than a half is if there are no two unique indices, implying that . Secondly, if , the sets in form a -packing over ; all sets have measure at most , and every symmetric difference is at least . This is our second-level packing. Now, the Shallow Packing Lemma 1 implies:
[TABLE]
where we have used the fact that is non-decreasing and that .
We can now bound the length of the full sequence of sets assigned to the packing set . Taking expectations sidesteps any dependencies in the sequences. For instance, a set can only be in if previous samples failed to hit it. However, for each fixed set , the probability of the sampled points forming a -net for is independent of previous sampling. Indeed, by Theorem 1.1, the probability that is a -net is at least .
Lemma 3 (Mustafa, Lemma 5 [17])
[TABLE]
Proof. We use a simple application of linearity of expectation, and Theorem 1.1:
[TABLE]
where we drop the conditioning on because the event that a particular sample is a -net is independent of the number of previous samples. On the other hand, Eq. 7 upper bounds the size of . Piecing these together yields the inequality:
[TABLE]
Thus far we have conditioned on a set in the first-level packing being assigned at least one processed set. We now bound the probability of this being the case. Later, this probability is used to compute the expected number of processed sets assigned to a first-level packing set.
Lemma 4
Let be the initial sample taken by the algorithm. Then for any :
[TABLE]
Proof. Fix an index . Suppose that . By Eq. 6, for any :
[TABLE]
The second inequality above follows from the assumption that all sets have weights within a factor 2 of each other. The above implies that, if is a -net for , then any would be hit by . In other words, only if is not a -net for :
[TABLE]
Beacuse , the initial sample includes each element with sufficient probability to apply Theorem 1.1 to the RHS above, completing the proof.
4.2 Proof of Theorem 2.1
Proof of Theorem 2.1. At this stage, the analysis closely follows Mustafa’s [17]. Clearly, the algorithm proceeds until is an -net with respect to measure , i.e., a hitting set. It suffices to bound the expected size of the hitting set , as well as the expected number of oracle calls. These quantities are related, since the number of points added depends on the number of times a set is processed.
First, consider the expected size of the hitting set. There are two contributions to the set: the initial sample , and the samples from the processed sets . We bound the expected size of the initial sample first.
Claim
The expected size of the initial sample, is bounded by
[TABLE]
This follows by summing the probability of sampling for each . An analogous result is used for the number of points added during the processing of a set , provided it is processed:
Claim
For any fixed set , conditional on being processed, the expected number of points added each time it is processed is
[TABLE]
This bound applies irrespective of whether or not a set was processed previously.
The number of points added during processing, and the number of oracle calls, can be bounded together. Recalling that are the processed sets, and using the claim above, the number of added elements is at most
[TABLE]
Thus, it suffices to bound the expected number of oracle calls . This is where we employ both the first-, and second-level packings. In particular
[TABLE]
The terms (i), (ii) and (iii) are bounded using Eq. 5, Lemma 3, and Lemma 4, respectively. In addition, using :
- (i)
2. (ii)
\mathbb{E}\left[\operatorname{len}\left({\mathcal{S}^{j}}\right)\big{\rvert}n_{j}\geq 1\right]\leq\frac{48d}{3/2-\beta-\gamma}\varphi\left(\frac{8d}{3/2-\beta-\gamma},\frac{24d}{3/2-\beta-\gamma}\right)\leq\frac{48d}{3/2-\beta-\gamma}\varphi\left(\frac{8d}{\beta\epsilon},\frac{24d}{\beta}\right); 3. (iii)
.
Combining the right-hand-side terms, we obtain the bound
[TABLE]
This is minimized by choosing a small , e.g. , and setting .
Finally, summing over the groups of sets, and adding the expected number of initial samples to the expected number added points completes the proof. Note that Eq. 13 also bounds the expected number of oracle calls made during the run of the algorithm.
Appendix 0.A Proof of the Weighted Packing Lemma
This section proves the Weighted Packing Lemma 2. Our proof closely follows the original in Haussler [11]. The reader is referred to Matoušek [15] (Sec 5.3) for an excellent treatment of the unweighted proof. We begin by restating the weighted lemma.
Lemma 5 (Weighted Packing Lemma)
Let be a set system with elements and sets , equipped with weights with . Let for some integer , and let be a constant such that for all . Then
[TABLE]
where is the set of unique elements in an random sample of size , in which each element is sampled iid with replacement.
The proof strategy is the following. First, we consider a random sample sampled from with replacement. The sample may contain repeated elements; let denote the set of unique elements in . Next, we generate a unit-distance graph; a weighted graph that depends on the random set , and derive three claims about the total weight of its edges: (i) an upper bound on the total weight, (ii) a partial lower bound, and (iii) a complete lower bound. Combining the bounds completes the proof. The main differences between our approach and that of Chazelle, Haussler, and Mustafa are twofold [5, 11, 16]. Firstly, we permit non-uniform weights as opposed to weighing each set by its cardinality, and for we sample from a probability distribution proportional to . Secondly we use sampling with replacement as opposed to without replacement. This makes the analysis more straightforward under non-uniform sampling using .
A weighted unit-distance graph over the sampled set-system takes a central stage in the proof. In this graph, sets are viewed as vertices, and edges are drawn between any two sets at unit-distance of each other.
Definition 2 (Unit distance graph)
Let be a set system. The unit distance graph of ) is a graph with vertex set and edges
[TABLE]
In other words, edges represents pairs of sets that differ on exactly one element. The following lemma connects the number of edges with the VC-dimension.
Lemma 6 (Haussler [11])
Fix a set system with . Let be its unit distance graph. Then .
We use this lemma to bound the total edge weight in our unit-distance graph. But first, we define our particular unit-distance graph and its edge weights.
We construct a graph that depends on the random set . Consider the projection of to , denoted . Let be a unit distance graph over the projected system. For each vertex , define the vertex weight as the number of sets that are projected to in , that is
[TABLE]
Moreover, define the weight of an edge as the minimum over the weights of its two vertices, . Finally, let the total edge weight be . Note that the weights are random variables because they depend on the random selection . We proceed by bounding the total edge weight. This will allow us to bound the size of the packing in a way that “looks like a magician’s trick” [15].
First, we find an upper bound for the total edge weight. This is naturally also an upper bound on the expected total edge weight.
Claim
The total edge weight is upper-bounded by .
Proof. This is the proof of Haussler and Chazelle [11, 5]. Lemma 6 implies that:
[TABLE]
Hence there exists a vertex in with degree at most . Each edge incident to has weight at most , so the vertex is responsible for edges of total weight at most . Applying this inductively proves the bound on the total weight.
[TABLE]
Next we derive a lower bound. It suffices to derive the bound for a reduced problem. Let be the subsequence of sample containing all but the last element . Similarly, let be the set of unique elements in the subsample , just as denotes the unique elements in the full sample . Now, when the final element is added to , some vertices in may form an edge due to . This occurs exactly when the last sampled element falls in the symmetric difference of two sets that were previously equal in the projection . Let be the sum of the weights of the edges due to element . In other words, the weight is the weight of the edges generated by adding a random element to the random sequence . Because the samples are iid, given a squence, the ordering of the random elements in the sequence is uniform over all permutations, so we can apply symmetry of expectation:
[TABLE]
Hence, it suffices to derive an upper bound on .
Following Haussler [15], an intermediate step is to lower bound the expectation of the weight due to the th element conditional on the previous elements . The lower bound follows from considering pairs of vertices that lack edges in but that may share an edge after adding . This happens exactly when the new element falls in their symmetric difference. This event occurs with probability at least , because we assume for all pairs in our packing . This argument uses the fact that we sample elements proportional to the weight .
Claim
For any set generated by a fixed sequence , with for , it holds that
[TABLE]
where denotes expectation over is over a single random element .
Proof. Fix a set corresponding to the unique elements in the partial selection . Consider an arbitrary set in the projection . There may be many sets in that map to in . Let be the collection of these sets, and let denote the number of such sets. Note that for any pair of sets , cannot contain any element in the symmetric difference , or else the two sets would not map to the same . However, when an additional element is sampled and added to (with the possibility that is already in ) the collection is partitioned into two groups: (i) sets that contain , and (ii) sets that do not contain . Let and denote the number of sets in these groups, respectively, with . These two groups are at a unit-distance in . The weight of the resulting edges in the unit-distance graph is exactly .
By adding up the expected weights due to each pair we get . For every pair , the probability that hits is . Thus, the expected contribution of each pair to the product is at least . Note that the sum depends on , however is independent of . Hence
[TABLE]
The first inequality follows from the fact that . The first equality uses the fact that there is partitioned into two groups, each at unit distance, so is the total number of edges between the two groups. Taking the above inequality and summing over all vertices gives the result
[TABLE]
By using the claim above it is now straightforward to produce a lower bound on the expected total edge weight.
Claim
.
Proof. We employ the reduction from above as well as the partial lower bound. Let denote the Cartesian product of element set . For any length sequence of elements in , let be the set of unique elements in . Analogously let let denote the random set of unique elements in a random sequence in . It then follows that:
[TABLE]
where the first inequality uses the partial lower bound, and the last equality follows from the definition the random set .
Finally, all the pieces are in place to prove the Packing Lemma. Using the lower and upper bounds it follows that cardinality of is bounded above by twice the expected size of :
[TABLE]
This yields the statement of the weighted packing lemma, completing the proof.
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] Aronov, B., Ezra, E., Sharir, M.: Small-size ε 𝜀 \varepsilon -nets for axis-parallel rectangles and boxes. In: Proceedings of the Forty-First Qnnual ACM Symposium on Theory of Computing. pp. 639–648 (2009)
- 2[2] Bar-Yehuda, R., Even, S.: A linear-time approximation algorithm for the weighted vertex cover problem. Journal of Algorithms 2 (2), 198–203 (1981)
- 3[3] Brönnimann, H., Goodrich, M.T.: Almost Optimal Set Covers in Finite VC-Dimension. Discrete Comput. Geom. 14 , 263–279 (1995)
- 4[4] Chan, T.M., Grant, E., Könemann, J., Sharpe, M.: Weighted capacitated, priority, and geometric set cover via improved quasi-uniform sampling. In: Proceedings of the Twenty-Third Annual ACM-SIAM Symposium on Discrete Algorithms. p. 1576–1585. SODA ’12, Society for Industrial and Applied Mathematics, USA (2012)
- 5[5] Chazelle, B.: A note on Haussler’s packing lemma (1992), a note on Haussler’s packing lemma
- 6[6] Chvatal, V.: A greedy heuristic for the set-covering problem. Mathematics of Operations Research 4 (3), 233–235 (1979)
- 7[7] Clarkson, K.L.: A randomized algorithm for closest-point queries. SIAM Journal on Computing 17 (4), 830–847 (1988)
- 8[8] Even, G., Rawitz, D., Shahar, S.M.: Hitting sets when the VC-dimension is small. Information Processing Letters 95 (2), 358–362 (2005)
