Abstract 1 Introduction 2 The algorithm 3 Getting a Multiplicative Approximation References

Query Complexity of Stochastic Minimum Vertex Cover

Mahsa Derakhshan Northeastern University, Boston, MA, USA Mohammad Saneian Northeastern University, Boston, MA, USA Zhiyang Xun University of Texas at Austin, TX, USA
Abstract

We study the stochastic minimum vertex cover problem for general graphs. In this problem, we are given a graph G=(V,E) and an existence probability pe for each edge eE. Edges of G are realized (or exist) independently with these probabilities, forming the realized subgraph 𝒢. The existence of an edge in 𝒢 can only be verified using edge queries. The goal of this problem is to find a near-optimal vertex cover of 𝒢 using a small number of queries.

Previous work by Derakhshan, Durvasula, and Haghtalab [STOC 2023] established the existence of 1.5+ε approximation algorithms for this problem with O(n/ε) queries. They also show that, under mild correlation among edge realizations, beating this approximation ratio requires querying a subgraph of size Ω(nRS(n)). Here, RS(n) refers to Ruzsa-Szemerédi Graphs and represents the largest number of induced edge-disjoint matchings of size Θ(n) in an n-vertex graph.

In this work, we design a simple algorithm for finding a (1+ε) approximate vertex cover by querying a subgraph of size O(nRS(n)) for any absolute constant ε>0. Our algorithm can tolerate up to O(nRS(n)) correlated edges, hence effectively completing our understanding of the problem under mild correlation.

