Learning Low Degree Hypergraphs
Abstract
We study the problem of learning a hypergraph via edge detecting queries. In this problem, a learner queries subsets of vertices of a hidden hypergraph and observes whether these subsets contain an edge or not. In general, learning a hypergraph with edges of maximum size requires queries [7]. In this paper, we aim to identify families of hypergraphs that can be learned without suffering from a query complexity that grows exponentially in the size of the edges.
We show that hypermatchings and low-degree near-uniform hypergraphs with vertices are learnable with queries. For learning hypermatchings (hypergraphs of maximum degree ), we give an -round algorithm with queries. We complement this upper bound by showing that there are no algorithms with queries that learn hypermatchings in adaptive rounds. For hypergraphs with maximum degree and edge size ratio , we give a non-adaptive algorithm with queries. To the best of our knowledge, these are the first algorithms with query complexity for learning non-trivial families of hypergraphs that have a super-constant number of edges of super-constant size.444Accepted for presentation at the Conference on Learning Theory (COLT) 2022.
1 Introduction
Hypergraphs are a powerful tool in computational chemistry and molecular biology where they are used to represent groups of chemicals and molecules that cause a reaction. The chemicals and molecules that cause a reaction are however often unknown a priori, and learning such groups is a central problem of interest that has motivated a long line of work on hypergraph learning in the edge-detecting queries model, e.g., [18, 7, 6, 2, 3, 1]. In this model, a learner queries subsets of vertices and, for each queried subset, observes whether it contains an edge or not. When the vertices represent chemicals, the learner queries groups of chemicals and observes a reaction if a subgroup reacts. The goal is to learn the edges with a small number of queries, i.e., a small number of experiments.
An important application of learning chemical reaction networks is to learn effective drug combinations (drugs are vertices and effective drug combinations are hyperedges). In particular, there has recently been a lot of interest in finding drug combinations that reduce cancer cell viability. For example, as part of AstraZeneca’s recent DREAM Challenge, the effectiveness of a large number of drug combinations was tested against different cancer cell lines [17]. Despite this interest, as noted by Flobak et al. [14], “our knowledge about beneficial targeted drug combinations is still limited, partly due to the combinatorial complexity”, especially since the time required to culture, maintain and test cell lines is significant. This combinatorial complexity motivates the need for novel computational methods that efficiently explore drug combinations.
One main obstacle to discovering effective combinations that involve vertices is that queries are required to learn hypergraphs with edges of maximum size [6]. Since there is no efficient algorithm for learning general hypergraphs with large maximum edge size, the main question is which families of hypergraphs can be efficiently learned.
Which families of hypergraphs can we learn with a number of queries
that does not grow exponentially in the size of the edges?
Our results.
We develop the first algorithms with queries for learning non-trivial families of hypergraphs that have a super-constant number of edges of super-constant size. The first family of such hypergraphs that we consider are hypermatchings, i.e., hypergraphs such that every vertex is in at most one edge. Learning a hypermatching generalizes the problem of learning a matching studied in [4, 8]. In addition to their query complexity, we are also interested in the adaptive complexity of our algorithms, which is the number of adaptive rounds of queries required when the algorithm can perform multiple queries in parallel in each round. Our first main result is an algorithm with near-linear query complexity and poly-logarithmic adaptive complexity for learning hypermatchings.
Theorem.
There is a -adaptive algorithm with queries that, for any hypermatching over vertices, learns with high probability.
The adaptivity of the algorithm can be improved to at the expense of queries. We complement our algorithm by showing that there are no -adaptive algorithms that learn hypermatchings using queries.
Theorem.
There is no -adaptive algorithm with polynomial query complexity that learns an arbitrary hypermatching over vertices, even with small probability.
Moving beyond hypermatchings, we study hypergraphs whose vertices have bounded maximum degree ( for hypermatchings). For such hypergraphs, the previously mentioned lower bound on the number of queries needed by any algorithm implicitly also implies that queries are required, even when , where is the ratio between the maximum and minimum edge sizes [6]. Thus, an exponential dependence on this near-uniform edge sizes parameter is, in general, unavoidable. We give a non-adaptive algorithm with query complexity that depends on the maximum degree and the near-uniform parameter of the hypergraph we wish to learn.
Theorem.
There is a non-adaptive algorithm with queries that, for any near-uniform hypergraph with maximum degree , learns with high probability.
This query complexity is independent of the maximum size of the edges and is polynomial in the number of vertices when the maximum degree and the edge size ratio are constant. Our learning algorithms rely on novel constructions of collections of queries that satisfy a simple property that we call unique-edge covering, which is a general approach for constructing learning algorithms with a query complexity that does not grow exponentially in the size of the edges. We believe that an interesting direction for future work is to identify, in addition to hypermatchings, other relevant families of hypergraphs that are learnable with queries, even when both the maximum edge size and the edge size ratio are non-constant.
Technical overview.
Previous work on learning a hypergraph relies on constructing a collection of sets of vertices called an independent covering family [7] or a cover-free family [3, 15, 16, 2]. These families aim to identify non-edges, which are sets of vertices that do not contain an edge . More precisely, both of these families are a collection of sets of vertices such that every non-edge set of size is contained in at least one set that does not contain an edge. These families have a minimum size that is exponential in and these approaches require a number of queries that is at least the size of these families. In contrast to these existing approaches that focus on non-edges, we construct a collection of sets of vertices such that every edge is contained in at least one set that does not contain any other edge of . We call such a collection a unique-edge covering family. Since the number of edges in a hypergraph with maximum degree is at most , there exists unique-edge covering families whose sizes depend on the maximum degree of instead of the maximum edge size .
The algorithm for learning a hypermatching proceeds in phases. In each phase, we construct a unique-edge covering family of a subgraph of containing all edges of size that is in a specified range. This unique-edge covering family is constructed with i.i.d. sampled sets that contain each vertex, independently, with probability depending on the edge size range. The edge size range is widened at the end of each phase. One main challenge with hypermatchings is to obtain a near-linear query complexity. We do so by developing a subroutine which, given a set that covers a unique edge of size at most , finds this unique edge with queries. For the lower bound for hypermatchings, there is a simple construction that shows that there are no non-adaptive algorithms for learning hypermatchings with queries. The technical part of interest is extending this construction and its analysis to hold for rounds. Finally, for low-degree near-uniform hypergraphs , we construct a unique-edge covering family in a similar manner to those for hypermatchings (). The main technical difficulty for hypergraphs with maximum degree is in analyzing the number of samples required to construct a unique-edge covering family, which is significantly more involved than for hypermatchings due to overlapping edges.
Related work.
The problem of learning a hidden hypergraph with edge-detecting queries was first introduced by Torney [18] for complex group testing, where this problem is also known as exact learning from membership queries of a monotone DNF with at most monomials, where each monomial contains at most variables [5, 6, 9].
Regarding hardness results, non-adaptive algorithms for learning hypergraphs with edges of size at most require queries where [2, 16]. Angluin and Chen [6] show that queries are required by any (adaptive) algorithm for learning general hypergraphs, and then extended this lower bound in [7] to for learning near-uniform hypergraphs with maximum edge size difference .
Regarding adaptive algorithms, Angluin and Chen [7] give an algorithm that learns a hypergraph with queries in rounds with high probability. When , Abasi et al. [2] give a randomized algorithm that achieves a query complexity of and show an almost matching lower bound. When , they present a randomized algorithm that asks queries for some constant , almost matching the lower bound of [6]. Chodoriwsky and Moura [12] develop an adaptive algorithm with queries. Adaptive algorithms with queries are constructed in [13]. Regarding non-adaptive algorithms, Chin et al. [11] and Abasi et al. [3] give deterministic non-adaptive algorithms with an almost optimal query complexity . The problem of learning a hypergraph when a fraction of the queries are incorrect is studied in Chen et al. [10] and Abasi [1]. We note that, to the best of our knowledge, all existing algorithms require a number of queries that is exponential in , or exponential in when . We develop the first algorithms using queries for learning non-trivial families of hypergraphs that have arbitrarily large edge sizes and a super-constant number of edges .
Finally, learning a matching has been studied in the context of graphs [4, 8]. In particular Alon et al. [4] provide a non-adaptive algorithm with queries. To the best of our knowledge, there is no previous work on learning hypermatchings, which generalizes matchings to hypergraphs of maximum edge size . Our lower bound shows that, in contrast to algorithms for learning matchings, algorithms for learning hypermatchings require multiple adaptive rounds. Similar to the algorithm in [4] for learning matchings, our algorithm for learning hypermatchings has a near-linear query complexity.
2 Preliminaries
A hypergraph consists of a set of vertices and a set of edges . We abuse notation and write for edges . For the problem of learning a hypergraph , the learner is given and an edge-detecting oracle . Given a query , the oracle answers if contains an edge , i.e. there exists such that ; otherwise, . The goal is to learn the edge set using a small number of queries. When queries can be evaluated in parallel, we are interested in algorithms with low adaptivity. The adaptivity of an algorithm is measured by the number of sequential rounds it makes where, in each round, queries are evaluated in parallel. An algorithm is non-adaptive if its adaptivity is .
The degree of a vertex is the number of edges such that . The maximum degree of is the maximum degree of a vertex . When , every vertex is in at most one edge and is called a hypermatching, which we also denote by . The rank of is the maximum size of an edge , i.e., . The edge size ratio of a hypergraph is . A graph is -near-uniform and is uniform if and respectively.
3 Learning Hypermatchings
In this section, we study the problem of learning hypermatchings, i.e., hypergraphs of maximum degree . In Section 3.1, we present an algorithm that, with high probability, learns a hypermatching with queries in rounds. The number of rounds can be improved to , at the expense of an query complexity. In Section 3.2, we show that there is no -round algorithm that learns hypermatchings with queries. Some proofs are deferred to Appendix A.1 and A.2.
3.1 Learning algorithm for hypermatchings
A central concept we introduce for our learning algorithms is the definition of a unique-edge covering family of a hypergraph , which is a collection of sets such that every edge is contained in at least one set that does not contain any other edge.
Definition 1.
A collection is a unique-edge covering family of if, for every , there exists s.t. is the unique edge contained in , i.e. and for all .
Efficiently searching for the unique edge in a set.
We first show that, given a unique-edge covering family of a hypermatching , we can learn . We observe that a set of vertices contains a unique edge if and only if and for some and that if it contains a unique edge, this edge is . This observation immediately leads to the following simple algorithm called FindEdgeParallel.
The main lemma for FindEdgeParallel follows immediately from the above observation.
Lemma 1.
For any hypermatching and set , FindEdgeParallel is a non-adaptive algorithm with queries that, if contains a unique edge , returns and None otherwise.
Proof.
It is clear that makes at most queries. If does not contain an edge, then and the algorithm returns None. If contains at least two edges, then there is no intersection between the edges because is a matching. Therefore, for every , , and the algorithm returns None. The only case left is when contains a unique edge . In this case and . In this case, return . ∎
In order to obtain a near-linear query complexity for learning a hypermatching, the query complexity of FindEdgeParallel needs to be improved. Next, we describe an -round algorithm, called FindEdgeAdaptive, which finds the unique edge in a set with queries, assuming . The algorithm recursively partitions into two arbitrary sets and of equal size. If , then contains at least two edges. If and (or similarly and ), then, assuming contains a single edge, this edge is contained in and we recurse on . The most interesting case is if . Assuming contains a single edge , this implies that both and contain vertices in and we recurse on both and . When recursing on , the set needs to be included in future queries to find vertices in (and vice-versa when recursing on ). The algorithm thus also specifies an additional argument for the recursive calls. This argument is initially the empty set, in the case where the set is added to when recursing on and vice-versa, and is included in all queries in the recursive calls.
Let be the at the beginning of the th iteration of the while loop of FindEdgeAdaptive. In the case where contains a single edge and , the algorithm maintains two invariants (formally stated in Lemma 2; proof in Appendix A.1). The first is that, for all vertices and all iterations , either or there exists a unique such that is contained in set . This invariant makes sure that every vertex will eventually be added to . The second is that all sets contain at least one vertex . This invariant explains why, in the base case , we add the single vertex in to the solution . Additionally, since by construction, are disjoint, the second invariant also implies that when , we have that either set contains more than one edge or that it contains a single edge of size greater than , in which case the algorithm returns None. This stopping condition ensures that at most queries are performed at each iteration of the while loop.
Lemma 2.
Assume there is a unique edge such that and that , then, for every vertex and at every iteration of the while loop of FindEdgeAdaptive we have that (1) either or for a unique and (2) for all .
We show that if returns , then is an edge. If there is a unique edge and , then the algorithm returns .
Lemma 3.
For any and , if there is a unique edge such that and this edge is such that , then returns the edge . Otherwise, it either returns None or an edge . uses at most queries in at most rounds.
Proof.
First, assume that there is a unique edge such that and that . Consider . If , then by Lemma 2, we have that at every iteration of the while loop, either or for some . Since for all , at iteration , either or for some and , in which case is then added to by the algorithm. Next, if , since for all by Lemma 2, is never added to . Thus, FindEdgeAdaptive returns the edge
Assume now that does not contain any edges. In this case, every query is answered by zero, and FindEdgeAdaptive returns None. Finally, assume that contains at least two edges. If FindEdgeAdaptive does not return None, then Step 14 ensures that the returned edge has size at most . Step 14 also ensures that contains at least one edge. If strictly contains an edge, then there is a vertex such that , in which case FindEdgeAdaptive would have returned None. Therefore, is an edge of of size less than .
We now show that FindEdgeAdaptive runs in rounds and makes at most queries. At every iteration of the while loop, FindEdgeAdaptive makes less than queries (recall that if then the algorithm returns None). We show that the number of iterations of the while loop is less than At every iteration of the while loop, for every couple in , the size of is divided by 2. After iterations, either is empty or for every couple in we have . This guarantees that no sets are added to . Therefore, the number of iterations of the while loop is less than . This also shows that the adaptive complexity of FindEdgeAdaptive is less than . After the while loop, we make at most queries and the total number of queries is less than . ∎
Constructing a unique-edge covering family.
Next, we give an algorithm called FindDisjointEdges that, for any hypermatching , constructs a unique-edge covering family of the -near-uniform hypermatching . is defined as the subgraph of over edges of size between and and over vertices in that are not in an edge of size less than . The unique-edge covering family is constructed with i.i.d. samples that contain each vertex in , independently, with probability . The algorithm then calls a FindEdge subroutine, which is either FindEdgeParallel or FindEdgeAdaptive, on samples that contain at least one edge.
We show that such samples suffice to construct a unique-edge covering family of the -near-uniform hypermatching .
Lemma 4.
Assume , , that the FindEdge subroutine uses at most queries in at most rounds, and let be the samples, then FindDisjointEdges is an -adaptive algorithm with queries such that, with probability , is a unique-edge covering family of the hypermatching and thus .
Proof.
We know that a sample contains at least an edge if and only if . We also know from Lemma 1 and Lemma 3 that if contains a unique edge of size less than , then the subroutine will return . Therefore, to learn all edges of size in , we only need to make sure that each such edge appears in at least one sample that does not contain any other edges, in other words, that is a unique-edge covering family for }. Below, we show that it is the case w.p. .
We first show that with high probability, each edge of size is contained in at least sample ’s. We use to denote the number of samples containing , then we have By Chernoff bound, we have As there are at most edges of size between and , by a union bound, and we get From now on we condition on the event that all edges whose size is between and are included in at least samples. We show below that given for a sample , the probability that there exists another edge of size at least in is upper bounded by . Recall that is the hidden matching we want to learn. We abuse notation and use to denote that an edge is both in the matching and included in the sample . We have
where the first inequality uses a union bound, the first equality is due to the fact that is a matching and thus and that vertices are sampled independently, and the second inequality follows because the total number of remaining edges is upper bounded by and each edge is in with probability at most . As each edge with size between and is contained in at least samples, we have
where the last inequality is since . By another union bound on the edges of size between and , We can thus conclude that with probability at least , for all with size between and , there exists at least one sample that contains but no other remaining edges. By Lemma 1 and Lemma 3, is returned by , and is added to the matching that is returned by .
Next, we show that FindDisjointEdges is an -adaptive algorithm that requires queries. We first observe that FindDisjointEdges makes only parallel calls to FindEdges (after verifying that ). Therefore, since FindEdges runs in at most rounds, we get that FindDisjointEdges runs in at most rounds. To prove a bound on the number of queries, we first argue using a Chernoff bound that with probability , every edge of size at least is in at most samples . Therefore there are at most samples such that . For every one of these samples, we call , which makes queries by assumption. Therefore, with high probability , FindDisjointEdges makes queries. ∎
The main algorithm for hypermatchings.
The main algorithm first finds edges of size by brute force with FindSingletons. It then iteratively learns the edges of size between and by calling , where is the set of vertices that are not in edges learned in previous iterations. At the end of each iteration, the algorithm increases . We obtain the main theorem for learning hypermatchings, the proof of which is given in Appendix A.1.
Theorem 5.
Let be a hypermatching, then FindMatching learns w.h.p either in rounds using queries, with and FindEdgeAdaptive, or in rounds using queries, with and FindEdgeParallel.
3.2 Hardness of learning hypermatchings
In this section, we show that the adaptive complexity of learning a hypermatching with queries is . This result is in sharp contrast to matchings (where edges are of size ) for which there exists a non-adaptive learning algorithm with queries [4].
Warm-up: hardness for non-adaptive learning.
As a warm-up, we present a simple construction of a family of hypermatchings for which there is no non-adaptive learning algorithm with queries. Each hypermatching in this family depends on a partition of the vertex set into three parts where , , and . contains edges of size which form a perfect matching over and one edge of size which contains all the vertices in . The only vertex in is not contained in any edges in . The main idea of the construction is that, after one round of queries, vertices in and are indistinguishable to the learning algorithm. However, the algorithm needs to distinguish vertices in from the vertex in to learn the edge .
Theorem 6.
There is no non-adaptive algorithm with query complexity that can learn every non-uniform hypermatching with probability .
Proof.
Let be the set of all possible partitions such that , , and . We consider a uniformly random partition from , a matching and a non-adaptive algorithm that asks a collection of non-adaptive queries. The main lemma (Lemma 2) shows that, with high probability, for all queries , the answer is independent of which vertices in constitute the edge . The analysis of this lemma consists of two cases. If the query is small (), then we show that contains less than vertices from , w.h.p. over the randomization of , by the Chernoff bound. Therefore does not contain and is independent of the partition of into and . If is large (), then contains an edge of size two from . Thus and is independent of the partition of into and .
In Lemma 3, we argue that if all queries of are independent of the partition of into and , then, with high probability, the matching returned by this algorithm is not equal to . By the probabilistic method, there is a matching with that does not successfully learn with probability . ∎
Hardness of learning in rounds.
The main technical challenge is to generalize the construction and the analysis of the hard family of hypergraphs for non-adaptive learning algorithms to a construction and an analysis which holds over rounds. In this construction, each hypermatching depends on a partition of the vertex set into parts. For each , contains edges of size which form a perfect matching over . We set the sizes such that , , and .
The main idea of the construction is that after rounds of queries, vertices in are indistinguishable to any algorithm. However, the algorithm needs to distinguish vertices in from vertices in , for all , to learn . Informally, since the edges in have a larger size than edges in for , an algorithm can learn only one part at each round of queries, the one with edges of minimum size among all parts that have not yet been learned in previous rounds.
Theorem 7.
There is no -adaptive algorithm with query complexity which can learn every non-uniform hypermatching with probability .
Proof Sketch, full proof in Appendix A.1..
Let be the set of all partitions such that , and let be a uniformly random partition from , and be an algorithm with queries. In Lemma 8, we show that if vertices in are indistinguishable to at the beginning of round of queries, then vertices in are indistinguishable at the end of round .
The proof of Lemma 8 consists of two parts. First, Lemma 7 shows that if is small ( and is independent of partition of into , then w.h.p., for every , does not contain any edge contained in . Second, Lemma 6 shows that if a query has a large size ( and is independent of partition of into , then w.h.p. contains at least one edge from the matching on which implies . Proving Lemma 6 is quite involved. Because the edges of a matching are not independent from each other, a Chernoff bound analysis is not enough to show that the probability that a query does not contain any edge from is small. We therefore provide an alternative method to bound this probability (Lemma 5). In the end, in both cases, we show that is independent of the partition of into . Finally, we conclude the proof of Theorem 7 similarly as for Theorem 6. ∎
4 Learning Low-Degree Near-Uniform Hypergraphs
In this section, we give an algorithm for learning low-degree near-uniform hypergraphs. The algorithm is non-adaptive and has query complexity for learning a hypergraph of maximum degree and edge size ratio . It generalizes FindDisjointEdges and constructs a unique-edge covering family, but its analysis is completely different, and significantly more challenging, due to overlapping edges. Full proofs are deferred to Appendix B.
Near-uniformity is necessary.
The query complexity from the previous section for holds for any hypermatching , even those with edge size ratio . In contrast, for general , we obtain an query complexity. Angluin and Chen [7] show that queries are required to, even fully adaptively, learn hypergraphs of maximum edge size . Their hardness result holds for a family of hypergraphs of maximum degree and edges of size or , so with . Thus, it implies that queries are required to learn hypergraphs even when , i.e., an exponential dependence on is required.
The algorithm.
FindLowDegreeEdges constructs a unique-edge covering family of the hypergraph similarly to FindDisjointEdges, which requires a larger number of samples when . In addition, steps - are needed to ensure that intersections of edges are not falsely identified as edges since, when contains two or more edges that all overlap in , we have that .
Recall that for hypermatchings, FindDisjointEdges is used as a subroutine in an adaptive procedure that learns edges of any size. For hypergraphs, however, we cannot call FindLowDegreeEdges iteratively and remove vertices in learned edges after each call because a large edge could overlap with a small edge.
The analysis.
The main technical challenge in this section is to analyze the sample complexity required to obtain w.h.p. a unique-edge covering family. The main lemma bounds the probability that, conditioned on a sample containing an edge , this sample contains another edge .
Lemma 1.
If a sample set is constructed by independently sampling each vertex w.p. from a hypergraph with maximum degree , maximum edge size , edge size ratio , , then for any edge ,
Proof. [Proof Sketch, full proof in Appendix B.1.] Given an edge , the proof of Lemma 1 relies on analyzing the following two mathematical programs, whose optimal values are used to bound .
s.t. | |||
s.t. | |||
The variables denote the number of edges of size intersecting in vertices and we assume . The two programs have identical constraints. The first constraint is that the sum, over edges , of the size of the intersection of and has to be at most since has size and each vertex has degree at most . The second constraint is that the sum, over edges , of the size of has to be at most since there are vertices of degree at most
For the objectives, we note that is the probability that a fixed collection of vertices is in a sample. Thus, is the probability that an edge of size intersecting in vertices is not contained in a sample , conditioned on . If events and were independent for all (which is not the case), the probability that there is no other edge in , conditioned on would be equal to the objective of the left program. The objective of the right program is an upper bound on by a union bound over all edges . We denote the optimal value to the left and right programs by and . The main steps of the proof are
-
1.
In Lemma 9, we show that the unfavorable event is more likely to happen with the edge independence assumption:
(1) by using induction and Bayes rule to formalize the intuition that the events for are positively correlated because edges could share common vertices.
-
2.
In Lemma 12, we show that for ,
(2) by deriving a closed-form optimal solution of , which maximizes for and sets the rest .
-
3.
In Lemma 13, we show that
(3) -
4.
In Lemma 15, we show that
(4) by deriving a closed-form solution to and showing that it can be upper bounded by and that for .
- 5.
We are now ready to present the main result for this section (see Appendix B.2 for the full proof).
Theorem 8.
For any -near-uniform hypergraph with maximum degree , maximum edge size , and number of vertices , FindLowDegreeEdges correctly learns with probability . Furthermore, it is non-adaptive and makes at most queries.
We note that if the exact parameters , , and are unknown and only upper bounds , , are available, then, if is large enough so that , we have that FindLowDegreeEdges with inputs also learns with probability .
Acknowledgements
We thank Meghan Pantalia and Matthew Ulgherait for helpful discussions on finding drug combinations that reduce cancer cell viability.
References
- Abasi [2018] Hasan Abasi. Error-tolerant non-adaptive learning of a hidden hypergraph. In 43rd International Symposium on Mathematical Foundations of Computer Science (MFCS 2018). Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik, 2018.
- Abasi et al. [2014] Hasan Abasi, Nader H Bshouty, and Hanna Mazzawi. On exact learning monotone DNF from membership queries. In International Conference on Algorithmic Learning Theory, pages 111–124. Springer, 2014.
- Abasi et al. [2018] Hasan Abasi, Nader H. Bshouty, and Hanna Mazzawi. Non-adaptive learning of a hidden hypergraph. Theoretical Computer Science, 716:15 – 27, 2018. ISSN 0304-3975. doi: https://doi.org/10.1016/j.tcs.2017.11.019. URL http://www.sciencedirect.com/science/article/pii/S0304397517308496. Special Issue on ALT 2015.
- Alon et al. [2004] Noga Alon, Richard Beigel, Simon Kasif, Steven Rudich, and Benny Sudakov. Learning a hidden matching. SIAM Journal on Computing, 33(2):487–501, 2004.
- Angluin [1988] Dana Angluin. Queries and concept learning. Machine learning, 2(4):319–342, 1988.
- Angluin and Chen [2004] Dana Angluin and Jiang Chen. Learning a hidden graph using o (log n) queries per edge. In International Conference on Computational Learning Theory, pages 210–223. Springer, 2004.
- Angluin and Chen [2006] Dana Angluin and Jiang Chen. Learning a hidden hypergraph. Journal of Machine Learning Research, 7:2215–2236, December 2006. ISSN 1532-4435.
- Beigel et al. [2001] Richard Beigel, Noga Alon, Simon Kasif, Mehmet Serkan Apaydin, and Lance Fortnow. An optimal procedure for gap closing in whole genome shotgun sequencing. In Proceedings of the fifth annual international conference on Computational biology, pages 22–30, 2001.
- Bshouty [2018] Nader H Bshouty. Exact learning from an honest teacher that answers membership queries. Theoretical Computer Science, 733:4–43, 2018.
- Chen et al. [2008] Hong-Bin Chen, Hung-Lin Fu, and Frank K Hwang. An upper bound of the number of tests in pooling designs for the error-tolerant complex model. Optimization Letters, 2(3):425–431, 2008.
- Chin et al. [2013] Francis YL Chin, Henry CM Leung, and Siu-Ming Yiu. Non-adaptive complex group testing with multiple positive sets. Theoretical Computer Science, 505:11–18, 2013.
- Chodoriwsky and Moura [2015] Jacob Chodoriwsky and Lucia Moura. An adaptive algorithm for group testing for complexes. Theoretical Computer Science, 592:1 – 8, 2015. ISSN 0304-3975. doi: https://doi.org/10.1016/j.tcs.2015.05.005. URL http://www.sciencedirect.com/science/article/pii/S0304397515003965.
- D’yachkov et al. [2016] A. G. D’yachkov, I. V. Vorobyev, N. A. Polyanskii, and V. Y. Shchukin. On multistage learning a hidden hypergraph. In 2016 IEEE International Symposium on Information Theory (ISIT), pages 1178–1182, 2016.
- Flobak et al. [2019] Åsmund Flobak, Barbara Niederdorfer, Vu To Nakstad, Liv Thommesen, Geir Klinkenberg, and Astrid Lægreid. A high-throughput drug combination screen of targeted small molecule inhibitors in cancer cell lines. Scientific data, 6(1):1–10, 2019.
- Gao et al. [2006] Hong Gao, Frank K Hwang, My T Thai, Weili Wu, and Taieb Znati. Construction of d (h)-disjunct matrix for group testing in hypergraphs. Journal of Combinatorial Optimization, 12(3):297–301, 2006.
- Hwang and Du [2006] Frank Kwang-ming Hwang and Ding-zhu Du. Pooling designs and nonadaptive group testing: important tools for DNA sequencing, volume 18. World Scientific, 2006.
- Menden et al. [2019] Michael P Menden, Dennis Wang, Mike J Mason, Bence Szalai, Krishna C Bulusu, Yuanfang Guan, Thomas Yu, Jaewoo Kang, Minji Jeon, Russ Wolfinger, et al. Community assessment to advance computational prediction of cancer drug combinations in a pharmacogenomic screen. Nature communications, 10(1):1–17, 2019.
- Torney [1999] David C. Torney. Sets pooling designs. Annals of Combinatorics, 3(1):95–101, 1999. doi: 10.1007/BF01609879. URL https://doi.org/10.1007/BF01609879.
Appendix A Missing Analysis for Hypermatchings (Section 3)
A.1 Missing analysis for algorithm for learning hypermatchings (Section 3.1)
See 1
Proof.
It is clear that makes at most queries. If does not contain an edge, then and the algorithm returns None. If contains at least two edges, then there is no intersection between the edges because is a matching. Therefore, for every , , and the algorithm returns None. The only case left is when contains a unique edge . In this case and . In this case, return . ∎
Let be at the beginning of the th iteration of the while loop of FindEdgeAdaptive. To prove Lemma 3, we need the following three loop invariants in FindEdgeAdaptive. See 2
Proof.
To simplify the proof, we actually show the following three loop invariants, where the second is an intermediary step to show the third invariant:
-
1.
either or for some
-
2.
for all
-
3.
for all
We prove the three invariants by induction on .
Base case: At the beginning of the first iteration, and , and we have the following 1) For every we have . 2) 3) .
Assume that the statement of the lemma holds at the beginning of iteration . We will show that it holds at the beginning of iteration . Let be at the beginning of the th iteration of the while loop of FindEdgeAdaptive.
-
1.
Consider a vertex . If at the beginning of the th iteration we had , then at the beginning of the th iteration as well. Suppose now that for some at the start of iteration . If then is added to at Step 8. Assume , and let . Then is partitioned into two sets and . If and then this contradicts the fact that contains a unique edge. In fact, without loss of generality, we can assume that . Therefore cannot include , and the only way is if contains another edge. If and then we know that and is added to . If and then we know that and is added to . If and then both and are added to , and we have either or .
-
2.
From steps 9 to 11 in FindEdgeAdaptive, a couple is only added to when . In step 12, we have and , and both and are added to . But we know from the induction assumption that at the beginning of iteration we had , therefore by 2. . This ensures that also in this case, is only added to when .
-
3.
We know from the induction hypothesis for all . For a fixed contains a vertex from . In the while loop, is partitioned into and , such that is either in or in . If , then , is added to and . Similarly, if , then , is added to and . Assume now that , then and ) are added to and we need to show that and . We know from 2. that . Therefore implies that there is a vertex of both in and , therefore and . This concludes this part and shows that whenever is added to , we have .
∎
See 4
Proof.
We know that a sample contains at least an edge if and only if . We also know from Lemma 1 and Lemma 3 that if contains a unique edge of size less than , then the subroutine will return . Therefore, to learn all edges of size in , we only need to make sure that each such edge appears in at least one sample that does not contain any other edges, in other words, that is a unique-edge covering family for }. Below, we show that it is the case with probability .
We first show that with high probability, each edge of size is contained in at least sample ’s. We use to denote the number of samples containing , then we have
By Chernoff bound, we have
As there are at most edges of size between and , by a union bound, we have
Subsequently,
From now on we condition on the event that all edges whose size is between and are included in at least samples. We show below that given for a sample , the probability that there exists another edge of size at least in is upper bounded by . Recall that is the hidden matching we want to learn. We abuse notation and use to denote that an edge is both in the matching and included in the sample . We have
(5) | ||||
(6) | ||||
(7) | ||||
where Eq.(5) uses union bound. Eq.(6) is due to the fact that is a matching and thus and vertices are sampled independently. Eq.(7) follows because the total number of remaining edges is upper bounded by and each edge is in with probability at most .
As each edge with size between and is contained in at least samples, we have that
where the last inequality follows because .
By another union bound on all edges of size between and (at most of them), we have that
We can thus conclude that with probability at least , for all with size between and , there exists at least one sample that contains but no other remaining edges. By Lemma 1 and Lemma 3, is returned by and is added to the matching that is returned by .
Next, we show that FindDisjointEdges is an -adaptive algorithm with queries. We first observe that FindDisjointEdges makes only parallel calls to FindEdges (after verifying that ). Therefore, since FindEdges runs in at most rounds, we get that FindDisjointEdges runs in at most rounds. To prove a bound on the number of queries, we first argue using a Chernoff bound that with probability , every edge of size at least is in at most samples . For a fixed edge we have:
A union bound on the at most edges yields that every edge of size at least is in at most samples with probability . Therefore, there are at most samples such that For every one of these samples, we call , which makes queries by assumption. Therefore, with high probability , FindDisjointEdges makes queries. ∎
The following claim is a technical result we need to prove Theorem 5.
Claim 1.
For we have .
Proof.
Consider the function for . The derivative of is
Because , we have . Therefore,
where the last inequality follows from the assumption that . ∎
See 5
Proof.
FindSingletons learns, with probability 1, all the edges of size . For edges of size greater than 2, from Lemma 4, we know that each call of fails to find all edges in of size between and with probability at most . As there are at most different edge sizes, FindDisjointEdges is called at most times (we show below that it is actually called at most times). Thus, the probability that at least one of the calls fails is upper bounded by
We can thus conclude that the probability that all calls are successful is at least .
Next, we show that FindMatching makes calls to FindDisjointEdges.
We use to denote the value of after the call of FindDisjointEdges for with being the number of adaptive rounds of FindMatching and set . We show that the algorithm needs less than rounds to go over all the possible edge sizes of the matching. In step 5 of FindMatching, we update as follows:
Therefore
(8) |
and
(9) |
Since the maximum we input to FindDisjointEdges is , we have that
and subsequently
Therefore, FindMatching makes calls to FindDisjointEdges. From Lemma 4, we know that with high probability , runs in rounds and makes queries when FindEdges runs in rounds and makes queries. From Lemma 1 and Lemma 3 we know that for the subroutines FindEdgeAdaptive and FindEdgeParallel we have and respectively. Therefore FindDisjointEdges runs in rounds and makes queries with FindEdgeAdaptive and in 2 rounds with FindEdgeParallel. We conclude that with high probability,
-
•
FindMatching runs in rounds and makes queries with FindEdgeAdaptive,
-
•
FindMatching runs in rounds and makes queries with FindEdgeParallel.
Now we turn our attention to particular values of .
-
•
Suppose now that and that we use FindEdgeAdaptive. We get then . Furthermore, by Claim 1, we have
Therefore we get that . We also observe that for
Therefore . We finally conclude that when and we use the subroutine FindEdgeAdaptive, FindMatching runs in adaptive rounds and makes queries in total.
-
•
With and FindEdgeParallel, we have and we get that FindMatching learns any hypermatching w.h.p. in rounds and with at most queries.
∎
A.2 Missing analysis for hardness of learning hypermatchings (Section 3.2)
A.2.1 Lower bound for non-adaptive algorithms
To argue that learning hypermatchings non-adaptively requires an exponential number of queries, we fix the number of vertices , we construct a family of matchings which depend on a partition of the vertex set into 3 parts such that
-
•
.
-
•
contains a perfect matching with edges of size 2.
-
•
-
•
is an edge of the matching s.t. .
-
•
.
We denote all such partitions by . For a partition , multiple matchings are possible, depending on the perfect matching . We use to denote a random matching from all the possible matchings satisfying the properties above. The main idea of the construction is that after one round of queries, elements in and are indistinguishable to any algorithm with polynomial queries. However, a learning algorithm needs to distinguish elements in from the element in to learn the edge .
Before presenting the proof, we formalize what it means for a set of elements to be indistinguishable. Since the next definition is also used in the next subsection, we consider an arbitrary family of partitions . Given a partition , we denote by : the union of parts such that , i.e. . Informally, we say that queries are independent of the partition of : if the values of these queries do not contain information about which elements are in , or or .
Definition 2.
Given a family of partitions and a partition , let be a partition chosen uniformly at random from . Let be a matching on such that and are equal on . A query is independent from if with high probability over .
For example, in the partition above, any query such that contains an edge from is independent of the partition of since this query will always answer 1.
Analysis of the construction. We consider a non-adaptive algorithm , a uniformly random partition in , and a matching . We argue that with high probability over both the randomization of and the decisions of , the matching returned by is not equal to . The analysis consists of two main parts.
The first part argues that, with high probability, for all queries made by a non-adaptive algorithm, is independent of the partition of .
Lemma 2.
Let be a uniformly random partition from . For any collection of non-adaptive queries, with high probability , for all , is independent of the partition of .
Proof.
Consider any set which is independent of the randomization of . There are two cases depending on the size of .
-
1.
. In this case, if does not contain at least vertices from , then for any other partition such that , we have . In fact, both and will be equal 1 if and only if contains an edge from . Next we show that, with high probability, will contain fewer than vertices from . Since is a uniformly random set of size , by the Chernoff bound, with probability .
We therefore get that for any partition and query with probability .
-
2.
. In this case, the set contains at least one matched edge from . In fact, the number of edges in plus the size of is
must therefore contain at least one edge from , and we get that for any partition and query with probability 1.
By combining the two cases and , we get that with probability , is independent of the partition of , and by a union bound, this holds for any collection of sets . ∎
The second part of the analysis argues that if all queries of an algorithm are independent of the partition of , then, with high probability, the matching returned by this algorithm is not equal to .
Lemma 3.
Let be a uniformly random partition in and a random matching over . Consider an algorithm such that all the queries made by are independent of the partition of . Then, the (possibly randomized) matching returned by is, with probability , not equal to .
Proof.
Consider an algorithm such that all queries of are independent of the partition of . Thus, the matching returned by is conditionally independent of the randomization of the partition given .
For the algorithm to return , it needs to learn the edge . We distinguish two cases.
-
•
does not return any edge that is included in . In this case, with probability 1, is not equal to .
-
•
returns an edge that is included in . We know from the previous lemma that with probability , all queries are independent from . Therefore, the edge returned by is also independent of the partition . The probability that this edge is equal to is less than . Therefore, with probability , the returned matching is not equal to .
∎
See 6
Proof.
Consider a uniformly random partition , a matching and an algorithm which queries . By Lemma 2, after one round of queries, with probability over both the randomization of and of the algorithm, all the queries made by are independent of the partition of . By Lemma 3, this implies that, with probability , the matching returned by is not a equal to . By the probabilistic method, this implies that there exists a partition for which, with probability , does not return after one round of queries. ∎
A.2.2 Lower bound for adaptive algorithm
Our idea is to construct a partition , such that every set is a perfect matching of edges of size , and therefore has edges. We want to choose the size and ( increasing) such that with probability , after rounds of any adaptive algorithm that asks a polynomial number of queries, the partition is indistinguishable.
Our construction
-
•
.
-
•
.
-
•
.
-
•
.
Notation : Let be the set of partitions satisfying the conditions above. For a fixed , let , and let be the random matching on . Finally, let
Claim 2.
The construction has partitions.
Proof.
We first show that the construction has partitions.
By induction we have that
Therefore
This implies that
and
Next we show that . We know that , which implies that and
Therefore,
∎
Suppose that at the beginning of round , we learned but is indistinguishable. Consider a query of the -th round. We show that if the query is big, then with high probability contains an edge from , and if is small, then does not contain any edge from the high partition In both cases, querying gives an answer that is independent to with high probability over all the polynomial number of queries. Therefore, after the -th round, is indistinguishable.
Outline of the proof. Claim 3 is a technical result we need to bound the binomial coefficients in our proofs. Lemma 4 gives the expected size of the intersection of a query with a partition and presents a concentration result on the intersection when the queries are large. Lemma 5 shows that for the purpose of bounding the probability that no edge of a partition is included in , we can drop the constraint the edges are disjoint and think of them as being randomly and uniformly sampled (with replacement) from the partition. Lemma 6 shows that , then with probability , contains at least one edge from the matching on . If , then Lemma 7 shows with probability , for every , does not contain any edge from the matching on . Combining the two lemmas (Lemma 8) shows that if is a uniformly random partition in , and if all the queries made by an algorithm in the previous rounds are independent of the partition of , then any collection of non-adaptive queries at round , independent of
with probability .
Claim 3.
If , then
Proof.
We have that
The upper bound follows immediately. To show the lower bound, we observe that
Now consider the function for and . For and fixed , the function decreases as increases. Similarly, for fixed, decreases as increases. Therefore
Furthermore, we know that for , . Therefore
∎
Lemma 4.
Let be an arbitrary subset of . After rounds, for , the expected size of the intersection is
where the expectation is over the partitions of into . Moreover, for any polynomial set of queries such that for , then with probability , for all and for all , we have .
Proof of Lemma 4.
Every node in will be in with probability , therefore by linearity of expectation
Suppose now that . By Chernoff bound, we have
In the fourth inequality, we used . By a union bound the probability that there exists a partition with such that is . Another application of the union bound on the polynomially many queries shows that with probability at least , for all queries of size greater than and for all partitions greater than , we have . ∎
Lemma 5.
Fix an iteration , and a query . Let be edges of size , independently and uniformly sampled from . Let be a random matching on . We have
Proof.
Since the partition is fixed, we drop indexing by and use to denote , to denote , and to denote . We also let and assume without loss of generality that .
The intuition is that, since the edges must be disjoint but the edges do not necessarily have to, then the edges will cover a “bigger fraction” of than .
We prove this by induction on the number of edges. When considering only one edge , we know that
Now assume that the result is true for edges, i.e. . We want to show that it holds for edges, i.e.,
By the inductive hypothesis, it is sufficient to show that
This is equivalent to showing that . Furthermore, we have
Therefore, becomes equivalent to
(10) |
Since, , the inequality (10) is equivalent to
(11) |
Lemma 6.
Consider a query by an algorithm at round such that all the queries from previous rounds are independent of . Let be such that , then with probability , contains at least one edge from the matching on
Proof.
(12) | ||||
(13) |
where the inequality comes from Lemma 5. Since , we have with high probability that . Conditioning on this event, and since we already have , we get by Claim 3
Since , we get that
Lemma 7.
Consider a query by an algorithm at round such that all the queries from previous rounds are independent of . Let be such that , then with probability , for every , does not contain any edge from the matching on .
Proof.
Let’s fix a partition with . Let be the random matching on . We have for ,
Going forward, we present an upper bound on . We can assume without loss of generality that . In fact, for any , if then we have .
The probability that can be expressed as
where . By Chernoff bound we get
where the second to last inequality is due to . Therefore by a union bound on the edges of the matching in we get that
Finally, another union bound on all the partition yields that the probability that there exists a partition such that an edge of is included in is less than . ∎
Lemma 8.
If vertices in are indistinguishable to at the beginning of round of queries, then vertices in are indistinguishable at the end of round with probability .
Proof.
Consider a query by an algorithm at round such that all the queries from previous rounds are independent of the partition . Lemma 7 shows that if is small ( and is independent of partition of into , then with probability , for every , does not contain any edge contained in . On the other hand, Lemma 6 shows that if a query has large size ( and is independent of partition of into , then with probability , contains at least one edge from the matching on which implies . In both cases, is independent of the partition of into with probability . By a union bound, this holds for queries at round . ∎
See 7
Proof.
Consider a uniformly random partition , a matching and an algorithm which queries in rounds. By Lemma 8, after rounds of queries, with probability over both the randomization of and of the algorithm, all the queries made by are independent of the partition of . Therefore, and since by Claim 2, we get that after round of queries, with probability over both the randomization of and the algorithm , all the queries made by are independent of the partition of . We now distinguish two cases:
-
•
does not a return any edge that is included in .
-
•
returns a set of edges that is included in . In this case, we know that with probability all the queries made by are independent of the partition of into and . The edges that are returned by and included in are therefore also independent from the partition of into and with probability . To fully learn , needs to make the distinction between points in and points in , but there are ways of partitioning into and . Therefore the probability that correctly learns is less than
In the rest of the proof, we show that . This implies that the probability that learns correctly is less than .
We know that . Therefore . By Claim 3, we get that
Therefore, with probability , the matching returned by is not equal to . ∎
Appendix B Missing Analysis for Low Degree Near Uniform Hypergraphs (Section 4)
B.1 Proof of Lemma 1
Lemma 9.
Assume that the hypergraph has a maximum degree of and edge size between and . Let be a vertex-sample with probability , and assume that contains an edge . We have
Proof.
The intuition is that the term treats the events that the edges are not contained in as independent events.
Consider the following intermediate optimization problem
s.t. | ||||
We want to show that for every , and for any edges , all different than , we have
For , the result clearly holds. Suppose by induction for any edges , all different than , we have
If we consider edges, then
By the induction hypothesis we know that . Therefore, if we can show that
(18) |
then we will have
To see that (18) holds, we omit conditioning on to ease notation. By Bayes rule,
When for some value , then we know with probability one that . Therefore
Furthermore,
therefore
∎
Lemma 10.
For , any optimal solution to and is such that for all .
Proof.
For ease of notation, we use instead of in the proof. Suppose to the contrary that there is an optimal solution such that for some . Then consider the alternative solution such that , , and for all or . For small enough, clearly the constraints still hold.
The net increase in objective value of is because and . The new objective value of is times the old objective value (thus smaller than the old objective value) again because and . Therefore, is not an optimal solution to either or . ∎
From Lemma 10, we can obtain the following two equivalent representations of and : let be the number of edges of size that intersect the focal edge at vertices, we have
s.t. | ||||
s.t. | ||||
Claim 4.
The function
is increasing in for .
Proof.
Taking the derivative of , we get
(19) |
The first term on the RHS of Eq.(19) is non-positive: and because and . We now show that the second term is non-positive as well. Denote the second term by , i.e.,
Our plan is to first show that is decreasing in , and therefore it is maximized at . We then show that , and thus conclude that for all .
Taking derivative of , we get
Because and , we have . Thus, . Furthermore, because . We can thus conclude that for all , or equivalently, is decreasing on .
We now show .
where the last inequality follows from the fact that for all : we can set . ∎
Lemma 11.
For , an optimal solution to the math program is
Proof.
For ease of notation, we use instead of in the proof. Consider another solution such that . If for all , , then is not optimal: neither constraint is tight; thus one could always increase some to decrease the objective value. Therefore, without loss of generality, we can assume that there exists an index , . Let be the biggest such index. For , consider the following alternative solution:
It can be easily checked that is still feasible for small enough . Let (resp. ) be the objective function value with respect to solution (resp. ). When , we have
where the last inequality follows from Claim 4. We have thus shown that if .
We now show that if . When , we have
because . ∎
Lemma 12.
For , we have
Proof.
For ease of notation, we use instead of in the proof. From Lemma 11, we have that
(20) |
Specifically when , we have
where the second equality follows because for , we have .
We therefore have
(21) |
From Eqs.(20) and (21), we have that to show the desired inequality, we can equivalently show
-
1.
-
2.
We first show
Since , we equivalently want to show
which, after canceling common terms and rearranging clearly holds.
We then show
Again, because , we equivalently need to show
Equivalently
Dividing both sides by , we get equivalently
which holds for because and .
∎
Lemma 13.
Let , then we have
Proof.
For ease of notation, we use instead of in the proof. Let be a feasible solution to . It is sufficient to show that
We show, more generally that for and
If , the inequality is trivially true. So we assume that , which implies for . We first show that for a positive integer and we have
To see this, we consider the function over . The derivative of is for . is therefore increasing and since , we get that for . Therefore, for
By taking the product we get that
(22) |
Claim 5.
For and , we have
Proof.
We prove the claim in three steps.
-
1.
for .
To see this, we analyze the derivative of
We get
When , we have , and therefore when .
-
2.
for
To see this, consider the function over the interval . We have
Since is increasing and , we have that for . Therefore, is decreasing over . Since , this implies that for .
-
3.
for .
To see this, we use the following sequence of equivalences
The last inequality is true for
∎
Lemma 14.
The optimal solution of is given by
(24) |
Proof.
For ease of notation, we use instead of in the proof. Suppose to the contrary that there exists an optimal solution such that . There must exist such that : neither constraint is tight if for all , ; thus one could always increase some to increase the objective value. Let be the biggest index below such that . For , consider the following alternative solution:
It can be easily checked that is still feasible for small enough . When , the net increase in objective value from to is
(25) |
Now consider the following function
We claim that is strictly increasing when : taking the derivative of , we get
where the inequality follows from the fact that for all and .
Therefore, we have that , which translates to
(26) |
By rearranging Eq.(26), we can conclude that the net increase given in (25) is strictly positive, thus contradicting the assumption that is an optimal solution.
Now consider the case where . The net increase in objective value from to is
(27) |
which is clearly strictly positive if , contradicting the assumption that is an optimal solution. ∎
Lemma 15.
Assume . When and , we have
B.2 Proof of Theorem 8
See 8
Proof.
To show that Algorithm 5 returns the hypergraph with high probability, we will show the following:
-
1.
With high probability, for every edge, there exists at least one sample that contains that edge and no other edges.
-
2.
If a sample contains more than one edge, we will learn at most the intersection of the edges, and this intersection will be discarded in the last for-loop of the algorithm
The second point above is easy to see: if a sample contains more than one edge, then if and only if is in the intersection of all edges contained in . If we can successfully learn any edge in from another sample that contains only that edge, then the intersection learned through sample will be discarded as it is a subset of the edge learned using .
For the rest of the proof, we focus on showing the first point. To reiterate, we want to show that every edge of appears in at least one sample by itself. Below, we show that it is the case with probability .
We first show that with high probability, each edge of size is contained in at least sample ’s: use to denote the number of samples containing , then we have
By Chernoff bound, we have
As there are at most edges of size , by a union bound, we have
Subsequently,
From now on we condition on the event that all edges whose size is between and are included in at least samples.
From Lemma 1, we have that for all ,
As each edge with size between and is contained in at least samples, we have that
By another union bound on all edges of size between and (at most of them), we have that
We can thus conclude that with probability at least , for all with size between and , there exists at least one sample that contains but no other remaining edges.
We now prove the query complexity of FindLowDegreeEdges. It is clear that FindLowDegreeEdges is non adaptive because all the queries can be made in parallel. Regarding query complexity, FindLowDegreeEdges constructs samples, and for each one of these samples, makes at most queries. Therefore FindLowDegreeEdges makes at most
queries in total. ∎
Appendix C Sequential and Parallel Runtime
The runtime of our proposed algorithms is not much worse than their query complexity. When running sequentially, FindEdgeAdaptive requires an additional time to do every set partition, FindDisjointEdges requires an additional time to construct a set of independently sampled vertices, and FindLowDegreeEdges requires an additive time to execute the last for loop that consolidates the candidate edge sets. We summarize both the sequential and parallel runtimes for each algorithm in Table 1 below which we will include in the next version of the paper. We assume that each query can be made in time, and for the parallel runtime analysis, we assume access to polynomially many parallel processors. Some of our algorithm use a subroutine that can either be FindEdgeParallel or FindEdgeAdaptive. We will use PRL and ADA to refer to these subroutines respectively.
Algorithm |
Query
Complexity |
Sequential
Runtime |
Parallel
Runtime |
---|---|---|---|
|
|||
|
|||
* | |||
FindLowDegreeEdges |
|
|