Weighted geometric set multi-cover via quasi-uniform sampling

. We give a randomized polynomial-time algorithm with approximation ratio O (log φ ( n )) for weighted set multi-cover instances with a shallow cell complexity of at most f ( z, k ) = zφ ( z ) k O (1) . Up to constant factors, this matches a recent result of Chan, Grant, K(cid:246)nemann and Sharpe [6] for the set cover case, i.e. when all the covering requirements are 1. One consequence of this is an O (1) -approximation for geometric weighted set multi-cover problems when the geometric objects have linear union complexity; for example when the objects are disks, unit cubes or halfspaces in R 3 . Another consequence is that the real di(cid:30)culty of many natural capacitated set covering problems lies with solving the associated priority cover problem only, and not with the associated multi-cover problem.


Introduction
In the weighted set multi-cover problem we are given a set P of n points and a collection S of m subsets of P. Each element p ∈ P has a positive integer demand d p , and each set s ∈ S has a positive weight w s .A subset X of S is a feasible multi-cover if each p ∈ P lies in (or equivalently is covered by) at least d p distinct sets in X, and the goal is to nd a minimum weight feasible multi-cover.The case when all the demands are unit (i.e.d p = 1 for all p) is known as the weighted set cover problem and has been studied extensively.
It is well known that the natural greedy algorithm is a 1 + ln n-approximation algorithm for the weighted set multi-cover problem, and unless NP has slightly super-polynomialtime algorithms, no polynomial-time algorithm can achieve a better approximation ratio (up to lower order terms), even for unit demands and weights [9].Thus, we focus here on special classes of instances where the underlying structure of the set system allows for an improved approximation.Such classes commonly arise in natural combinatorial optimization problems.For example, some network design problems can be cast as covering a collection of cuts using edges.Another class of such instances arise in geometry, where the sets are geometric objects such as disks, rectangles or fat triangles and the elements are points in R d .This paper is motivated by the following meta-question: If a particular set system (or class of set systems) admits a good approximation jocg.orgalgorithm for the set cover problem, then does it also admit a good approximation algorithm for the multi-cover case?
In addition to its direct relevance, multi-cover problems arise naturally in many practical settings, another important theoretical motivation to study this question arises from the result in [5] that a capacitated set cover problem can be reduced to a priority set cover problem, and a multi-cover problem on similar set systems.Thus, in many cases, better bounds for multi-cover problems will directly improve upon known bounds for capacitated problems.
While the set cover problem has been extensively studied for many classes of set systems, the corresponding multi-cover case has received less attention.At rst glance, it seems that there should be a simple general method for extending a set cover result to the corresponding multi-cover case.After all, their natural integer linear programming formulations dier only in the right hand side of the constraints, i.e.Ax ≥ 1 v.s.Ax ≥ d.However, this seems unlikely in general.For example, consider the classic survivable network design problem (SNDP): Given a graph G = (V, E) and demands r(u, v) for pairs u, v ∈ V , nd a minimum cost subset F of edges such that G = (V, F ) has r(u, v) edge disjoint paths for each pair u, v. SNDP can be viewed as a multi-cover problem where each cut S has covering requirement d(S) = max u∈S,v / ∈S r(u, v).Note that this problem seems much harder than the corresponding set cover case, r(u, v) ∈ {0, 1}, which is the Steiner network problem.A 2-approximation algorithm for Steiner network was known long before a 2-approximation was found for SNDP [10].In fact, obtaining an O(1)-approximation for SNDP directly from the Steiner Network result would be a signicant breakthrough.Further, extending common techniques for obtaining approximation algorithms for geometric set cover problems to the corresponding multi-cover problems poses several additional challenges (see [7] for a discussion).The only generic connection between set cover and multi-cover that we are aware of is the following (most likely folklore) result [3]: if a set system has an linear programming based α-approximation for set cover, then it has an O(min(log d max , log log n)α)-approximation for multi-cover, where d max is the maximum coverage requirement.
In this paper, we study the weighted set multi-cover problem on geometric set systems, and slight generalizations thereof.We extend the best known approximation results for the corresponding weighted set cover problem to hold for weighted multi-cover.Thus, we give a partial answer to the meta-question above: that for common geometric set systems, weighted multi-cover is not harder to approximate than set cover.

