9 research outputs found
GROTESQUE: Noisy Group Testing (Quick and Efficient)
Group-testing refers to the problem of identifying (with high probability) a
(small) subset of defectives from a (large) set of items via a "small"
number of "pooled" tests. For ease of presentation in this work we focus on the
regime when D = \cO{N^{1-\gap}} for some \gap > 0. The tests may be
noiseless or noisy, and the testing procedure may be adaptive (the pool
defining a test may depend on the outcome of a previous test), or non-adaptive
(each test is performed independent of the outcome of other tests). A rich body
of literature demonstrates that tests are
information-theoretically necessary and sufficient for the group-testing
problem, and provides algorithms that achieve this performance. However, it is
only recently that reconstruction algorithms with computational complexity that
is sub-linear in have started being investigated (recent work by
\cite{GurI:04,IndN:10, NgoP:11} gave some of the first such algorithms). In the
scenario with adaptive tests with noisy outcomes, we present the first scheme
that is simultaneously order-optimal (up to small constant factors) in both the
number of tests and the decoding complexity (\cO{D\log(N)} in both the
performance metrics). The total number of stages of our adaptive algorithm is
"small" (\cO{\log(D)}). Similarly, in the scenario with non-adaptive tests
with noisy outcomes, we present the first scheme that is simultaneously
near-optimal in both the number of tests and the decoding complexity (via an
algorithm that requires \cO{D\log(D)\log(N)} tests and has a decoding
complexity of {}. Finally, we present an
adaptive algorithm that only requires 2 stages, and for which both the number
of tests and the decoding complexity scale as {}. For all three settings the probability of error of our
algorithms scales as \cO{1/(poly(D)}.Comment: 26 pages, 5 figure
Engineering Competitive and Query-Optimal Minimal-Adaptive Randomized Group Testing Strategies
Suppose that given is a collection of elements where of them are \emph{defective}. We can query an arbitrarily chosen subset of elements which returns Yes if the subset contains at least one defective and No if the subset is free of defectives. The problem of group testing is to identify the defectives with a minimum number of such queries. By the information-theoretic lower bound at least queries are needed. Using adaptive group testing, i.e., asking one query at a time, the lower bound can be easily achieved. However, strategies are preferred that work in a fixed small number of stages, where queries in a stage are asked in parallel. A group testing strategy is called \emph{competitive} if it works for completely unknown and requires only queries. Usually competitive group testing is based on sequential queries. We have shown that actually competitive group testing with expected queries is possible in only or stages. Then we have focused on minimizing the hidden constant factor in the query number and proposed a systematic approach for this purpose. Another main result is related to the design of query-optimal and minimal-adaptive strategies. We have shown that a -stage randomized strategy with prescribed success probability can asymptotically achieve the information-theoretic lower bound for and growing much slower than . Similarly, we can approach the entropy lower bound in stages when
Constraining the Number of Positive Responses in Adaptive, Non-Adaptive, and Two-Stage Group Testing
Group testing is a well known search problem that consists in detecting the
defective members of a set of objects O by performing tests on properly chosen
subsets (pools) of the given set O. In classical group testing the goal is to
find all defectives by using as few tests as possible. We consider a variant of
classical group testing in which one is concerned not only with minimizing the
total number of tests but aims also at reducing the number of tests involving
defective elements. The rationale behind this search model is that in many
practical applications the devices used for the tests are subject to
deterioration due to exposure to or interaction with the defective elements. In
this paper we consider adaptive, non-adaptive and two-stage group testing. For
all three considered scenarios, we derive upper and lower bounds on the number
of "yes" responses that must be admitted by any strategy performing at most a
certain number t of tests. In particular, for the adaptive case we provide an
algorithm that uses a number of "yes" responses that exceeds the given lower
bound by a small constant. Interestingly, this bound can be asymptotically
attained also by our two-stage algorithm, which is a phenomenon analogous to
the one occurring in classical group testing. For the non-adaptive scenario we
give almost matching upper and lower bounds on the number of "yes" responses.
In particular, we give two constructions both achieving the same asymptotic
bound. An interesting feature of one of these constructions is that it is an
explicit construction. The bounds for the non-adaptive and the two-stage cases
follow from the bounds on the optimal sizes of new variants of d-cover free
families and (p,d)-cover free families introduced in this paper, which we
believe may be of interest also in other contexts
New Constructions for Competitive and Minimal-Adaptive Group Testing
Group testing (GT) was originally proposed during the World War II in an attempt to minimize the \emph{cost} and \emph{waiting time} in performing identical blood tests of the soldiers for a low-prevalence disease.
Formally, the GT problem asks to find \emph{defective} elements out of elements by querying subsets (pools) for the presence of defectives.
By the information-theoretic lower bound, essentially queries are needed in the worst-case.
An \emph{adaptive} strategy proceeds sequentially by performing one query at a time, and it can achieve the lower bound. In various applications, nothing is known about beforehand and a strategy for this scenario is called \emph{competitive}. Such strategies are usually adaptive and achieve query optimality within a constant factor called the \emph{competitive ratio}.
In many applications, queries are time-consuming. Therefore, \emph{minimal-adaptive} strategies which run in a small number of stages of parallel
queries are favorable.
This work is mainly devoted to the design of minimal-adaptive strategies combined with other demands of both theoretical and practical interest. First we target unknown and show that actually competitive GT is possible in as few as stages only.
The main ingredient is our randomized estimate of a previously unknown using nonadaptive queries.
In addition, we have developed a systematic approach to obtain optimal competitive ratios for our strategies.
When is a known upper bound,
we propose randomized GT strategies which asymptotically achieve query optimality in just , or stages depending upon the growth of versus .
Inspired by application settings, such as at American Red Cross, where in most cases GT is applied to small instances, \textit{e.g.}, . We extended our study of query-optimal GT strategies to solve a given problem instance with fixed values , and . We also considered the situation when
elements to test cannot be divided physically (electronic devices), thus the pools must be disjoint. For GT with \emph{disjoint} simultaneous pools, we show that tests are sufficient, and also necessary for certain ranges of the parameters
Randomized group testing both query-optimal and minimal adaptive
The classical group testing problem asks to determine at most d defective elements in a set of n elements, by queries to subsets that return Yes if the subset contains some defective, and No if the subset is free of defectives. By the entropy lower bound, d log n tests are needed at least. We devise group testing strategies that combine two features: They achieve this optimal query bound asymptotically, with a factor 1+o(1) as n grows, and they work in a fixed number of stages of parallel queries. Our strategies are randomized and have a controlled failure probability, i.e., constant but arbitrarily small. We consider different settings (known or unknown d, probably correct or verified outcome), and we aim at the smallest possible number of stages. In particular, 2 stages are sufficient if d grows slowly enough with n, and 4 stages are sufficient if d=o(n)