Group testing refers to the situation in which one is given a set of objects ${\cal O}$, an unknown subset ${\cal P}\subseteq {\cal O}$, and the task of determining ${\cal P}$ by asking queries of the type "does ${\cal P}$ intersect $\cal Q$?," where $\cal Q$ is a subset of ${\cal O}$ Group testing is a basic search paradigm that occurs in a variety of situations such as quality control testing, searching in storage systems, multiple access communications, and data compression, among others Group testing procedures have been recently applied in computational molecular biology, where they are used for screening libraries of clones with hybridization probes and sequencing by hybridization
Motivated by particular features of group testing algorithms used in biological screening, we study the efficiency of two-stage group testing procedures Our main result is the first optimal two-stage algorithm that uses a number of tests of the same order as the information-theoretic lower bound on the problem We also provide efficient algorithms for the case in which there is a Bernoulli probability distribution on the possible sets ${\cal P}$, and an optimal algorithm for the case in which the outcome of tests may be unreliable because of the presence of "inhibitory" items in ${\cal O}$ Our results depend on a combinatorial structure introduced in this paper We believe that it will prove useful in other contexts, too

Optimal Two-Stage Algorithms for Group Testing Problems

We introduce a natural generalization of the well-studied group testing problem: A test gives a positive (negative) answer if the pool contains at least u (at most l) positive elements, and an arbitrary answer if the number of positive elements is between these fixed thresholds l and u. We show that the p positive elements can be determined up to a constant number of misclassifications, bounded by the gap between the thresholds. This is in a sense the best possible result. Then we study the number of tests needed to achieve this goal if n elements are given. If the gap is zero, the complexity is, similarly to classical group testing, O(plogn) for any fixed u. For the general case we propose a two-phase strategy consisting of a Distill and a Compress phase. We obtain some tradeoffs between classification accuracy and the number of tests.

/pdf/threshold-group-testing-39jias8gfl.pdf

Threshold group testing

Threshold Group Testing

We consider the problem of learning a hypergraph using edge-detecting queries. In this model, the learner may query whether a set of vertices induces an edge of the hidden hypergraph or not. We show that an r-uniform hypergraph with m edges and n vertices is learnable with O(24rm · poly(r,logn)) queries with high probability. The queries can be made in O(min(2r (log m+r)2, (log m+r)3)) rounds. We also give an algorithm that learns an almost uniform hypergraph of dimension r using O(2O((1+Δ/2)r) · m1+Δ/2 · poly(log n)) queries with high probability, where Δ is the difference between the maximum and the minimum edge sizes. This upper bound matches our lower bound of Ω((m/(1+Δ/2))1+Δ/2) for this class of hypergraphs in terms of dependence on m. The queries can also be made in O((1+Δ) · min(2r (log m+r)2, (log m+r)3)) rounds.

/pdf/learning-a-hidden-hypergraph-lue1zk755e.pdf

Learning a Hidden Hypergraph

We consider the problem of learning a hypergraph using edge-detecting queries. In this model, the learner may query whether a set of vertices induces an edge of the hidden hypergraph or not. We show that an r-uniform hypergraph with m edges and n vertices is learnable with O(2$^{\rm 4{\it r}}$m · poly(r,log n)) queries with high probability. The queries can be made in O(min(2rr2 log2n, r3 log3n)) rounds. We also give an algorithm that learns a non-uniform hypergraph whose minimum edge size is r1 and maximum edge size is r2 using $O(f_{1}(r_{1},r_{2})\cdot m^{(r_{2}-r_{1}+2)/2} \cdot poly(log n))$ queries with high probability, and give a lower bound of $\Omega(f_{2}(r_{1},r_{2})\cdot m^{(r_{2}-r_{1}+2)/2})$ for this class of hypergraphs, where f1 and f2 are functions depending only on r1 and r2. The queries can also be made in $O(min(2^{r2}r^{2}_{2}log^{2} n,r^{3}_{2}log^{3}n))$ rounds.