Previous Work
The goal in geometric set cover problems is to improve the ln n set cover bound by exploiting the underlying geometric structure.This is an active area of research and various dierent techniques have been developed.However, until recently most of these techniques applied only to the unweighted case.A key idea is the connection between set covers and -nets [4], which implies that proving better bounds on sizes of -nets for various geometric systems (an active research area in discrete geometry) directly gives improved guarantees for the unweighted set-cover problem.In another direction, [8] related the guarantee for jocg.orgunweighted set-cover to the complexity of the geometric objects.Here the complexity of a geometric shape refers to the size needed to describe it (which is roughly the number of vertices, edges, faces etc.).More precisely, [8] showed that if the complexity of the vertical decomposition of the complement of the union of any k sets is O(kh(k)), then there is an O(h(n))-approximation for unweighted set cover.This was subsequently improved to O(log(h(n))) [12,2], and these results were further extended to the (unweighted) multicover case in certain well-behaved" cases [7].However, none of these techniques work with weights.Roughly speaking, the problem is the following: all these techniques begin by random sampling (say, according to the optimum linear programming solution), followed by an alteration phase where the points that are left uncovered during the sampling phase are now covered.Their techniques are able to show that not many extra sets are needed in the alteration phase.However, they are unable to avoid the possibility that some sets may have a much higher chance of being picked than others, which is problematic if weights are present.
The rst breakthrough on weighted geometric cover problems was made by Varadarajan [11], who showed that for geometric set systems with union complexity 1 O(kh(k)), there is an ecient randomized algorithm with approximation ratio O(exp(O(log * n)) log h(n)).
Further, he showed that if the function h(n) is mildly increasing( in particular, it suces to have h(n) = ω(log (j) n) for some constant j), then the approximation ratio improves to O(log h(n)).The key idea behind this result was a new sampling approach, called quasiuniform sampling, which gives a uniform bound on the factor by which the probability that a set is sampled exceeds the value for that set in the optimal linear programming solution.
Recently, Chan et al. [6] rened this approach further and removed the mildly increasing requirement on h(n).They give an O(log h(n))-approximation algorithm for geometric set systems with union complexity O(nh(n)).In particular, this algorithm guarantees an O(1)-approximation if h(n) = O(1), which for example is the case for disks, pseudo-disks, axis-aligned octants, unit cubes, or half-spaces in three-dimensional space.
Instead of using union complexity, [6] presented their results using the notion of shallow cell complexity.
Denition 1.Let f (z, k) be a function that is non-decreasing in both k and z.A set system S of m sets has shallow cell complexity f (z, k) if for all 1 ≤ z ≤ m and for any collection X of z sets from S, the number of distinct regions covered by k or fewer sets in X is at most f (z, k).Here a region refers to an equivalence class of points that are covered by precisely the same sets in X.
Chan et al. [6] gave an O(log φ(n))-approximation algorithm for weighted set cover instances with shallow cell complexity zφ(z)k O(1) (here we assume without loss of generality that φ(z) ≥ 2).We remark that Varadarajan [11] also works with shallow cell complexity, without using this terminology directly.In particular, he uses the fact that geometric sets in R d with union complexity nφ(n) have shallow cell complexity O(zφ(z)k d−1 ).
1 Unlike in [8,7], the union complexity here means the complexity of the shape of the union of sets, and not of the vertical decomposition of the complement of the union.jocg.org

Result and Consequences
Our main result is: Theorem 2. There is a randomized polynomial-time algorithm that computes a c log(φ(n))approximation to the minimum weight multi-cover problem on n points where the underlying set system has shallow cell complexity f (z, k) = zφ(z)k c , for some constant c.Here c is a universal constant that only depends on c.
This matches the guarantee (up to constant factors) in [6] for the set cover case, and thus this extends all the geometric covering results in that paper from set cover to the multi-cover case.
An important consequence of our result is for capacitated covering problems.Here, each set s has a capacity c s in addition to a weight w s , and each point p has a demand d p ; a solution is feasible if the aggregate capacity of the selected sets covering a point is at least the point's demand.Perhaps surprising at rst sight, capacities make the problem substantially more dicult.For example, even if there is just one point to cover (a trivial problem without capacities), we obtain the NP-Hard Knapsack Cover problem.Recently, [5] gave a general method to deal with capacities, and show that any weighted capacitated covering problem can be reduced to weighted multi-cover problem(s) and the weighted priority cover problem on closely related systems.In a weighted priority cover problem, each set and each point has a priority, and each point must be covered by at least one set of higher priority than itself.In particular, they show that an O(α + β)-approximation algorithm for a weighted capacitated cover problem follows from an α-approximation algorithm for the underlying weighted multicover problem, and a β-approximation algorithm for the underlying weighted priority cover problem.
Our result implies that the real bottleneck for approximating capacitated covering problems in geometric settings is solving the associated priority cover problem.This already improves several results where previously the guarantee for the multi-cover problem was a bottleneck.One application is to Theorem 1.3 in [6], which says that any capacitated covering problem on an underlying network matrix has O(log log n)-approximation.Applying the improved bound in Theorem 2. together with the result in [6] that network matrices have O(nk) shallow cell complexity, improves the approximation ratio to O(1) for such problems.
Another application is to a general scheduling problem introduced in [3].They show that this problem can be cast as a capacitated covering problem where the sets are axis-parallel rectangles with the bottom side touching the x-axis.Applying Theorem 2 to such sets gives an O(1)-approximation for the associated multi-cover problem, improving upon the previous O(log log n) bound given in [3].This improves the approximation for the scheduling problem in [3] from O(log log nP ) to O(log log P ), where P is the ratio of the maximum to minimum job size.