Keywords and phrases:
Sublinear algorithms, Vertex cover, Query complexity
Funding:
Zhiyang Xun: Supported by NSF Grant CCF-2312573 and a Simons Investigator Award (#409864, David Zuckerman).
Copyright and License:
[Uncaptioned image] © Mahsa Derakhshan, Mohammad Saneian, and Zhiyang Xun; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Streaming, sublinear and near linear time algorithms
Acknowledgements:
The authors thank Sanjeev Khanna for countless insightful discussions and help.
Editors:
Raghu Meka

1 Introduction

We study the stochastic minimum vertex cover problem. In this problem, we are given an arbitrary n-vertex graph G(V,E) and an existence probability pe for each edge eE. Edges of G are realized or exist independently, with their corresponding probability forming the realized subgraph 𝒢. While 𝒢 is unknown, one can query an edge eE to see if this edge exists in 𝒢. The goal is to find a near-optimal vertex cover of 𝒢 by querying a small subset of E.

There is extensive literature studying various graph problems in this stochastic setting, such as minimum spanning tree [21, 22], all-pairs shortest paths [24], and maximum matching [13, 5, 12, 25, 3, 6, 9, 10, 8, 16, 15]. The stochastic vertex cover for general graphs was first studied by Blum, Behnezhad, and Derakhshan [7]. They provided a 2-approximation algorithm with O(n/p) queries where p=mineEpe. Later, this approximation ratio was improved to 1.5+ε by the work of Derakhshan, Durvasula, and Haghtalab [14] with O(n/εp) queries. Even though these stochastic settings are primarily concerned with information-theoretical questions, this was the first work to provide positive results for a computationally hard problem. However, the key unresolved question remains:

Question 1.

How many non-adaptive edge queries are needed to find a (1+ε)-approximation to the minimum vertex cover problem in the stochastic setting?

In this paper, we take a step toward answering this question. We design a simple algorithm and establish a relation between the number of queries it makes and the density of a well-known class of graphs called Ruzsa-Szemerédi Graphs (Definition 2). Our number of queries matches the lower bound of Derakhshan, Haghtalab, and Durvasula [14] for the number of queries needed to surpass a 1.5-approximation in the presence of O(n) correlated edges.

Definition 2 (Ruzsa-Szemerédi Graphs [23]).

An n-vertex graph G(V,E) is an RSn(r,t) graph if its edge set E can be decomposed into t edge-disjoint induced matchings of size r. We use RSn(r) to denote the maximum t for which RSn(r,t) exists.

Our main result is formalized in the theorem below.

Result 3.

Given any ε(0,1) let t be RSn(cn) for c=ε2128. There exists an algorithm that queries a subgraph of size O(tn/p) and finds a vertex cover with the expected approximation ratio of (1+ε).

Proving lower and upper bounds parameterized by the density of RS-graphs has been of interest in various communities, such as dynamic algorithms [11, 4], streaming algorithms [20, 1, 2], property testing [17], and additive combinatorics [19]. Despite this, our understanding of their density remains incomplete. What we currently know is:

nΩc(1/loglog(n))[17]RSn(cn)[18]n/log(O(log(1/c)))

where log(x) is the x-iterated logarithmic function. Our result is most interesting if the lower-bound turns out to be tight. In such a case the number of edges queried by our algorithms is

|Q|=O(n1+Ωc(1/loglog(n))/p)=O(n1+o(1)/p).

On the opposite end, if the actual density of RSgraphs is closer to the known upper-bound, our result implies |Q|=O(n2plogO(log(1/c))).

1.1 Technical Overview

We first design an algorithm with an additive error of at most εn in Section 2 and later show how it can be modified to obtain the (1+ε) approximation ratio. To choose which edges to query we rely on a parameter ce defined for any edge eE as follows:

ce=Pr[e has an end-point in OPT],

where OPT=MVC(𝒢). In this definition, the randomization comes from the realization of 𝒢 and MVC(.) is a fixed algorithm which returns the minimum vertex cover of a given graph. Basically, ce is the probability with which an edge eE is covered by MVC(𝒢).111Since we are not concerned with computational efficiency, we assume ces are known. Regardless, similar to [14], our results can also be obtained with the estimated value of ces calculated using polynomially many calls to the MVC oracle.

Given a parameter τ(0,1) whose value we fix later, we set Q, the subgraph that we query, to be the subgraph of edges with ce1τ. I.e.,

Q={eE:ce1τ}.

Since we need the output to be a valid vertex cover, our final solution also needs to cover all the edges that we do not query. Let us denote this subgraph by H=GQ. Therefore, after we query Q and see its realization 𝒬, the most straightforward way of finding a small vertex cover is to output MVC(𝒬H). However, for the sake of analysis, we need to design an alternative algorithm for finding a vertex cover of 𝒬H. We formally explain this in Algorithm 1 and briefly explain the overall ideas below.

After querying Q and observing its realization 𝒬, we also hallucinate the edges in H to get . The hallucinated subgraph is a random realization of H containing each edge independently w.p. pe. We then let P1=MVC(𝒬) and commit all its vertices to the final solution. Next, we pick another set of vertices, P2, to cover all the edges in H that were not covered by P1. That is, P2=MVC(H[VP1]). We finally output P1P2. This clearly covers both 𝒬 and H and is a valid solution. The extra step of hallucinating H is to ensure that P1 has the same distribution as the optimal solution (see 8). This gives us two properties:

  1. 1.

    The expected size of P1 is the same as OPT. To analyze our approximation ratio, it suffices to upper-bound E[|P2|].

  2. 2.

    For any edge eH, we have Pr[e not covered by P1]=1ce. Since by our choice of Q, the edges in H=GQ all have ce1τ. This implies that any edge in H remains in H[VP1] w.p. at most τ.

Having this, we argue that if the expected size of the solution P1P2 is more than E[OPT]+εn, then we have |P2|εn. This means that the subgraph R=H[VP1] has a large minimum vertex cover and, consequently, a large maximum matching. Now, suppose we draw T independent subgraphs of H from the same distribution as R and call them R1,,RT. (We can do so by running our algorithm on T different hallucinations of G (see Definition 4).)

From each Ri, we take the maximum matching of it to be Mi, and from Mi, we delete all the edges present in at least one other Rj for ji. We show that this gives us a set of induced matchings. Notice that since we have that any edge is present in Ri with probability at most τ, we can argue that deleting the edges present in other Rj’s will not reduce the size of Mi significantly for a choice of T=12τ. Therefore, we conclude that if E[|P2|] is greater than εn, we can find a dense RS-graph in H. Finally, by carefully choosing τ=1/3t, where t is RSn(εn/8), we argue that Algorithm 1 has an additive approximation of at most εn.

In Section 3, we explain how we can modify this algorithm and design our (1+ε) algorithm Algorithm 3. The main difference is that we pre-commit a subset of vertices to the final solution at the beginning of the algorithm. These vertices are the ones that have a high chance of being in OPT; therefore, including them does not significantly increase the size of the output. This allows us to argue that the optimal solution on H is large enough to allow us to turn the additive error into a multiplicative error.

1.2 Preliminaries

Throughout the paper, we denote the input graph as G=(V,E), where |V|=n. From this input graph, we have each edge e present in 𝒢 independently with probability pe. We denote the minimum value among all pes to be p. Given a small constant ε>0, our goal is to query a sparse subgraph of G represented by Q non-adaptively and find a (1+ε) approximate minimum vertex cover of 𝒢.

We let MVC() be a fixed algorithm which given any graph outputs its minimum vertex cover. We may also refer to this as the minimum vertex cover oracle. We define OPT=MVC(𝒢) to be the optimal solution to our problem. Note that OPT is a random variable since 𝒢 is a random realization of G. We also let opt=E[|OPT|] be the expected size of this optimal solution. We let μ(G) be the size of the maximum matching of the graph G.

For any vertex vV, we define

cv=Pr[vOPT],

which is the probability that v joins the optimal solution. This means vVcv=opt. Similarly for any edge e=(u,v) in the graph G we define

ce=Pr[uOPT or vOPT].
Definition 4 (Graph Hallucination).

Given a any subgraph L of G we define a hallucination of L to be a subgraph which contains each edge eL independently with probability pe.

We define RS(n) to be the largest number of induced edge-disjoint matchings of size Θ(n) in an n-vertex graph.

2 The algorithm

In this section, we prove the following theorem.

Theorem 5.

Let t be RSn(εn/8). Running Algorithm 1 with τ=13t finds a vertex cover that has an additive approximation of at most εn to the optimal minimum vertex cover and queries a subgraph of size O(tn/p).

To prove this theorem, we design Algorithm 1, which takes a parameter τ, and queries the subgraph Q with ce1τ. Let us call the edges realized in Q to be 𝒬. We then hallucinate the edges not in Q which we call the subgraph H=GQ to get . We then let P1 be MVC(𝒬).

This makes P1 have the same distribution of OPT (see 8 for the proof). Now we commit the vertices in P1 to the final solution and all that remains to be covered are edges in H that have not been covered so far. Therefore we add P2=MVC(H[VP1]) to the solution. All we need to do is to argue E[|P2|] is small since we have E[|P1|]=opt.

We show that if E[|P2|] is large we can find a large RS-graph in H (see Algorithm 2) so by carefully choosing τ which we relate to the density of RS-graphs we prove E[|P2|] is small and hence we prove Algorithm 1 has at most additive error of εn. In the next section we modify Algorithm 1 slightly to get Algorithm 3 and show that this algorithm finds a (1+ε) approximation to the minimum vertex cover.

2.1 A Two-Step Algorithm

Here we describe the algorithm for finding the minimum vertex cover of G. We call it the two step algorithm because the output consists of union of two sets P1 and P2.

Algorithm 1 An algorithm to find MVC for 𝒢.
Parameter: τ
  1. 1.

    Let Q be the subgraph of edges with ce1τ.

  2. 2.

    Let H be GQ.

  3. 3.

    Query edges in Q to get its realization 𝒬.

  4. 4.

    Hallucinate edges in H to form .

  5. 5.

    Let P1=MVC(𝒬).

  6. 6.

    Let R=H[VP1].

  7. 7.

    Let P2=MVC(R).

  8. 8.

    Return O=P1P2.

First, let us prove that the output of Algorithm 1 is a vertex cover.

Claim 6.

The output of Algorithm 1 is a vertex cover for 𝒢.

Proof.

Since P2 is a vertex cover on the graph that P1 does not cover we can argue that P1P2 is a vertex cover for 𝒢. Now let us bound the number of queries that Algorithm 1 makes.

Claim 7.

The size of subgraph Q that we query is at most O(npτ) for p=min(pe) for eE.

Proof.

Due to [14] we know that if we take a random minimum vertex cover P for 𝒢 at most O(n/p) edges will not be covered by it with high probability. Here we repeat how this argument works for convenience. Let us call this number of edges X and call this subgraph F. For any subgraph with more than n/p edges, the probability of none of its edges being in 𝒢 is at most (1p)n/p. Moreover, since F is an induced subgraph of G, there are at most 2n possibilities for it. By a union bound, we get that with high probability, F has at most n/p edges. That is:

Pr[|E(F)|n/p]12n(1p)n/p12nen=1(2/e)n

Due to linearity of expectation we have

E[X]=e1ce.

For the edges in Q we have 1ceτ so we can get |E(Q)|Xτ and since we have X=O(n/p) we get that |E(Q)|O(npτ).

Claim 8.

The expected size of P1 from Algorithm 1 is equal to opt and the distribution of P1 is the same as OPT

Proof.

Look at the graph that P1 is a minimum vertex cover for. It is the graph 𝒬. For any edge e, if it is in H then it is present in with probability pe and if it is in Q it is present in 𝒬 with probability pe. Since QH=G we can see that the distribution of 𝒬 is the same as the distribution for 𝒢 and hence the expected size of the minimum vertex cover for 𝒬 is the same as 𝒢 which is opt. Also since the distribution of 𝒬 is the same as 𝒢 we get

P1=MVC(𝒬)=MVC(𝒢)=OPT

Hence P1 comes from the same distribution as OPT.

Lemma 9.

If Algorithm 1 does not have additive approximation of at most k in expectation, then E[μ(R)]k2

Proof.

Due to 8, the expected size of P1 is opt. Therefore, if Algorithm 1 has worse than k additive approximation then we can conclude E[|P2|]k. In any graph the maximum matching size it at least half of the size of minimum vertex cover. Applying this statement on the graph R give us that

E[μ(R)]E[|P2|]2k2.

2.2 Finding a Dense RS-graph in 𝑯

Suppose in Algorithm 1 instead of querying Q and hallucinating H we hallucinate all the edges. We repeat this process T times, calling the resulting graph R in Algorithm 1 Ri for each i from 1 to T. For each Ri, we find the maximum matching Mi. Then, from each Mi, we delete the edges that are present in at least one other Rj for ji, and we define Si to be the remaining edges of Mi after these deletions. In Algorithm 2, we formalize this process. Our goal in this section is to argue that if Algorithm 1 does not have an additive error of at most εn, then the matchings Si will be large, and we can find a large RS-graph as a subgraph of H.

Algorithm 2 Finding a large RS-graph in H in Algorithm 1.
Parameter: τ
  1. 1.

    For i from 1 to T:

    1. (a)

      Let Q and H be graphs defined in Algorithm 1

    2. (b)

      Hallucinate graph G to get 𝒢i

    3. (c)

      Let Pi be MVC(𝒢i)

    4. (d)

      Let Ri=H[VPi]

  2. 2.

    Let Mi be the maximum matching of Ri

  3. 3.

    Delete the edges in Mi present in at least one other Rj with ji to get Si

  4. 4.

    Return S1S2 ST

The next claim will bound the probability of edges being in Ri.

Claim 10.

For each edge e and each graph Ri, we have that Pr[eRi]τ.

Proof.

For the edge e we have two cases, eQ or eH. If we have eQ and e𝒬, then this edge will not be present in R, otherwise if e𝒬 since P1 covers all the edges of 𝒬 this edge will not be present in R. So the only case that eR happens is when we have eH. In this case since we have ce1τ and P1 is a random minimum vertex cover of G, then the edge e will be covered with probability ce in P1 (this is because P1 comes from the same distribution as OPT according to 8). So this edge is present in P2 with a probability of at most 1ceτ.

The following claim will prove that the matching Si are induced matchings.

Claim 11.

The matchings Si formed in the random process are induced matchings.

Proof.

The graphs Ri are induced subgraphs on VP1. Suppose that Si’s are not induced matchings. Since we delete duplicate edges from Ri to get Si there is no edge e that is present in Si and Sj for ij. Hence, there must exist two edges e1=(u1,v1) and e2=(u2,v2) present in Si and e3=(u1,u2) present in Sj for ij to break the property of induced matchings. We call edges like e3 a cross edge. In this case, we can argue that the edge e3 is also present in Ri since both of its endpoints are in the vertices of Ri. Since e3 is present in Ri and Rj this edge gets deleted and can not be part of Sj. This contradicts with what we assumed. Therefore we can conclude that Si’s are induced matchings.

Claim 12.

Suppose we set T=12τ, then we have E[|Si|]k4.

Proof.

Due to Lemma 9, we have that E[|Mi|]k2. Now we should argue that with the edge deletions, each Mi will lose at most k4 edges in expectation. Take an edge e in Mi. For each ji we have Pr[eMi]τ due to 10 since for an edge to be in Mi it should also be in Ri. By an application of union bound the edge e is present in at least one other Mj with probability at most Tτ. Hence we get,

Pr[e not in any Mj]1Tτ=12

And for the size of Si we have:

E[|Si|]=eMi𝟙eMj for jieMi12k4

Lemma 13.

By running the process explained above in Algorithm 2 we can find an RSn(r,t) graph (see Definition 2) with t=12τ and r=k8 on H.

Proof.

Due to 12 we can have T=12τ matchings each with expected size k4. Putting these matchings together will give us expected Tk4 edges in total. Suppose we break each matching Si to smaller matchings of size k8 size. If the number of edges in Si is not divisible by k8 we will lose at most the reminder of |Si| to k8 which is at most k8. The new matchings each have size exactly k8 and are induced matchings. This is because the original Si’s did not have a cross edge (see 11 for what a cross edge is) and hence the new matchings also do not have a cross edge since we are just partitioning the edges of Si to smaller matchings. The total size of the new set of matchings is at least

Tk4Tk8=Tk8

This is because the total number of removed edges is bounded by the number of edges removed from each Si which is εn8 times the number of Si’s which is T. Since we are running the random process which in expectation gives us induced matchings of size k8 with total size of Tk8 there is an instance which we have at least Tk8 edges in total. From this we can construct an RSn(r,t) graph with r=k8 and t=12τ.

Now we are ready to prove Theorem 5. We restate the theorem below.

See 5

Proof.

Suppose that Algorithm 1 does not find a vertex cover with additive approximation of εn. Then by setting k=εn in Lemma 13 we get

t=12τ=1213t=1.5t

matchings each of size εn8 that are induced matchings. This is in contradiction with what we assumed since t is the maximum number of induced matchings of size εn8 for an RS-graph and now we have found 1.5t matchings of this size. This means that indeed Algorithm 1 has an additive approximation of at most εn for τ=13t. Due to 7, we have |E(Q)|O(npτ) which for τ=1/3t we get |E(Q)|=O(tn/p).

3 Getting a Multiplicative Approximation

In this section, we modify Algorithm 1 to give us a multiplicative approximation of 1+ε. Our modification is simple yet effective. At the beginning of the algorithm, we set P0={v:cv1αε} and commit P0 to the final solution. The intuition behind this is that since these vertices have high cv, they have a high probability of being in the final solution so it does not hurt us to have them in the final solution.

We do this specifically to be able to prove Lemma 16 which states cvs for a subgraph of vertices is lower bounded by αε2. This means that if we find an algorithm that is additive in terms of n the size of this subgraph, then it is also a multiplicative approximation because of the lower bound for cvs of this subgraph. Here is the modified algorithm.

Algorithm 3 Multiplicative Approximation Algorithm.
1. Let P0={v:cv1αε}.
2. Let G=G[VP0].
3. Let Q be the subgraph of edges with ce1τ in G.
4. Let H=GQ.
5. Query edges in Q to get its realization Q.
6. Hallucinate edges in GQ to form subgraph .
7. Let P1=MVC(Q).
8. Let R=H[VP1].
9. Let P2=MVC(R).
10. Return O=P0P1P2.

The first lemma we prove is for bounding the expected size of P0P1.

Lemma 14.

E[|P0P1|](1+ε/2)opt for α14

Proof.

We can write E[|P0P1|] as follows:

E[|P0P1|]=|P0|+E[|P1|]E[|P0P1|].

Due to 8, we know that E[|P1|]=opt. Take an arbitrary vertex vP0. Since P1 is a random minimum vertex cover, any vertex v in P0 has a probability of cv of also being in P1. And since cv1αε for vP0 we have Pr[vP1]1αε. Hence we have

|P0|E[|P0P1|]=vP01𝟙vP1|P0|(αε) (1)

We know that |P0|opt1αε this is because opt=vVcv and we have vP0cv(1αε)|P0|. Form Equation 1, we can get

|P0|E[|P0P1|]opt1αε(αε) (2)

Since we have α14 and ε1 from Equation 2 we have

|P0|E[|P0P1|] opt1αε(αε)
opt1αε(ε4)
opt0.5ε4
=optε2

Putting this together with E[|P1|]=opt due to 8 we get,

E[|P0P1|](1+ε/2)opt

From Lemma 14 we can argue that if Algorithm 3 has worse than εopt additive approximation in expectation, then |P2| is greater than εopt2. We use this fact in the following lemma.

Lemma 15.

If Algorithm 3 does not have a approximation of at most (1+ε) in expectation, then E[μ(R)]εopt4

Proof.

Due to Lemma 14 we have E[|P0P1|](1+ε/2)opt so if Algorithm 3 does not have a multiplicative approximation of at most (1+ε) then we can conclude E[|P2|]εopt2. In any graph, the maximum matching size is at least half the minimum vertex cover size. Applying this statement on the graph R gives us,

E[μ(R)]E[|P2|]2εopt4

The next lemma proves a lower bound for cv of vertices in H having at least one edge. We call this graph H for future reference, meaning we remove the vertices in H having no edge.

Lemma 16.

For any vertex vH, we have cvαε2 for ταε2.

Proof.

Take an edge e=(u,v)H since it has a degree of at least one. For this edge we know that ce1τ since we put all the edges with ce1τ in Q. Also we have cu<1αε since uP0. We also know that cecv+cu. Putting this all together we get that cvαετ which for a ταε2 we get cvαε2.

Claim 17.

We have optnαε2 for n=|V(H)|

Proof.

This is because we have,

opt=vVcvvHcv

and we know that vHcvnαε2 due to Lemma 16.

Putting 17 and Lemma 15 together we get that if Algorithm 3 does not give a (1+ε) approximation, then E[μ(R)]nαε28. The next lemma asserts that if Algorithm 3 does not find a (1+ε) approximation then we can find a large RS-graph in H.

Lemma 18.

If Algorithm 3 is not a (1+ε) approximation then, we can find an RSn(r,t) graph (see Definition 2) with t=1/2τ and r=αε2n32 on H

Proof.

Suppose we set k=nαε24. Then we can run the algorithm explained in Algorithm 2 and put together matchings Si formed from different realizations of H to find an RS-graph where each matching size is k/8. Due to having E[μ(R)]nαε28 we can prove 10. This is because for edges in Ri we can argue that they exist in Ri with a probability of at most τ similar to how we proved it for Ri’s in Algorithm 1 in 10. Moreover, like how we proved for Algorithm 2 that the matchings Si are induced matchings we form Si’s like in Algorithm 2 and we can argue that they are induced matchings. Then we can also prove 12 and Lemma 13 for the new value of k. Therefore, similar to how we proved Lemma 13 we can find an RSn(r,t) graph with t=12τ and r=k8=αε2n32 on H. Now we are ready to prove the main result of this work.

See 3

Proof.

Let us run Algorithm 3 with α=1/4 and τ=1/3t. Meaning we have c=αε232. We proceed similar to how we proved Theorem 5. Suppose that Algorithm 3 does not find a vertex cover with (1+ε) approximation. Then we can find an RSn(r,t) graph in H for t=1/2τ and r=αε2n32 since RSn(cn)RSn(cn) for nn. By setting k=nαε24 in Lemma 13 we get

t=12τ=1213t=1.5t

matchings each of size k8 that are induced matchings. This is in contradiction with what we assumed since t is the maximum number of induced matchings of size k8 for an RS-graph and now we have found 1.5t matchings of this size. This means that indeed Algorithm 3 has an approximation of at most (1+ε) for τ=13t. Due to 7, we have |E(Q)|O(npτ) which for τ=1/3t we get |E(Q)|=O(tn/p).

Correlated Edges

Suppose that G has some edges that are realized in 𝒢 independently called G1 and some edges that are correlated with each other and the edges in G1 called G2. This means that edges in G2 might exist based on edges in G1 or G2 that are realized. We need to adjust the definition of hallucination and realize the correlated edges by drawing them from the given distribution rather than realizing them independently. Moreover, if a set of them are queried and we want to hallucinate the rest, it should be done conditionally.

Notice that the only place we use independent realization of edges is in the proof of 7. So we can argue that among the edges in G1 at most O(tn/p) edges will be in Q. Furthermore we know that |Q||Q1|+|Q2| where Qi is the subgraph of Gi that is in Q. Since the number of correlated edges is at most RSn(cn) we have |Q2|nRSn(cn) so we get:

|Q||Q1|+|Q2|O(tn/p)+nRSn(cn)=O(tn/p)+nt=O(tn/p)

Based on the explanation above we drive the following corollary.

Corollary 19.

Our Algorithm 3 can handle up to t=RSn(cn) correlated edges for c=ε2128 and still provide a (1+ε) approximation to the optimal solution with O(tn/p) queries.

References

  • [1] Sepehr Assadi. A two-pass (conditional) lower bound for semi-streaming maximum matching. In Joseph (Seffi) Naor and Niv Buchbinder, editors, Proceedings of the 2022 ACM-SIAM Symposium on Discrete Algorithms, SODA 2022, Virtual Conference / Alexandria, VA, USA, January 9 - 12, 2022, pages 708–742. SIAM, 2022. doi:10.1137/1.9781611977073.32.
  • [2] Sepehr Assadi, Soheil Behnezhad, Sanjeev Khanna, and Huan Li. On regularity lemma and barriers in streaming and dynamic matching. In Barna Saha and Rocco A. Servedio, editors, Proceedings of the 55th Annual ACM Symposium on Theory of Computing, STOC 2023, Orlando, FL, USA, June 20-23, 2023, pages 131–144. ACM, 2023. doi:10.1145/3564246.3585110.
  • [3] Sepehr Assadi and Aaron Bernstein. Towards a unified theory of sparsification for matching problems. 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 11:1–11:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/OASICS.SOSA.2019.11.
  • [4] Sepehr Assadi and Sanjeev Khanna. Improved bounds for fully dynamic matching via ordered ruzsa-szemerédi graphs. CoRR, abs/2406.13573, 2024. doi:10.48550/arXiv.2406.13573.
  • [5] Sepehr Assadi, Sanjeev Khanna, and Yang Li. The stochastic matching problem: Beating half with a non-adaptive algorithm. In Constantinos Daskalakis, Moshe Babaioff, and Hervé Moulin, editors, Proceedings of the 2017 ACM Conference on Economics and Computation, EC ’17, Cambridge, MA, USA, June 26-30, 2017, pages 99–116. ACM, 2017. doi:10.1145/3033274.3085146.
  • [6] Sepehr Assadi, Sanjeev Khanna, and Yang Li. The stochastic matching problem with (very) few queries. ACM Trans. Economics and Comput., 7(3):16:1–16:19, 2019. doi:10.1145/3355903.
  • [7] Soheil Behnezhad, Avrim Blum, and Mahsa Derakhshan. Stochastic vertex cover with few queries. In Joseph (Seffi) Naor and Niv Buchbinder, editors, Proceedings of the 2022 ACM-SIAM Symposium on Discrete Algorithms, SODA 2022, Virtual Conference / Alexandria, VA, USA, January 9 - 12, 2022, pages 1808–1846. SIAM, 2022. doi:10.1137/1.9781611977073.73.
  • [8] Soheil Behnezhad and Mahsa Derakhshan. Stochastic weighted matching: (stochastic weighted matching: (1-ε) approximation. In Sandy Irani, editor, 61st IEEE Annual Symposium on Foundations of Computer Science, FOCS 2020, Durham, NC, USA, November 16-19, 2020, pages 1392–1403. IEEE, 2020. doi:10.1109/FOCS46700.2020.00131.
  • [9] Soheil Behnezhad, Mahsa Derakhshan, Alireza Farhadi, MohammadTaghi Hajiaghayi, and Nima Reyhani. Stochastic matching on uniformly sparse graphs. In Dimitris Fotakis and Evangelos Markakis, editors, Algorithmic Game Theory - 12th International Symposium, SAGT 2019, Athens, Greece, September 30 - October 3, 2019, Proceedings, volume 11801 of Lecture Notes in Computer Science, pages 357–373. Springer, 2019. doi:10.1007/978-3-030-30473-7_24.
  • [10] Soheil Behnezhad, Mahsa Derakhshan, and MohammadTaghi Hajiaghayi. Stochastic matching with few queries: (1-ε) approximation. In Konstantin Makarychev, Yury Makarychev, Madhur Tulsiani, Gautam Kamath, and Julia Chuzhoy, editors, Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, STOC 2020, Chicago, IL, USA, June 22-26, 2020, pages 1111–1124. ACM, 2020. doi:10.1145/3357713.3384340.
  • [11] Soheil Behnezhad and Alma Ghafari. Fully dynamic matching and ordered ruzsa-szemerédi graphs. In 65st IEEE Annual Symposium on Foundations of Computer Science, FOCS 2024, 2024.
  • [12] Soheil Behnezhad and Nima Reyhani. Almost optimal stochastic weighted matching with few queries. In Éva Tardos, Edith Elkind, and Rakesh Vohra, editors, Proceedings of the 2018 ACM Conference on Economics and Computation, Ithaca, NY, USA, June 18-22, 2018, pages 235–249. ACM, 2018. doi:10.1145/3219166.3219226.
  • [13] Avrim Blum, John P. Dickerson, Nika Haghtalab, Ariel D. Procaccia, Tuomas Sandholm, and Ankit Sharma. Ignorance is almost bliss: Near-optimal stochastic matching with few queries. In Tim Roughgarden, Michal Feldman, and Michael Schwarz, editors, Proceedings of the Sixteenth ACM Conference on Economics and Computation, EC ’15, Portland, OR, USA, June 15-19, 2015, pages 325–342. ACM, 2015. doi:10.1145/2764468.2764479.
  • [14] Mahsa Derakhshan, Naveen Durvasula, and Nika Haghtalab. Stochastic minimum vertex cover in general graphs: A 3/2-approximation. In Barna Saha and Rocco A. Servedio, editors, Proceedings of the 55th Annual ACM Symposium on Theory of Computing, STOC 2023, Orlando, FL, USA, June 20-23, 2023, pages 242–253. ACM, 2023. doi:10.1145/3564246.3585230.
  • [15] Mahsa Derakhshan and Mohammad Saneian. Query efficient weighted stochastic matching. CoRR, abs/2311.08513, 2023. doi:10.48550/arXiv.2311.08513.
  • [16] Shaddin Dughmi, Yusuf Hakan Kalayci, and Neel Patel. On sparsification of stochastic packing problems. In Kousha Etessami, Uriel Feige, and Gabriele Puppis, editors, 50th International Colloquium on Automata, Languages, and Programming, ICALP 2023, July 10-14, 2023, Paderborn, Germany, volume 261 of LIPIcs, pages 51:1–51:17. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.ICALP.2023.51.
  • [17] Eldar Fischer, Eric Lehman, Ilan Newman, Sofya Raskhodnikova, Ronitt Rubinfeld, and Alex Samorodnitsky. Monotonicity testing over general poset domains. In Proceedings of the thiry-fourth annual ACM symposium on Theory of computing, pages 474–483, 2002. doi:10.1145/509907.509977.
  • [18] Jacob Fox. A new proof of the graph removal lemma. Annals of Mathematics, pages 561–579, 2011.
  • [19] Jacob Fox, Hao Huang, and Benny Sudakov. On graphs decomposable into induced matchings of linear sizes. Bulletin of the London Mathematical Society, 49(1):45–57, 2017.
  • [20] Ashish Goel, Michael Kapralov, and Sanjeev Khanna. On the communication and streaming complexity of maximum bipartite matching. 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 468–485. SIAM, 2012. doi:10.1137/1.9781611973099.41.
  • [21] Michel X. Goemans and Jan Vondrák. Covering minimum spanning trees of random subgraphs. In J. Ian Munro, editor, Proceedings of the Fifteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2004, New Orleans, Louisiana, USA, January 11-14, 2004, pages 934–941. SIAM, 2004. URL: http://dl.acm.org/citation.cfm?id=982792.982933.
  • [22] Michel X. Goemans and Jan Vondrák. Covering minimum spanning trees of random subgraphs. Random Struct. Algorithms, 29(3):257–276, 2006. doi:10.1002/RSA.20115.
  • [23] Imre Z Ruzsa and Endre Szemerédi. Triple systems with no six points carrying three triangles. Combinatorics (Keszthely, 1976), Coll. Math. Soc. J. Bolyai, 18(939-945):2, 1978.
  • [24] Jan Vondrák. Shortest-path metric approximation for random subgraphs. Random Struct. Algorithms, 30(1-2):95–104, 2007. doi:10.1002/RSA.20150.
  • [25] Yutaro Yamaguchi and Takanori Maehara. Stochastic packing integer programs with few queries. In Artur Czumaj, editor, Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2018, New Orleans, LA, USA, January 7-10, 2018, pages 293–310. SIAM, 2018. doi:10.1137/1.9781611975031.21.