/pdf/learning-a-hidden-hypergraph-yyd7ipgvry.pdf

Learning a hidden hypergraph

We study the complexity of learning arbitrary Boolean functions of n variables by membership queries, if at most r variables are relevant. Problems of this type have important applications in fault searching, e.g. logical circuit testing and generalized group testing. Previous literature concentrates on special classes of such Boolean functions and considers only adaptive strategies. First we give a straightforward adaptive algorithm using O(r2r log n) queries, but actually, most queries are asked nonadaptively. This leads to the problem of purely nonadaptive learning. We give a graph-theoretic characterization of nonadaptive learning families, called r-wise bipartite connected families. By the probabilistic method we show the existence of such families of size O(r2r log n + r22r). This implies that nonadaptive attribute-efficient learning is not essentially more expensive than adaptive learning. We also sketch an explicit pseudopolynomial construction, though with a slightly worse bound. It uses the common derandomization technique of small-biased k-independent sample spaces. For the special case r = 2, we get roughly 2.275 log n adaptive queries, which is fairly close to the obvious lower bound of 2 log n. For the class of monotone functions, we prove that the optimal query number O(2r + r log n) can be already achieved in O(r) stages. On the other hand, Ω(2r log n) is a lower bound on nonadaptive queries.

/pdf/adaptive-versus-nonadaptive-attribute-efficient-learning-56rhci6z0j.pdf

Adaptive versus nonadaptive attribute-efficient learning

We study the complexity of learning arbitrary Boolean functions of n variables by membership queries, if at most r variables are relevant. Problems of this type have important applications in fault searching, e.g. logical circuit testing and generalized group testing. Previous literature concentrates on special classes of such Boolean functions and considers only adaptive strategies. First we give a straightforward adaptive algorithm using O(r2r log n) queries, but actually, most queries are asked nonadaptively. This leads to the problem of purely nonadaptive learning. We give a graph-theoretic characterization of nonadaptive learning families, called r-wise bipartite connected families. By the probabilistic method we show the existence of such families of size O(r2r log n + r22r). This implies that nonadaptive attribute-efficient learning is not essentially more expensive than adaptive learning. We also sketch an explicit pseudopolynomial construction, though with a slightly worse bound. It uses the common derandomization technique of small-biased k-independent sample spaces. For the special case r e 2, we get roughly 2.275 log n adaptive queries, which is fairly close to the obvious lower bound of 2 log n. For the class of monotone functions, we prove that the optimal query number O(2r + r log n) can be already achieved in O(r) stages. On the other hand, Ω(2r log n) is a lower bound on nonadaptive queries.

/pdf/adaptive-versus-nonadaptive-attribute-efficient-learning-4f6pcumypn.pdf

Adaptive Versus Nonadaptive Attribute-Efficient Learning

Programmable logic arrays (PLA) are highly regular circuits which compute suitable Boolean functions. PLAs are a popular circuit design especially in microcontrollers. PLA folding is a technique for minimizing the area of such PLA. Folding can be formulated in purely graph-theoretic terms. In this paper, we study PLA for a very special class of Boolean functions, namely indicator functions of intervals of binary numbers. As a possible application, we can imagine PLA which shall supervise that an input value lies in a prescribed tolerance interval. From a mathematical point of view, the connection of these interval indicator functions with threshold graphs and cographs is interesting. Our study naturally leads to the folding problem in cographs which is shown to be solvable in linear time. In sections 1-2 we introduce the basic notions. In section 3 we prove a theorem on minimal normal forms of interval indicator functions, thereby motivating the folding problem on cographs. A linear time algorithm solving this problem is derived in section 4. Finally, in section 5, we mention some related results and possible directions of further research.

Peter Damaschke

Papers

Adaptive versus nonadaptive attribute-efficient learning

Adaptive Versus Nonadaptive Attribute-Efficient Learning

Logic Arrays for Interval Indicator Functions