Overview of Algorithm Design and Analysis
As mentioned previously, most previous approaches for geometric covering problems work via random sampling.The starting point is an optimal solution to the linear programming jocg.orgrelaxation of the natural integer programming formulation of the problem.If α is the desired approximation, then rst the sets s are sampled with probability O(αx s ), where x s is the probability that s is selected in the optimal linear programming solution.After this step, a forcing procedure is applied (perhaps recursively) to cover the remaining uncovered points.
The key insight in [11] and [6] is to develop a forcing procedure where the probability of picking each set s remains bounded by αx s .Such a forcing is called a quasi-uniform sampling.As our algorithm also uses this framework, we elaborate on this approach a bit more.
Let us start with explaining the approach, specialized to set cover, in which each demand is 1.Without loss of generality, the values x s can be assumed to be integer multiples of 1/M for some large integer M .The rounding proceeds in rounds.In round i, for each set s we independently with probability (roughly) 1/2, either double x s , or set x s to 0. This ensures that each x s is an integer multiple of 2 i /M .This continues for roughly log M rounds, until all variables are close to 0 or 1.In expectation, the extent to which each point is fractionally covered stays (roughly) the same.However, due to the randomness in the doubling step, if some point is p unlucky and is fractionally covered by signicantly less sets than expected, then a greedy forcing procedure is invoked to select some sets that will cover p.To obtain a quasi-uniform sampling, we need that the probability of forcing is suciently small and that the forcing procedure doesn't force any particular set with too high probability.
We want to adapt the above approach to multi-cover so that no dependence on the covering requirement d max is incurred in the approximation ratio.The main reason that this is challenging is that a point p must be covered by d p distinct sets, that is, we cannot pick the same set twice.If a set can be picked multiple times, the set-cover analysis in [6] can be adapted very easily to multi-cover (see [7]).
Our basic idea for overcoming this issue is simple.We rst pick all sets s with x s ≥ 1/Q for some large enough constant Q, and update the covering requirements accordingly.As the linear programming solution for the residual problem now satises x s < 1/Q for each s, each point p must be fractionally covered by Qd p sets in the linear programming solution.Thus, if the rounding proceeded according to expectation, there would be enough distinct sets to form a multicover at the end of the rounding.However, if it so happens that the number of distinct sets fractionally covering a point becomes signicantly less than expected, then we will again need a forcing procedure to reestablish that condition.The greedy forcing procedure for multicover is the natural extension to the forcing procedure for set cover.And we will again need to argue that the probability of forcing is suciently small.However, for multi-cover the argument that the probability of forcing is suciently small is signicantly more involved than the analogous argument for set cover.This argument is the main technical extension to the analysis for set cover in [6].
The rounding algorithm is described in Section 2. The algorithm's analysis is described in Section 3. The Algorithm Description The rounding of the linear programming solution proceeds in rounds.We rst describe the initial setup that creates the initial instance from the linear programming solution.We then describe the invariant that we wish to maintain at each round.During each round there is a sampling phase that discards some copies of certain sets, a forcing phase that permanently selects some sets and ensures that the invariant in maintained in the next round, and a cleanup phase.We next describe the sampling and cleanup phases, and the termination condition, which are relatively straightforward.The description of the forcing phase is postponed until Subsection 2.1 because it is more involved.
The Initial Setup: We assume that the given set system has shallow cell complexity f (z, k) = zφ(z)k c for some constant c and some nondecreasing function φ(z).To ensure that log(φ(z)) is positive, we will assume that φ(z) ≥ 2.
The exact integer formulation of the weighted set multicover problem is the following:

s:p∈s
x s ≥ d p , ∀p ∈ P and x s ∈ {0, 1}, ∀s ∈ S, where x s indicates whether the set s is selected or not.
The algorithm begins by solving the natural linear programming relaxation where we relax the requirement x s ∈ {0, 1} to x s ∈ [0, 1].Let x denote some xed basic optimum solution to this linear program.As there are n non-trivial constraints, at most n variables x s lie strictly between 0 and 1.Let Q be a large enough constant, whose value will be specied later.For each s with x s ≥ 1/(2Q), select s and decrease the demand d p by 1 for every point p covered by s.Clearly, the cost of selecting these sets is at most 2Q times the linear program cost.Consider the residual instance on the remaining sets and points.Let us redene d p to be the residual covering requirement of p. Clearly, the residual solution x s is still feasible for the residual instance.
Let M = n.We create a new instance by making n s = 2M x s copies of each set s.To distinguish between the original sets and the copies in the new instance, we will use replicas to denote the copies of a set s.As the linear program solution is feasible, s:p∈s x s ≥ d p for each point p, and thus p is covered by at least s:p∈s replicas in the new instance.The second inequality uses the fact that the linear program support is at most n.
Note that in this new instance, each point p is covered by at least M d p replicas of sets containing p, and each set has at most n s ≤ 2M x s ≤ M/Q replicas, as x s ≤ 1/(2Q).So p is covered by replicas corresponding to at least Qd p distinct sets.Let N denote the number of replicas in the instance.As there are at most n sets in the support and n s ≤ 2M = 2n for each s, we have that N ≤ 2n 2 .As N = O(n 2 ) and φ(z) ≤ z d for geometric problems in dimension d, log(φ(N )) = O(log(φ(n))).

jocg.org
The Invariant: We rst state the invariant, in equation ( 2), then give some intuition, and nally formally dene all the terms used in the invariant.
This says that each point must be covered by at least k(i)d p (i) replicas, but each set is only allowed to contribute up to k(i)/b(i) replicas.In particular this implies that there are at least b(i)d p (i) distinct sets that can cover p. Actually our algorithm will also ensure that n s (i) ≤ k(i)/b(i) for each set s, but it is more convenient to state the invariant (2) this way.The term n s (i) is the number of replicas of set s at the start of round i.The term d p (i) is the residual covering requirement for point p at the start of round i.The term k(i) = M/2 i−1 is the number of replicas we would expect for each set at the start of round i if we retained replicas with probability exactly 1/2.We dene for some suciently large constant R. In a couple of places we will need that R is suciently large so that we can argue that some bad events are suciently rare.The quantity (i) represents the bias in the rounding in round i towards retaining a set.Finally the term roughly represents a lower bound on the ratio of the number distinct sets covering a point p to the demand of p.We choose Q large enough so that in the nal round r, b(r) = 2.This completely determines Q.In Claim 7 we will show that Q = O(1).A Generic Round: The algorithm does the following in each round i for which (i) < 1/2.
• Sampling Phase: For each set s, independently retain each replica with probability 1/2 + (i), and discard the rest.Let n * s (i) denote the number of retained replicas for set s.
• Forcing Phase: After the sampling phase, if the invariant ( 2) is violated for a point p, then some sets covering p are permanently selected (also referred to as forced) to ensure that invariant (2) holds at the start of next round.Details are given in Subsection 2.1.
All the replicas of a forced set s are removed, and the residual covering requirement of points in s is reduced by 1.This will be the only point in the algorithm where the residual covering requirement of a point changes.
• The Cleanup Phase: For each s, if n * s (i) > k(i + 1)/b(i + 1), we retain k(i + 1)/b(i + 1) arbitrary replicas of s and discard the rest.Thus we will also have the invariant that the number of replicas of s in the next round n s (i + 1) = min(n * s (i), k(i + 1)/b(i + 1)).
Termination: When (i) becomes greater than or equal to 1/2 in the nal round r, then all the sets that have one or more replicas left are selected.

The Forcing Phase
We now explain how the sets to be forced are selected in a generic round i. Roughly speaking, all points that violate invariant (2) and have the same residual demand are considered in each sub-round.To determine which sets to pick to cover these points, an ordered list of replicas of sets is constructed carefully.This ordering ensures that property that not too many points that can force a set to be picked.
First we dene the pseudo-depth of a point, which is a more convenient notion to work with than residual requirement.Then we show in Claim 4 that the pseudo-depth is an upper bound on the residual covering requirement.We then explain, for each possible pseudo-depth q, how to construct an ordered list L q of replicas that have the property that they cover at least one point of pseudo-depth q, and that is increasingly ordered by the number of equivalent regions that they cover.We then explain how to use these lists to determine the sets to force.Finally, in Claim 5 we show why this forcing ensures that the invariant Denition 3. The pseudo-depth q p (i) of point p is s:p∈s n s (i)/k(i) , i.e. the number of replicas covering p at the start of round i, divided by k(i).
Claim 4. If invariant (2) holds at the start of round i, then for all p, q p (i) ≥ d p (i).
Proof.Invariant (2) implies that for each p, s:p∈s n s (i) ≥ k(i)d p (i).Since d p (i) is an integer, this implies that q p (i) ≥ d p (i).
Constructing the list L q : For q = 1, . . ., let P q be the collection of all points with pseudodepth exactly q.Let C q denote the collection of all replicas that cover some point in P q .For a collection of sets, a region is an equivalence class of points that are all covered by exactly the same sets.We initialize L q the empty order, and initialize the collection C q of remaining replicas to C q We construct an ordering L q of the replicas in C q by iterating the following steps.
1. Select a replica r ∈ C q that covers the least number of regions.
2. Append the replica r to the end of the list L q , and remove it from C q .
Without loss of generality we can assume that all the replicas corresponding to the same set appear consecutively in L q (as removing a replica r does not change the regions formed by C q unless r was the last remaining replica of its set).Thus, we can also view L q as an ordering of the sets.Let L p,q denote the ordered sublist of L q of sets that cover point p.Given a point p and a set s ∈ L p,q we dene the rank ρ p,q (s) of s as the number of distinct sets in L p,q that lie no later than s in the ordering (i.e.there are exactly ρ p,q (s) − 1 distinct sets before s in L p,q ).
Using the lists L q to determine which sets to force: Let s q be the last set s ∈ L q for which there is some point p such that p ∈ P q and p ∈ s for which the following forcing condition holds: t∈Lp,q:ρp,q(t)≥ρp,q(s) The forcing condition says that the total number of replicas of sets that contain p from s until the end of the list L q are insucient to satisfy the invariant (2) (in the next round) even if we pick all the replicas of the ρ p,q (s) − 1 sets appearing before s.Note that s q may not exist.If s q exists, then for each list L p,q all the sets with rank ρ p,q (s q ) or less are forced.
Claim 5.If the forced sets are selected for the multicover, and residual demands are updated appropriately, then invariant (2) will hold for all points.
Proof.We consider a pseudo-depth q.We need to show that the sets forced by pseudo-depth q cause invariant (2) to hold for points of pseudo-depth q, and does not cause invariant (2) to be violated for other pseudo-depths.
First assume that s q does not exist.Let p be a point with pseudo-depth q.So in particular the forcing condition does not apply for the set s with ρ p,q (s) = 1.Hence s:p∈s min n * s (i), and thus invariant (2) holds for p at the start of the next round.Now assume that s q exists, and again let p be a point with pseudo-depth q.Let s q be the set with ρ p,q (s q ) = ρ p,q (s q ) + 1 that appears after s q in the ordering L p,q .The set s q exists as s q cannot be the last in L p,q .This is because the invariant (2) after phase i ensures that |L p,q | = s∈Lp,q n s (i) ≥ b(i)q ≥ 2q ≥ q + 1, and it must necessarily be that ρ p,q (s q ) ≤ q for (4) to hold.As the forcing condition does not hold for p and s q t∈Lp,q:ρp,q(t)≥ρp,q(s q ) min n * t (i), = k(i + 1) (q − ρ p,q (s q )) . ( As the sets in L p,q of rank ≤ ρ p,q (s q ) will be in the multicover, the residual requirement for p reduces from d p (i) to at most d p (i) − ρ p,q (s q ) in round i + 1.So equation (5) ensures that the invariant (2) holds for p at the start of round i + 1.
Finally we show that the forcing for pseudo-depth q does not cause invariant (2) to be violated for a point p of pseudo-depth not equal to q.If a set s covering p is forced, the residual demand d p (i) decreases by 1.So the right hand side of invariant (2) reduces by k(i + 1).In contrast, the contribution min(n * s (i), k(i + 1)/b(i + 1)) on the left hand side of invariant (2) reduces by at most k(i + 1)/b(i + 1) ≤ k(i + 1).

3
The Algorithm Analysis We rst show that the algorithm returns a feasible multicover upon termination, and then focus on bounding the cost of the solution.

Feasibility
The correctness of the algorithm follows directly by the following argument.
Claim 6.The algorithm returns a valid multi-cover upon termination.
Proof.As invariant (2) holds at the last round r, each point p satises s:p∈s,ns(r)>0 and hence is covered by replicas involving at least b(r)d p (r) distinct sets.As b(r) = 2 > 1, and each set s with n s (r) > 0 is picked upon termination, the solution forms a valid multicover.

Bounding the cost via Quasi-Uniformity
We now prove that the algorithm produces a quasi-uniform sample, that is, every set is sampled with probability at most O(log φ(N )) times2 its LP contribution x s .
First we show that Q = O(1) and thus the algorithm only loses an O(1) by rounding all x s ≥ 1/Q to 1.This calculation is similar to Claim 2 in [6], but we describe it in detail here for completeness.

jocg.org
We now prove that quasi-uniformity.The key result, which is proved in Lemma 10, is that the probability that a set is selected (picked) in round i is at most 1 k(i) 2 .Given Lemma 10, the rest of the analysis follows along the lines in [6], which we give here for completeness.
In particular, we have the following claim.
Claim 8.If the forcing probability of a replica in round i is at most 1/k(i) 2 , then the probability that a set s is picked eventually by the solution is O(x s log φ(N )).
Proof.If s is never forced until the end of the algorithm, the probability that some xed replica f of s survives until the end is r−1 j=0 (1/2 + (j)), which by the calculation in Claim 7 is O(1)/2 r , which is O(log φ(N )/M ) by the choice of r.
On the other hand, if f (or equivalently s) is selected in round i, then this happens with probability at most 1/k(i) 2 conditioned on having survived until round i.As the probability of surviving until round i is O(1/2 i ), the probability that f is ever forced is at most As there are x s M replicas of s in the beginning, the probability that s is picked by the algorithm, either at termination or due to forcing is O( The rest of the analysis focuses on proving Lemma 10.We begin by stating the standard Cherno bounds [1] that we will use repeatedly. Theorem 9.If X = X 1 + . . .+ X n where each X i is a 0-1 random variables and µ = E[X], then for any 0 < δ < 1, Pr[X ≤ (1 − δ)µ] ≤ exp(−δ 2 µ/2) and Pr[X ≥ (1 + δ)µ] ≤ exp(−δ 2 µ/4).
Lemma 10.The probability that a set u is selected in round i is at most 1 Proof.Consider some xed round i and some set u.For notational convenience, let us denote k(i) by k.The set u is picked when the forcing rule (4) applies for a particular pair (p, s) such p ∈ u and p ∈ s, and s appears no earlier than u in the ordering given by L p,q .By the construction of the list L q , a replica of set u was placed in the list when there were at most k(q + 1)f (N, k(q + 1))/N = φ(N )(k(q + 1)) c+1 points p ∈ u (recall that points within a region are combinatorially identical, so we can assume there is exactly one point per region).
As each point p has pseudo-depth q there are at most k(q + 1) sets that can contain it.Thus there are at most φ(N )(k(q + 1)) c+2 pairs (p, s) that can cause u to be picked.
Let us x a set s and a point p at pseudo-depth q.Let us dene the event E p,q,s that the pair (p, s) is forced at pseudo-depth q.
We now focus on showing (6).For notational simplicity we will drop p and q from the subscripts in L p,q and ρ p,q (s).We will also drop i from b(i) and (i).
To bound E, it is convenient to dene two simpler events E 1 , E 2 and bound their probabilities.
Claim 11.For E to happen, it must be that (i) ρ(s) ≤ q, and (ii) at least one of the following events E 1 or E 2 must occur.
Proof.If ρ(s) ≥ q + 1, then the right hand side of E is at most 0 and E cannot occur.
For the second part we argue as follows.For any c, d, as min(c, d) = c − 1 c>d (c − d), note that the left hand side of E is identical to the dierence of the left hand sides of E
1 and E 2 .Thus if neither E 1 or E 2 occurs, then ≤ 1.This implies that E does not occur either.We now bound Pr[E 1 ] and Pr[E 2 ].