Scalable and Efficient Non-adaptive Deterministic Group Testing
Abstract
Group Testing (GT) is about learning a (hidden) subset K , of size k , of some large domain N , of size n ≫ k , using a sequence of queries.
A result of a query provides some information about the intersection of the query with the unknown set
K .
The goal is to design efficient (polynomial time) and scalable (polylogarithmic number of queries per element in K ) algorithms for constructing queries that allow to decode every hidden set K based on the results of the queries.
A vast majority of the previous work focused on randomized algorithms minimizing the number of queries; however, in case of large domains N , randomization may result in a significant deviation from the expected precision of learning the set K .
Others assumed unlimited computational power (existential results) or adaptiveness of queries (next query could be constructed taking into account the results of the previous queries) – the former approach is less practical due to non-efficiency, and the latter has several drawbacks including non-parallelization.
To avoid all the abovementioned drawbacks, for Quantitative Group Testing (QGT) where query result is the size of its intersection with the hidden set, we present the first efficient and scalable non-adaptive deterministic algorithms for constructing queries and decoding a hidden set K from the results of the queries – these solutions do not use any randomization, adaptiveness or unlimited computational power.
Introduction
In the Group Testing (GT) field, the goal is to identify all elements of an unknown set K by asking queries.
Originally GT was applied to identifying infected individuals in large populations using pooled tests [26] which regained interest during COVID-19 pandemic [2, 52, 56].
Recently GT found applications in various areas of Machine Learning including approximating the nearest neighbor [28], simplifying multi-label classifiers [58] and accelerating forward pass of a deep neural network [51].
All we initially know about set K is that | K | ≤ k , for some known parameter k ≤ n , and that it is a subset of some much larger set N with | N | = n .
The answer to a query Q depends on the intersection between K and Q and equals to Result ( K ∩ Q ) , where Result is some result function (also called feedback function in this paper).
The sequence of queries is a correct solution to Group Testing if and only if for any two different sets
K 1 , K 2 (satisfying some cardinality restriction), the sequence of answers for K 1 and K 2 is different.
Note that although this allows to uniquely identify the hidden set K based on the results of the queries, in some cases decoding of set K could be a hard computational problem.
The objective is: for a given deterministic feedback function Result ( · ) , to find a fixed sequence of queries that will identify any set
K , and the length of this sequence, called the query complexity, is as short as possible.
In particular, we are interested in solutions that have query complexity logarithmic in n and polynomial in k .
[Table]
The most popular classical variant, present in the literature, considers function Result ( · ) that answers whether the intersection between K and Q is empty or not, c.f., [27]; it is also known under the name of beeping .
Another popular result function returns the intersection size; this variant has also been studied under the name of coin weighting [4, 24] and Quantitative Group Testing (QGT) [32, 29].
In this paper we study the problem of Group Testing under a more general capped quantitative result , where the result (feedback) is the size of the intersection up to some parameter α ∈ { 1 , . . .
, k } , and α for larger intersections.
It subsumes and generalizes the two previously described classical result functions: the smallest case of α = 1 corresponds to the classical empty/non-empty feedback (beeping), while the case α =
k captures the (full) quantitative feedback (classical QGT).
Motivation for our research is twofold: first, to better understand the intermediate settings between the two classical GT models; second, to find efficient solutions for the capped settings that could be applied to other problems (see the Appendix). Our focus is on non-adaptive deterministic solutions, in which queries are fixed (i.e., the same sequence applies to all hidden sets) and allow to discover (decode) any hidden set based on αcapped results.
The primary goal is to minimize the number of queries, called query complexity , and the second objective is to compute the queries and decode the hidden set in polynomial time.
All existing polynomial construction/decoding algorithms for beeping or quantitative feedbacks use Θ(min { n, k 2 log n } ) queries, c.f., [54].
General constructions developed in this work employ the concept of dispersion , c.f., [57], and combine it appropriately with other techniques.
When instantiated for a specific feedback parameter α ∈ { 1 , . .
. , k } , (e.g., α = √ k ), they shrink the gap between the upper and lower bounds on the number of efficiently constructed queries nearly exponentially: from linear to polylogarithmic gap per hidden element.
Together with our lower bound, they explain why sometimes a much smaller feedback is sufficient for decoding sets with similar efficiency.
We show that parameter α has also different interpretations – it inversely relates to the number of occurrences of an element in the queries and to fault-tolerance (c.f., Section 6).
1.1 Our Results
(see also Table 1)
We generalize the classical beeping and QGT models of Group Testing by considering an α -capped results , also called an α -capped feedback function, for an α ∈ { 1 , . . .
, k } : for a hidden set K and query
Q it returns F α ( Q ∩ K ) =
min {| Q ∩ K | , α } .
We study the query complexity of non-adaptive deterministic QGT in this general model.
We focus on scalable (polylogarithmic number of queries per element) and efficient (polynomial-time) constructing/decoding algorithms, and we show that it could be achieved if and only if the information cap α = (cid:101) Ω( √ k ) .
In particular, it holds for classical QGT.
Main result – Polynomial-time construction/decoding algorithms using almost optimal number of queries (Algorithms 1 and 2 in Section 4).
Here almost-optimality means that the length of the constructed query sequence is only polylogarithmically longer than the shortest possible sequence.
The previous best polynomial-time solution used Θ(min { n, k 2 log n } ) queries for all [-↵  
 [48],and-]α ≥ 1 [54], and we shrink it by factor Θ(min { α 2 , k } polylog − 1 n ) .
To achieve this goal, we define and build new types of selectors, called (Strong) Selectors under Interference (SSuI and SuI, for short) based on the concept of (superimposed) dispersion.
Although dispersion has been used before in GT, c.f., [10, 44], as well as the classical superimposed codes, our technical novelty is twofold: first, we identified additional properties of selectors (e.g., avoiding interfering set with capped intersections), that could not be formally deducted from the definitions of previous types of selectors, but allow to improve the solutions to QGT; second, we applied careful mathematical analysis to choose specific parameters of dispersers and superimposed codes and to prove that the new selectors’ properties hold.
We also generalize the concept of Round-Robin query systems, where each query is a singleton, to α -Round-Robin query systems, containing sets of size at most α .
Such sequences are shorter than the simple Round-Robin, i.e., have length O (( n/α ) polylog n ) , and, unlike a simple Round-Robin singletons’ structure, are challenging to construct in a way to allow correct decoding based on α -capped feedback.
Theorem 1.
There is an explicit polynomial-time algorithm constructing non-adaptive queries
Q 1 , . .
, Q m , for m =
O (cid:16) min (cid:110)(cid:0) kα (cid:1) 2 , nα (cid:111) polylog n + k polylog n (cid:17) , that solve Group Testing under feedback F α with polynomial-time decoding. Moreover, every element occurs in O ( kα polylog n ) queries, and the decoding time is O ( m + k 2 α polylog n + k polylog n ) . One of the consequences is that having the result function capped at α = √ k , we obtain similar number of queries as with the actual result (i.e., returning the size of the whole intersection, up to k ), which together with our next lower bound establishes an interesting inherited property of GT.
The value α = √ k seems to be a sweet spot balancing two different phenomena – superimposed coding and dispersion.
Enriching the beeping model (i.e., α increases starting from 1 ) allows to improve the superquadratic query complexity of classical superimposed coding (used for the beeping feedback), and the improvement is roughly quadratic in terms of α , due to the nature of superimposed codes.
On the other hand, limiting the full quantitative model (i.e., α decreases starting from k ) increases the number of queries, starting from slightly superlinear, roughly linearly in α , as the nature of dispersion is linear. Both these phenomena equalize query complexities at α = √ k .
This is illustrated in our construction – in the beginning, the progress in learning relies on dispersion-based SuI’s for small α , then with the growth of α the length of used SuIs becomes similar to the length of the code-based SSuI; it happens for α = √ k . The SSuI allows to discover all the remaining elements and finishes the learning process. The last fact explains why further increase of α is not needed.
Lower bound (Section 5).
The almost-optimality of our algorithms from Theorem 1 is justified by proving an absolute lower bound on the length of sequences allowing to decode a hidden set based on feedback F α to the queries.
Here by “absolute” we mean that it holds for all query systems that allow for decoding of the hidden sets based on feedback F α , not restricted to polynomially constructed queries with polynomial decoding algorithm.
Even more, some components of the lower bound are general: they hold for any α -capped feedback function, which will be formally defined later in
Section 3.
The lower bound has three components: ( k/α ) 2 , n/α , and k log nk log α .
For different ranges of k , different components determine the value of the lower bound.
Note that these components match the corresponding components in our constructive upper bound (Main result in Theorem 1), up to a polylogarithmic factor.
Theorem 2.
Any non-adaptive algorithm solving Group Testing needs:
• Ω (cid:16) min (cid:110) (cid:0) kα (cid:1) 2 , nα (cid:111) + k log n k log α (cid:17) queries under feedback F α .
• Ω (cid:16) min (cid:110)(cid:0) kα (cid:1) 2 , nα (cid:111)(cid:17) queries under any feedback capped at α .
Document structure.
We discuss related work on various variants of GT in Section 2.
In Sectionwe formally define the QGT problem and the generalized α -capped-results model.
In Section 4 we present our polynomial-time query construction and decoding algorithms.
Section 5 proves the lower bound.
Discussion of extensions, applications and future directions is given in Section 6.
Additional
Appendix contains more details: Appendix A discusses other related work; Appendix B shows details of extensions and applications; Our new selector tools are constructed and analyzed in Appendix C.
Previous and Related Work (see also Tables 1 and 2)
Group Testing with general feedback functions have been studied in [47], where two parameters of feedback functions (cap and expressiveness) are shown to influence the necessary number of queries. In the standard feedback model, considered in most of the Group Testing literature [27], the feedback tells whether the intersection between query Q and set K is empty or not (sometimes it is also α [Table] [Table]
randomized
[Table] called a beeping model ). It it is a special case F 1 of our feedback function.
In this feedback model,
Group Testing is known to be solvable using O ( k 2 log( n/k )) queries [21] and an explicit polynomialtime construction of length O ( k 2 log n ) exists [54].
Best known lower bound (for k < √ n ) is Ω( k 2 log n/ log k )
This model is also similar to Angluin’s notion of concept learning with disjointness queries [1]. The main differences are that in our model the learner is non-adaptive and that in the disjointness queries the feedback might include an element from the intersection.
The setting considered in this paper is also a generalization of an existing problem of coin weighting.
In this problem, we have a set of n coins of two distinct weights w 0 (true coin) and w 1 (counterfeit coin), out of which up to k are counterfeit ones.
We are allowed to weigh any subset of coins on a spring scale, hence we can deduce the number of counterfeit coins in each weighting.
The task is to identify all the counterfeit coins.
Such a feedback is a special case F k of our feedback function.
The problem is solvable with O ( k log( n/k ) / log k ) [37] non-adaptive (i.e., fixed in advance) queries and matching a standard information-theoretic lower bound of Ω( k log( n/k ) / log k ) , as well as its stronger version proved for randomized strategies [24].
[4] considers the problem of explicit polynomial-time construction of O ( k log( n/k ) / log k ) queries that allows for polynomial time identification of the counterfeit coins.
However, the algorithm presented in [4] is adaptive, which means that the subsequent queries can depend on the feedback from the previous ones.
The only existing, constructive, non-adaptive solution would be using the explicit construction of the superimposed codes [46] but the resulting query complexity would be O ( k 2 polylog n ) .
Thus, the solution in our paper is the first explicit polynomial time algorithm constructing non-adaptive queries allowing for fast decoding of set K , with O ( k polylog n ) fixed queries.
An important line of work on non-adaptive randomized solutions to Quantitative Group Testing, started by [55] and being continued until recently [32, 14, 29, 3], resulted in a number of algorithms nearing the lower bound of 2 k ln( n/k ) ln k from [25].
However, these results always assume some restriction on k (typically k ∼ n θ for some 0 < θ < 1 ), and similarly as above, they may result in significant deviation from the actual set if n is large.
They also require a large number of truly random bits (in practice, algorithms have access only to small truly random seeds, while randomized solutions typically have large number of Ω( n log n log k ) random bits to construct the queries) and typically do not offer any provable guarantees in case when an adaptive adversary could create/change the hidden set or introduce errors online during the learning process.
The bounds obtained in this paper match (up to polylogarithmic factors) the best existing results for the extreme cases of α = 1 and α = k .
The paper also bounds how the query complexity depends on the value of α between these extremes.
Interestingly we show, that the shortest-possible query complexity of k polylog n is already possible for α = √ k and increasing α from √ k to k does not result in further decrease of the query complexity.
Other interesting feedback function is a Threshold Group Testing [20, 23], where the feedback model includes a set of thresholds and the feedback function returns whether or not the size of the intersection is larger or smaller than each threshold.
In [22] the authors show that it is possible to define an interval of √ k log k thresholds resulting in an algorithm with O ( k log( n/k ) / log k ) queries.
Note that both those feedbacks are “inefficient” in view of our setting of α -capped feedbacks, because their feedback functions are not capped at any α < k , but they achieve similar query complexity as our capped F √ k feedback.
Superimposed codes and dispersers were already used in Group Testing.
However, they either led to a super-quadratic (in k ) number of queries, c.f., [46, 9], or decoded only a fraction of elements of the hidden set, see [44, 41].
Recall that in solutions where query complexity depends on the number of identified elements, decoding of all the elements requires over k 2 queries, as proved in [21, 10].
[45] presents the first Group Testing solution with poly ( k, log n ) decoding time, but super-quadratic query complexity.
It is worth noting that our generalized solution achieves almost-linear number of queries (for certain values of α ) and our decoding algorithm identifies all the elements in time polynomial in k and logarithmic in n .
Our use of the known tools is different then in previous approaches: we define new properties (SuI, SSuI), which we prove to be satisfied by some combinations of those tools, and lead to efficient solutions in both query complexity and construction/decoding time.
The Model and the Problem
We assume that the universe of all elements N , with | N | = n , is enumerated with integers 1 , 2 , . . . , n .
Throughout the paper, we will associate an element with its identifier.
Let K , with | K | ≤ k , denote a hidden subset of N chosen arbitrarily by an adversary.
Let Q = ⟨ Q 1 , . . .
, Q m ⟩ be a non-adaptive algorithm, represented by a sequence of m queries fixed prior to an execution. A general feedback function F is a function from subsets of N into an arbitrary domain.
A function is applied to K ∩ Q . A meaningful feedback function can range from simple empty/non-empty feedback up to returning all elements of the intersection. Consider a feedback function F α , that returns the size of an intersection if it is at most α and α for larger intersections, i.e., F α ( Q ∩ K )
= min {| Q ∩ K | , α } .
Parameter α in feedback
F α is called a feedback cap .
A general class of feedback functions (used in our lower bound) with feedback cap α includes all deterministic functions that take subsets of N as input and for sets with more than α elements output some arbitrary fixed value.
We say that Q solves Quantitative Group Testing (QGT), if the feedback vector allows for unique identification of set K .
The feedback vector is defined as ⟨F α ( Q 1 ∩ K ) , F α ( Q 2 ∩ K ) , . .
, F α ( Q t ∩ K ) ⟩ .
Thus, in order to solve QGT, the feedback vectors for any two sets K 1 and K 2 have to be different.
We say that Q solves QGT with polynomial-time reconstruction if there exists a polynomialtime algorithm that, given the feedback vector outputs all the identifiers of the elements from K .
Finally we say that Q is constructible in polynomial time if there exists a polynomial-time algorithm, that given parameters n, k, α outputs an appropriate sequence of queries.
We assume that both coupled algorithms, construction and decoding, know n, k, F α .
W.l.o.g. , in order to avoid rounding in the presentation, we assume that n and other crucial parameters are powers of 2 .
Polynomial-time Constructions and Decoding 4.1 Combinatorial Tools
In this section we introduce two new combinatorial tools (Selectors-under-Interference and StrongSelectors-under-Interference) for our QGT solutions, and recall Dispersers and Balanced IDs.
For given sets K 1 , K 2 ⊆ N and an element v ∈ K 1 , we say that S ⊆ N selects v from K 1 under α -interference from K 2 if S ∩ K 1 = { v } and | S ∩ K 2 | < α .
Intuitively, v is a unique representative of K 1 in S and the number of representatives of K 2 in S is smaller than α .
Definition 1 (Selector under Interference (SuI)) .
An ( n, ℓ, ϵ, κ, α ) -Selector-under-Interference, ( n, ℓ, ϵ, κ, α ) -SuI for short, is a sequence of queries S =
( S 1 , . . .
, S x ) satisfying: for every set
K 1 ⊆ N of at most ℓ elements and set K 2 ⊆ N of at most κ elements, there are at most ϵℓ elements v ∈ K 1 that are not selected from K 1 under α -interference from K 2 by any query S i ∈ S , i.e., set { v ∈ K 1 : ∀ i ≤ x S i ∩ K 1 [-
-]̸
= { v } or | S i ∩ K 2 | ≥ α } has less than ϵℓ elements.
Disperser.
Consider a bipartite graph G =
( V, W, E ) , where | V | = n , which is an ( ℓ ∗ = ϵℓ, d, ϵ ) - disperser with entropy loss δ , i.e., it has left-degree d , | W | =
ℓd/δ , and satisfies the following dispersion condition: for each L ⊆ V such that | L | ≥ ℓ ∗ , the set N G ( L ) of neighbors of L in graph G is of size at least (1 − ϵ ) | W | .
Note that it is enough for us to take as ϵ in the dispersion property the same value as in the constructed ( n, ℓ, ϵ, κ, α ) -SuI S .
An explicit construction (i.e., in time polynomial in n ) of dispersers was given by [57], for any n ≥ ℓ , and some δ =
O (log 3 n ) , where d = O ( polylog n ) .
In the following the notation d and δ will always denote the parameters of the disperser.
Note that any improved construction of dispersers will immediately reduce the complexities of our algorithms.
In Appendix C.1 we will describe two disperser-based polynomialtime constructions of SuI and prove:
Theorem 3.
There is an explicit polynomial-time construction of an ( n, ℓ, ϵ, κ, α ) -SuI, for any ℓ , any α ≤ k such that ℓα/ (3 δ ) > κ , for any constant ϵ ∈ (0 , 1 / 3) , of size O (min (cid:8) n, ℓdδ log 2 n (cid:9) ) .
Moreover, every element occurs in O ( dδ log n ) queries.
Theorem 4.
There is an explicit polynomial-time construction of an ( n, ℓ, ϵ, κ, α ) -SuI, for any ℓ , any α ≤ k such that ℓ ≤ 3 δκ/α for any constant ϵ ∈ (0 , 1 / 3) , of size O (cid:0) min (cid:8) n, κdδα log 2 n (cid:9) + ndδα log n (cid:1) .
Moreover, every element occurs in O ( dδ log n ) queries.
Definition 2 (Strong Selector under Interference (SSuI)) .
An ( n, ℓ, κ, α ) -Strong-Selector-underInterference, ( n, ℓ, κ, α ) -SSuI for short, is a sequence of queries T =
( T 1 , . . .
, T x ) satisfying: for every set K 1 ⊆ N of at most ℓ elements and set K 2 ⊆ N of at most κ elements, every element v ∈ K 1 is selected from K 1 under α -interference from K 2 by some query T i ∈ T , i.e., set { v ∈ K 1 : ∀ i ≤ x T i ∩ K 1 [-
-]̸
= { v } or | T i ∩ K 2 | ≥ α } is empty.
An ( n, ℓ, κ, α ) -Strong-Selector-under-Interference could be also viewed as ( n, ℓ, 0 , κ, α ) -Selectorunder-Interference.
In Appendix C.2 we describe a polynomial-time construction of SSuI, which essentially is a [46] construction for adjusted parameters, and prove that it satisfies the SSuI property.
Theorem 5.
There is an explicit polynomial-time construction of an ( n, ℓ, κ, α ) -SSuI of length
O ( ℓ 2 log 2 ℓ n ) , provided ℓ ≥ 3 δκ/α .
Moreover, every element occurs in O ( ℓ log ℓ n ) queries.
Balanced IDs.
Each element i in N has a unique ID represented by 2 log 2 n bits, in which the number of 1’s is the same as the number of 0’s; e.g., take a binary representations of elements i and n − i , each in log 2 n bits, and concatenate them (recall n = | N | ).
Balanced IDs have previously been used in algorithms for decoding elements in Group Testing (see e.g., [50]).
4.2 Construction of Queries, Decoding and Analysis (Proof of Theorem 1)
Algorithm constructing queries.
Assume α ≥ 2 and k > 3 δk/ ( α − 1) (the opposite case will be considered later) and let us take ( n, ℓ, 1 / 2 , k, α − 1) -SuI S ( ℓ ) , for ℓ being a power of 2 ranging down from k to 3 δk/ ( α − 1) (w.l.o.g. we could also assume that 3 δk/ ( α − 1) is a power of 2 ).
Next, for each set S in these selectors we add the following family R ( S ) =
{ R i ( S ) } 2log 2 n i = of sets
R i ( S ) = { v ∈ S :
⌊ v/ 2 i − 1 ⌋ = 1 mod 2 } .
Intuitively R i ( S ) is the set of elements from S that have 1 on i -th least significant bit of Balanced ID.
Let us call the obtained enhanced selectors (i.e., with additional families R ( S ) , for every set S in the original selector) ¯ S ( ℓ ) .
Then we concatenate selectors R ( S ( ℓ ) ) , starting from the largest ℓ = k , to the smallest value ℓ = 3 δk/ ( α − 1) .
An ( n, 3 δk/ ( α − 1) , k, α − 1) -SSuI T is concatenated at the end, with the same replacement of bits 1 and 0 that gives R ( T ) as in the above ( n, ℓ, 1 / 2 , k, α − 1)
-SuI’s.
In the case, where α = 1 or k ≤ 3 δk/ ( α − 1) then the sequence equals to ( n, k, k, α ) -SSuI T concatenated as in the above with
R ( T ) .
Algorithm 1 presents a pseudocode of the construction algorithm for α > 1 .
set of elements from S that have 1 on i -th least significant bit of Balanced ID
[Figure]
simplicity we assume
Decoding algorithm.
During the decoding algorithm we process, in subsequent iterations, the feedbacks from enhanced selectors ¯ S ( ℓ ) for ℓ = k, k/ 2 , k/ 4 , . .
3 δk/ ( α − 1) .
We will later prove, by induction, that during processing ¯ S ( ℓ ) , ℓ/ 2 new elements from K are decoded.
To show this, we consider any iteration and let set K 1 be the set of the elements that have been decoded in previous iterations while set K 2 =
K \ K 1 be the set of unknown elements.
We treat K 1 as the interfering set and, by the properties of S ( ℓ ) , we know that for at least ℓ/ 2 elements v , there exists a query
S ∈ S ( ℓ ) , such that v ∈ S , | K 1 ∩ S | < α − 1 , | K 2 ∩ S | = 1 .
We observe that since we already know the identifiers of all the elements from the interfering set K 1 , then using feedbacks from the additional queries R ( S ) (corresponding to balanced IDs) we can exactly decode the identifier of v .
We do this for all ℓ/ 2 elements that are possible to decode in this iteration and we proceed to the next iteration.
After considering all Selectors-under-Interference, we have only at most 3 δk/ ( α − 1) unknown elements.
To complete the decoding we use a Strong-Selector-under-Interference, where the decoding procedure is exactly the same as in the case of SuI (the interfering set is also the set of already decoded elements).
The properties of SSuI guarantee that we decode the identifiers of all the remaining elements from K .
See the pseudocode of decoding Algorithm 2 for details of deocding for α > 1 .
In the case where α = 1 the decoding is straightforward, as the SSuI guarantees in this case no interference, hence the results (due to our enhancement ¯ T ) contain exactly the identifiers of the elements from set K .
Lemma 1.
There is an explicit polynomial-time algorithm constructing non-adaptive queries
Q 1 , . .
Q m and decoding any hidden set K of size at most k ≤ n , from the feedback vector in polynomial time, under feedback F α and for m =
O (( kα ) 2 δ 2 log 3 n + kdδ log 3 n ) queries.
Moreover, every element occurs in O ( kα δ log 2 n + dδ log 3 n ) queries.
Proof.
We start from describing a procedure of revealing elements in any given set K of at most k elements, together with a formal (inductive) argument of its correctness.
Our first goal is to show that by the beginning of ¯ S ( ℓ ) , for ℓ stepping down from k to 3 δk/ ( α − 1) , we have not learned about the identity of at most ℓ elements from the hidden set K .
The proof is by induction – it clearly holds in the beginning of the computation, as the set K has at most ℓ = k elements.
We prove the inductive step: by the end of ¯ S ( ℓ ) , at most ℓ/ 2 elements are not learned.
We set K 2 to be the set of learned elements and K 1 =
K \ K 2 .
Clearly, | K 2 | ≤ k , and by the inductive assumption | K 1 | ≤ ℓ ≤ k .
For such K 1 and K 2 , by the definition of SuI, there are at most ℓ/ 2 elements from K 1 that are not occurring in some round without other such elements or with at least α − 1 of already learned elements from K 2 .
Consider a previously not learned element v ∈ K 1 , for which there exists a good query in ¯ S ( ℓ ) , i.e., a query S ∈ ¯ S ( ℓ ) such that S ∩ K 1 = { v } and | S ∩ K 2 | < α − 1 .
At this point of decoding of set K we know the Balanced IDs of all elements from set K 2 .
Hence we can calculate the 2 log 2 n -bit feedback vector from sets K 2 ∩ R 1 ( S ) , K 2 ∩ R 2 ( S ) , . .
, K 2 ∩ R 2log 2 n ( S ) .
We compare this feedback vector with the output of the enhanced selector, which is the feedback vector for sets K ∩ R 1 ( S ) , K ∩
R 2 ( S ) , . .
, K ∩ R 2log 2 n ( S ) .
The difference between the latter and the former is exactly the Balanced
ID of v .
In case this difference does not form a Balanced ID of any element, i.e., it has some value bigger than 1 or otherwise the number of 1’s is different from log 2 n , or in case F α ( K ∩ S ) =
α (recall that S is also in the constructed selector) the feedback from this R ( S ) is ignored.
This is done to avoid misinterpreting the feedback and false discovery of an element which is not in K .
Indeed, first note that the fact | K ∩ S | ≥ α will automatically discard the part of the feedback from K ∩ R 1 ( S ) , K ∩ R 2 ( S ) , . . .
, K ∩ R 2log 2 n ( S ) , as it indicates that the intersection is too large to provide correct decoding of an element.
Second, assuming | K ∩ S | < α , if there are no elements do Calculate the feedback from set R j ( Q ) , if hidden set was exactly K acc . The difference is j -th least significant bit of Balanced ID of new element v . */ v ← v
Result j
Q
− | R j
Q
∩ K acc
return v in K 1 ∩ S then the difference between feedbacks gives vector of zeros, and if there will be at least two elements in K 1 ∩ S , the difference between feedbacks will contain a value of at least 2 or all 1’s, as it will be a bitwise sum of at least two Balanced IDs of log 2 n ones each.
By the definition of
SuI we can find l/ 2 such elements v .
This shows that during decoding of enhanced ¯ S ( ℓ ) we learn the identities of ℓ/ 2 new elements.
This completes the inductive proof.
Note here that the inductive step, being one of O (log n ) steps, defines a polynomial time algorithm decoding some elements one-by-one – indeed, it computes two feedbacks of polynomial number of queries, computes the difference and deducts based on the structure of subsequent blocks of O (log n ) size.
The above analysis implies, that before applying ( n, 3 δk/ ( α − 1) , k, α − 1) -SSuI we have not discovered at most 3 δk/ ( α − 1) elements.
Thus, by definition, ( n, 3 δk/ ( α − 1) , k, α − 1) -SSuI combined with Balanced IDs reveals all the remaining elements in the same way as the SuI’s above – the only difference in the argument is that instead of leaving at most ℓ/ 2 undiscovered elements in the ℓ -th inductive step, due to the nature of SuI’s, the SSuI guarantees that every undiscovered element will occur in a good query.
The same argument as for SuI’s proves that the decoding algorithm defined this way works in polynomial time.
By Theorem 3, the length of ( n, ℓ, 1 / 2 , k, α ) -SuI is O
(min (cid:8) n, ℓdδ log 2 n (cid:9) ) , which sums up to O ( kdδ log 2 n ) , and is multiplied by Θ(log n ) due to amplification by Balanced IDs.
By Theorem 5, the length of ( n, 3 δk/α, k, α ) -
SSuI is O
(( kα ) {+
 δ+} 2 log 2 n ) , and it is also increased by factor Θ(log n ) due to Balanced IDs.
If we apply the above reasoning with respect to the number of queries containing an element, we get that every element occurs in O ( kα δ log 2 n + dδ log 3 n ) queries.
Implementing α -Round-Robin for large values of k/α .
The question arises from the previous result if one could efficiently construct a shorter sequence of queries if ( k/α ) 2 > n/α ?
In the case of full feedback ( i.e., α = k ) the common way to deal with large values of k is via Round-Robin, which means that queries are singletons and consequently, the length of such query sequence is n .
This also works for an arbitrary value of α ≤ k , however the lower bound in Theorem 2 suggest that in such case there could exist a shorter query system of length O (( k + ( n/α )) polylog n ) .
Indeed, if we modify our construction in such case, we could obtain such a goal.
Namely, we concatenate:
• selectors ¯ S ( ℓ ) , for ℓ being decreasing powers of 2 from ℓ = k to ℓ = 6 δk/ ( α − 1) ; • selectors ¯ S| ( ℓ ) α , for ℓ being decreasing powers of 2 from ℓ = 3 δk/ ( α − 1) to ℓ = 1 .
In the case, where k > 6 δk/ ( α − 1) , then the construction contains only selectors ¯ S| ( ℓ ) α .
Then we enhance them based on Balanced IDs, as in the previous construction.
Then, applying Theoremfor concatenated ¯ S ( ℓ ) and Theorem 4 for concatenated ¯ S| ( ℓ ) α , instead of combination of Theoremsand 5 as it was in the proof of Lemma 1 with respect to ¯ S ( ℓ ) , we get the following result.
Lemma 2.
There is an explicit polynomial-time algorithm constructing non-adaptive queries
Q 1 , . .
Q m and decoding any hidden set K of size at most k ≤ n , from the feedback vector in polynomial time, under feedback F α and for m =
O (( k + n/α ) dδ log 3 n ) queries.
Moreover, each element occurs in O ( dδ log 3 n ) queries.
Proof.
The proof is analogous to the proof of Lemma 1, except that we continue proving the invariant until ℓ = 6 δκ/ ( α − 1) , using same properties guaranteed by Theorems 3, and continue the invariant until ℓ = 1 , using SuI’s of slightly different length formula from Theorem 4.
The correctness argument, as well as polynomial-time query construction and decoding of the elements, are the same as in the invariant proof in Lemma 1.
Then, by Theorem 3 for concatenated ¯ S ( ℓ ) and by Theorem 4 for concatenated ¯ S| ( ℓ ) α , we argue that the total length of the obtained sequence is m =
O (( k + n/α ) dδ log 3 n ) .
Indeed, the first part results from the telescoping sum for different ℓ and the second component is a logarithmic amplification of the original O (( ndδ/α ) log n ) length of SuI’s; all is amplified by O (log n ) due to enhancement of the used SuI’s by Balanced IDs.
In all the components, every element belongs to O ( dδ log n ) queries, by Theorems 3 and 4, in the final sequence it occurs in O ( dδ log 3 n ) queries.
Combining Lemma 1 with Lemma 2 gives Theorem 1.
Note that in both lemmas the decoding algorithm proceeds query-by-query, each time spending polylogarithmic time on each of them; additionally, for each decoded element, an update of the feedback of next queries needs to be done, which takes time proportional to the number of occurrences of the discovered element in the queries.
Thus, it is asymptotically upper bounded by the length of the sequence plus k times the upper bound on the number of occurrences of an element in the queries (polylogarithmic).
Lower Bound
Proof of Theorem 2.
We will first show the min { n/α, k 2 /α 2 } component.
Assume that a sequence of queries Q 1 , Q 2 , . . .
, Q t of length t solves Group Testing.
We want to show the lower bound that holds for any feedback function capped at α hence we assume that the feedback function F returns the whole set (i.e., the identifiers of all the elements).
Recall that F works only for sets with at most α elements.
We begin by proving the following:
Claim A: For any set K , with | K | ≤ k and any x ∈ K , there must exist τ ∈ { 1 , 2 , . . .
, t } , such that x ∈ Q τ and | K ∩ Q τ | ≤ α + 1 .
The proof is by contradiction.
Assume that such a set K ∗ and element x ∗ exist for which there is no such query.
Consider feedback vectors for sets K ∗ and K ∗ \ { x ∗ } .
For any query that does not contain x ∗ , the feedback is clearly identical.
For any query Q τ , such that x ∗ ∈ Q τ , we have | Q τ ∩ K ∗ | ≥ α +2 and | Q τ ∩ ( K ∗ \{ x ∗ } ) | ≥ α +1 and sets K ∗ and K ∗ \{ x ∗ } are indistinguishable under any feedback capped at α hence the sequence of queries does not solve the problem.
This completes the proof of Claim A. ■
Take all queries that have at most α + 1 elements and all elements that belong to such queries.
We have: N s = (cid:83) τ ∈{ 1 , 2 ,...,t }| Q τ |≤ α +1 Q τ and remaining elements N l = N \ N s .
Consider two cases:
Case 1 : | N s | ≥ n/ 2 .
Observe that: t ≥ |{ τ ∈ { 1 , 2 , . . .
, t } : | Q τ | ≤ α + 1 }| ≥ N s α +1 ≥ n 2( α +1) .
Case 2 : | N l | ≥ n/ 2 .
In this case, we take an arbitrary subset K 1 of k/ 2 elements from N l .
For every element x ∈ K 1 , we consider a set of queries Q ( x ) = { Q τ ∈ { Q 1 , Q 2 , . . .
, Q t } : x ∈ Q τ , | Q τ ∩ K 1 | ≤ α +1 } .
We show:
Claim B: For every x ∈ K 1 , we have | Q ( x ) | ≥ k 2( α +2) .
The proof is by contradiction.
Assume that for some x ∗ ∈ K 1 we have | Q ( x ∗ )
| < k 2( α +2) .
Then, for every query Q ∈ Q ( x ∗ ) , we take α + 2 − | Q ∩ K 1 | elements from Q \ K 1 .
Such elements exist since | Q | ≥ α + 2 .
Choose such elements for each query in Q ( x ∗ ) and gather them in set K 2 .
Note that since | Q ( x ∗ ) | < k 2( α +2) , then | K 2 | ≤ k/ 2 .
Now observe that set K 1 ∪ K 2 and element x ∗ violate Claim
A. The obtained contradiction completes the proof of Claim B. ■
Now observe that each query belongs to at most α + 1 sets Q ( x ) for different values of x ∈ K 1 .
Thus: t ≥ (cid:80) x ∈ K 1 | Q ( x ) | α + ≥ k 2 4( α +1)( α +2) .
To complete the proof observe that any algorithm must fall either into Case 1 or Case 2, hence any algorithm needs to use Ω (cid:0) min { n/α, k 2 /α 2 } (cid:1) queries.
To see that any algorithm in F α feedback model at least k log nk log α queries, observe that the feedback vector must be unique for each set K with at most k elements.
Hence we need at least (cid:0) nk (cid:1) different feedback vectors for different sets.
Feedback has at most α values hence we get α t ≥ (cid:0) nk (cid:1) and t ∈ Ω( k log nk log α ) .
This completes the proof of Theorem 2.
■
Extensions, Applications and Open Directions
Observations.
The size of response to a capped quantitative query is not much bigger than beeping – log α bits vs one bit of beeping – whereas the number of queries is smaller by a factor of α 2 compared to beeping.
Thus, even after normalization of the query complexity by the inverse of the size of the feedback, in the α -capped model it is nearly α 2 times better than the classic beeping, up to α = √ k . Although optimizing the construction time is not our main focus, it is actually small. E.g., for α = √ k , the construction of all queries takes time (cid:101) O ( n √ k ) . Most of the complexity comes from the construction of SSuI (Alg 4) – for each element of the universe, we consider (cid:101) O ( √ k ) zeros of some polynomial.
We use a logarithmic number of SuIs in the construction, but each takes only (cid:101) O ( n ) time (Alg 3): in SuI for every element we list its neighborhood in disperser in polylogarithmic time [57] and take the Cartesian product with a polylogarithmic Reed-Solomon type of codeword.
Fault-tolerance. Algorithms 1 and 2 are fault-tolerant with respect to f ≤ c · kα adversarially jammed results, for some sufficiently small constant c > 0 – here by a jammed result we understand receiving a null as a result of a query.
It also tolerates stochastic failures, where a result is jammed with probability p ≤ c .
Indeed, in adversarial failures we observe that, by dispersion, c · kα could be made negligible (by right selection of constant c ) with respect to the number of selected elements in
SuI, and it is also smaller than the number of single occurrences (i.e., without interference from other k − 1 elements) of an element in SSuI.
Thus the analysis of the algorithms hold (the original analysis have margins to accommodate those additional negligible jamming, as they were done with only asymptotic upper bounds).
The tolerance of stochastic failures follows from the fact that a random p -fraction of results of queries coming from SuI’s and SSuI are again negligible from perspective of the fraction of correctly encoded elements and can be accommodated by our asymptotic analysis.
Theorem 6.
Algorithms 1 and 2 tolerate f ≤ c · kα adversarial jammings and stochastic jammings with probability p ≤ c , for some sufficiently small constant c > 0 .
Other applications.
Applications to efficient GT and dynamic maintenance of multi-sets, graphs, as well as to Private Parallel Information Retrieval and coding, are detailed in Appendix B.
Open directions.
Considering only polynomially-constructible query systems leaves some interesting open directions.
One such direction is whether optimal-length query sequence can be constructed in polynomial time or perhaps it is possible to show some reduction that constructing a nearly-shortest query sequence is computationally hard (even if we know that it exists).
Shrinking polylogarithmic gaps between lower and (existential) upper bounds and improving constants is another challenging direction, as well as considering other interesting classes of GT models with an α -capped results, e.g., parity.
We also believe that with some adjustment, capped GT codes could be applied to efficiently solve many open problems in online streaming, communication and graph learning fields. Acknowledgments and Disclosure of Funding
Dominik Paj ˛ak was supported by the National Science Centre, Poland (NCN), grant UMO2019/33/B/ST6/02988.
Dariusz R. Kowalski was supported, in part, by the National Science Center,
Poland (NCN), grant UMO-2017/25/B/ST6/02010.
Checklist
The checklist follows the references.
Please read the checklist guidelines carefully for information on how to answer these questions.
For each question, change the default [TODO] to [Yes] , [No] or [N/A] .
You are strongly encouraged to include a justification to your answer , either by referencing the appropriate section of your paper or providing a brief inline description.
For example:
• Did you include the license to the code and datasets?
[Yes] See Section ?? .
• Did you include the license to the code and datasets?
[No] The code and the data are proprietary.
• Did you include the license to the code and datasets?
[N/A]
Please do not modify the questions and only use the provided macros for your answers.
Note that the
Checklist section does not count towards the page limit.
In your paper, please delete this instructions block and only keep the Checklist section heading above along with the questions/answers below.
For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?
[Yes] Our abstract and introduction states the theoretical results that are later proven in our paper.
(b) Did you describe the limitations of your work?
[Yes] Our assumed model (including the result function) is described in Section 3.
(c) Did you discuss any potential negative societal impacts of your work?
[Yes] Our result is theoretical hence does not have any direct negative impact.
Also none of the existing solutions to the Group Testing (which is a field with almost 80 years of history) were harmful to the society.
(d) Have you read the ethics review guidelines and ensured that your paper conforms to them?
[Yes] 2.
If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?
[Yes] The assumptions are given in a statement of each theoretical result.
(b) Did you include complete proofs of all theoretical results?
[Yes] Some combinatorial constructions (used in proofs of Theorems 3 4 5), are included Appendix C. 3.
If you ran experiments...
(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
[N/A] (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?
[N/A] (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?
[N/A] (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?
[N/A] 4.
If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?
[N/A] (b) Did you mention the license of the assets?
[N/A] (c) Did you include any new assets either in the supplemental material or as a URL?
[N/A] (d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating?
[N/A] (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?
[N/A] 5.
If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?
[N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?
[N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] Appendix
A Other Related Work
Our algorithms have direct application in stream processing and set reconstruction. There is a number of existing algorithms retrieving various informations from streams, such as: extracting the most frequent elements [17, 18, 16, 59, 49], quantile tracking [15, 35, 40], or approximate histogram maintenance and reconstruction [33, 34]. Some of these existing algorithms use Group Testing (e.g., [18]) but in a randomized variant.
This leads to a small probability of error that might become significant in very large streams. Solutions to Group Testing were also applied in many other domains, including pattern matching [13, 43], compressed sensing [19], reconstructing graphs [11, 37], identifying genetic carriers [5], resolving conflicts on multiple-access channels and wireless networks [6, 7, 31, 38, 39, 48, 53, 36]. Our setting of capped quantitative feedback could be applied to more subtle versions of the abovementioned problems, for example: in wireless communication, where the devices could filter out up to α interfering signals; in bio-chemical testing with capped scale; in streaming algorithms with limited processing time. The problem of Group Testing has also been considered in various different feedback models.
For instance, [8] shows that O ( k log nk ) queries are sufficient for a feedback that only returns whether the size of the intersection | Q ∩ K | is odd or even.
B Additional Extensions and Applications of Our Results
Group testing on multi-sets.
Assume instead of a hidden set, there is a hidden multi-set K , containing at most k elements from [ N ] .
Multi-set means that each element may have several multiplicities.
Let κ be the sum of multiplicities of elements in K , and we assume it is unknown to the algorithm.
We could decode all elements in K with their multiplicities using similar approach as in Section 4, with the following modifications.
First, we need to have a sufficiently large cap α to decode each multiplicity, i.e., α should be not smaller than κ .
Second, in the construction Algorithm 1, instead of applying SuI’s only while ℓ > 3 δlα − 1 and then SSuI, we need to keep applying SuI’s while ℓ > 1 .
Analogously in the structure of decoding Algorithm 2 – updating the condition of the first while-loop and removing the second while-loop.
This is because the multiplicities of elements not decoded by SuI’s in the While-loop could still be larger than √ κ , therefore switching to SSuI may not be enough to decode their multipicities (note that κ plays in this part a similar role to k in the original algorithm for sets without multiplicities).
The correctness still holds, as each consecutive SuI combined with balanced IDs reveals full multiplicities of a fraction of remaining elements in K (instead of just presence of elements, as in the original proof of Theorem 1).
The asymptotic query complexity (codeword length) stays the same as the part coming from the first while-loop (the sum of SuI lengths multiplied by 2 log n coming from balanced IDs), since we just add a negligible tail in the sum of lengths of SuI’s considered in Theorem 1.
Third, polynomial time is now with respect to n and log κ , to deal with multiplicities.
Therefore we get:
Theorem 7.
There is an explicit polynomial-time (in n and log κ ) algorithm constructing nonadaptive queries Q 1 , . . .
, Q m , for m =
O (min { n, k polylog n } ) , that correctly decode a multi-set
K of at most k elements and multiplicity κ (where k is known but κ could be unknown) under feedback F α with polynomial-time (in n and log κ ) decoding, where α is not smaller than the largest multiplicity of an element in K .
Moreover, every element occurs in O ( polylog n ) queries, and the decoding time is O ( m + k polylog n ) .
Maintaining and reconstructing a (multi) set.
Consider the following problem.
We have an incoming very large stream of insertion or deletions of elements from some domain N .
The objective is to propose a datastructure that processes such operations and at any step (i.e., after processing a certain number of operations) it can answer a request and provide information about the set specified by the operations that have been processes so far.
This is a commonly studied setting (see e.g., [18, 42]) and extracting information from such stream of operations has applications to database systems.
Our algorithms lead directly to an explicit formulation of a datastructure capable of extracting the whole (multi) set, however only conditioned that (at the moment of the request) the sum of multiplicities of the hidden set does not exceed k .
The space complexity of the datastructure would equal to the number of queries of the algorithm, which is O (min { n, k polylog n } ) .
Maintaining and reconstructing a graph with dynamically added or removed edges.
Consider a graph G with a fixed set of nodes and an online stream of operations on G , where a single operation could be either adding or removing an edge to/from G .
Assume for the ease of presentation that after each operation, the maximum node degree is bounded by some parameter k .
3 Consider a sequence of queries from Theorem 1 on the set of all possible n ( n − 1)edges.
For each added/removed edge, we increase/decrease (resp.)
a counter associated with each query containing this edge.
As each edge occurs in O ( kα log 2 n + polylog n ) queries, and thus this is an upper bound (up to some additional logarithmic factor) on the time of each graph update , which is polylogarithmic for α close to k .
Whenever one would like to recover the whole graph, a reconstruction algorithm is applied, which takes O ( m + k 2 α log 2 n + k polylog n ) steps, which for α close to k is O
( nk polylog n ) .
Note that the latter formula corresponds to (the upper bound on) the number of edges in G .
To summarize, we implemented graph updates operations in polylog n time per (edge-)operation, and the whole graph recovery in time proportional to the graph size (number of edges) times polylog n .
Private Parallel Information Retrieval (PPIR).
One of techniques to speed-up Information
Retrieval from a large dataset is to employ autonomous agents searching parts of the datasets, c.f., [30].
Our Capped Quantitative Group Testing algorithms could be applied to achieve this goal, additionally providing a level of privacy.
Assume that there are m =
O ( k polylog n ) simple autonomous agents, where m also denotes the number of queries in our Capped QGT system.
Each agent i is capable to search only through records captured by the corresponding query set Q i , and only count the number of occurrences of records satisfying the search criteria, but only up to √ k .
If all agents share privately their results with the user, he can decompose the set K of at most k elements satisfying the searching criteria, while each of the agents has knowledge about at most √ k of these elements.
It follows from the construction of our queries that each of them is of size
O ( n/ √ k polylog n ) , which is worst-case number of records that a single agent needs to check – thus equal to parallel time.
Note also that agents perform very simple counting operations, thus the PPIR algorithm could be efficient in practice.
Non-adaptive QGT as codes.
Alternatively, we can reformulate the problem of non-adaptive
Group Testing under F
α feedback into the language of codes.
A query sequence translates to code as follows: each element v ∈ [ N ] corresponds to a binary codeword with i -th position being 1 ordepending on whether v belongs to the i -th query or not.
Then the hidden set K is a subset of at most k codewords, for which we calculate the feedback vector by taking the function min {· , α } from elementwise sum of all the codewords corresponding to set K .
I.e., the feedback is computed for each position i , and the whole feedback vector is an input to the decoding algorithm.
The objective is to decode the elements of K from the feedback vector.
C Constructions of Combinatorial Tools C.1 Polynomial-time Construction of Selectors-under-Interference
In this section, we show how to construct, in time polynomial in n , an ( n, ℓ, ϵ, κ, α ) -SuI S of size O (min { n, ℓ polylog n } ) , for any integer parameters ℓ, κ ≤ n , α ≤ κ , and any (arbitrarily small) constant ϵ ∈ (0 , 1 / 2) .
Let ℓ ∗ denote ℓϵ .
The construction combines dispersers with strong selectors, see also the pseudocode Algorithm 3.
We start from reminding the disperser needed for the construction (defined in Section 4.1), and then specifying the strong selectors.
The disperser.
We will use a bipartite ( ℓ ∗ , d, ϵ ) -disperser graph G =
( V, W, E ) with entropy loss δ , where | V | = n .
It has left-degree d , | W | =
ℓd/δ , and satisfies the following dispersion condition: for each L ⊆ V such that | L | ≥ ℓ ∗ , the set N G ( L ) of neighbors of L in graph G is of size at least (1 − ϵ ) | W
| .
Note that it is enough for us to take as ϵ in the dispersion property the same value as in the constructed ( n, ℓ, ϵ, κ, α ) -SuI S – ff someone considers ϵ ≥ 1 / 3 , we could use construction for ϵ = 1 / 4 to get solution with better guarantees.
An explicit construction (i.e., in time polynomial in n ) of dispersers was given by [57], for any n ≥ ℓ , and some δ =
O (log 3 n ) , where d = O ( polylog n ) .
Optimal dispersers have δ = O (1) and d = O (log n ) , but their polynomial-time construction is an open problem.
Strong selector.
Let T =
{ T 1 , . . .
, T m } be an explicit ( n, 3 δ ) -strong-selector (also called stronglyselective family) of length m ≤ min { n, 2 · (3 δ ) 2 log 2 n } =
O (min { n, δ 2 log 2 n } ) , as constructed by Kautz and Singleton [46].
Construction of ( n, ℓ, ϵ, κ, α ) -SuI S .
We define an ( n, ℓ, ϵ, κ, α ) -SuI S of size min { n, m | W |} , which consists of sets S i , for 1 ≤ i ≤ min { n, m | W |} .
There are two cases to consider, depending on the relation between n and m | W | .
The case of n ≤ m | W | is simple: take the singleton containing only the i -th element of V as S i .
Consider a more interesting case when n > m | W | .
For i = am + b ≤ m | W | , where a and b are non-negative integers satisfying a + b > 0 , let S i contain all the nodes v ∈ V such that v is a neighbor of the a -th node in W and v ∈ T b .
Data: ( ℓϵ, d, ϵ ) -disperser
G =
( V, W, E ) ,
V = { v 1 , . .
. , v n } , W = { w 1 , . . .
, w | W | } , | W | =
ℓd/δ , δ =
O (log 3 n ) , d
= O ( polylog n ) , ( n, 3 δ ) -strong-selector T =
{ T 1 , . . .
, T m }
Result: ( n, ℓ, ϵ, κ, α ) -SuI
S 1 for i ← 1 to min { n, m | W |} do if n > m | W | then
} else
{+Proof. of Theorem 
+}
First we show that the constructed S is an ( n, ℓ, ϵ, κ, α ) -SuI.
The case n ≤ m | W | is clear, since each element in a set K 1 of size at most ℓ occurs as a singleton in some set S
i (here it does not matter what the set K 2 is).
Consider the case n > m | W | .
Let a set K 1 ⊆
V be of size at most ℓ and a set K 2 of at most κ elements.
Suppose, to the contrary, that there is a set L ⊆ K 1 of size ℓ ∗ such that none among the elements in L is K 1 -selected by S under α -interference from K 2 , that is, S i ∩ L ̸ = { v } or | S i ∩ K 2 | ≥ α , for any v ∈ L and 1 ≤ i ≤ m | W | .
(Recall that ℓ ∗ =
ℓϵ .)
Claim: Every w ∈ N G
L ) has more than 3 δ neighbors in K 1 or at least α neighbors in K 2 .
The proof is by contradiction.
Suppose, to the contrary, that there is w ∈ N G
( L ) which has at most 3 δ neighbors in K 1 and less than α neighbors in K 2 , that is,
| N G ( w ) ∩ K 1 | ≤ 3 δ and | N G ( w ) ∩ K 2 | < α .
By the former property and the fact that T is an ( n, 3 δ ) -strong-selector, we get that, for every v ∈ N G ( w ) ∩ K 1 , the equalities
[Equation]
[Equation]
hold, for some 1 ≤ b ≤ m .
This holds in particular for every v ∈ L ∩ N G ( w ) ∩ K 1 .
There is at least one such v ∈ L ∩ N G ( w ) ∩ K 1 because set L ∩ N G ( w ) ∩ K 1 is nonempty, since w ∈ N G ( L ) and L ⊆ K 1 .
Additionally, recall that N G ( w ) ∩ K 2 is smaller than α .
The existence of such v is in contradiction with the choice of L .
Namely, L contains only elements which are not K 1 -selected by sets from S under α -interference from K 2 , but v ∈ L ∩ N G ( w ) ∩ K 1 is selected from K 1 by some set S w · m + b and the interference from K 2 on this set is smaller than α .
This contradiction makes the proof of the Claim complete.
■ Recall that | L | = ℓ ∗ = ℓϵ .
By dispersion, the set N G ( L ) is of size larger than (1 − ϵ ) | W | .
Consider two cases below – they cover all possible cases because of the above Claim.
Case 1: At least half of the nodes w in N G ( L ) have more than 3 δ neighbors in K 1 .
In this case, the total number of edges between the nodes in K 1 and N G ( L ) in graph G is larger than
[Equation]
since 12 (1 − ϵ ) · 3 > 1 for ϵ < 1 / 3 .
This is a contradiction, since the total number of edges in graph
G incident to nodes in K 1 is at most | K 1 | d = ℓd .
Case 2: More than half of the nodes w in N G ( L ) have at least α neighbors in K 2 .
In this case, the total number of edges between the nodes in K 2 and N G ( L ) in graph G is larger than
[Equation]
because of assumptions ϵ < 1 / 3 and ℓ > κ · (3 δ ) /α .
This is a contradiction, since the total number of edges in graph G incident to nodes in K 2 is at most | K 2 | d = κd .
Thus, it follows from the contradictions in both cases that S is an ( n, ℓ, ϵ, κ, α ) -SuI.
The size of this selector is [Equation] since ℓ = Θ( ℓ ∗ ) . It follows directly from the construction that each element is in
Sparser SuI for small ℓ compared to κ/α – Modification and proof of Theorem 4.
What if αℓ ≤ 3 δκ ?
We could modify the above construction as follows.
If αℓκ ≤ 3 δ , we take the ( n, 3 δκ/α, ϵ, κ, α ) -SuI S from Theorem 3 and partition each set S ∈ S into the smallest number of sets of size at most α each.
We denote the new sequence obtained from S by S| α .
To bound the total number η of sets in S| α we first note that η ≤ |S| + (cid:80) S ∈S | S | α .
The total number of occurrences of elements in sets S ∈ S is upper bounded by O ( n · dδ log n ) , by Theorem 3.
Therefore, we obtain that η = O (cid:0) min (cid:8) n, ( κ/α ) dδ log 2 n (cid:9) + ndδα log n (cid:1) .
To show that S| α is an ( n, ℓ, ϵ, κ, α ) -SuI, note that if in the original ( n, 3 δκ/α, ϵ, κ, α ) -SuI S an element v is α -selected from a set K 1 under interference from K 2 by some set S i ∈ S , where | K 1 | ≤ ℓ ≤ 3 δκ/α , it occurs in some of the new sets being in the partition of the original selecting set S i .
Since each partition (made during the construction of S| α ) is a subset of the original set, element v is also α -selected in S| α from K 1 under interference from K 2 .
Note that in the above decoding, the number of queries containing any element remains O ( dδ log n ) , as in the original SuI from Theorem 3 (as in the construction we only partition sets).
Hence, by taking the construction of family S| α , we proved Theorem 4.
C.2 Polynomial-time Construction of Strong-Selectors-under-Interference
In order to construct an ( n, ℓ, κ, α ) -SSuI S , we use the following variation of a Reed-Solomon superimposed code, analogous to the construction used in [46], however here we prove an additional property of these objects.
Let deg =
⌈ log ℓ n ⌉ and q = c · ℓ · deg for some constant c > 0 such that q deg +1 ≥ n and q is prime.
Note that, by distribution of prime numbers, we could assume c ∈ [3 / 2 , 3) .
Consider all polynomials of degree deg over field F q ; there are q deg +1 such polynomials.
Remove q deg +1 − n arbitrary polynomials and denote the remaining polynomials by P 1 , P 2 , . .
P n .
Create the following matrix M of size q × n .
Each column i , for 1 ≤ i ≤ n , stores values
P i ( x ) of polynomial P i for arguments x = 0 , 1 , . . .
, q − 1 ; the arguments correspond to rows of M .
Next, matrix M ∗ is created from M as follows: each value y
=
P
i ( x ) ∈ { 0 , 1 , . .
{+. , q − 1 } is represented and padded in q consecutive rows containing 0 s and 1 s, where 1 is exactly in y +
+}
-st padded row, while in all other padded rows there are 0 s. Notice that each column of M ∗ has q 2 rows ( q rows per each argument), therefore M ∗ is of size q 2 × n .
Set T i ⊆
[ n ] , for 1 ≤ i ≤ q 2 , is defined based on row
i of matrix M ∗ : it contains all elements v ∈ [ n ] such that M ∗ [ j, v ] = 1 .
(Recall that each such v corresponds to some polynomial.)
For a fixed constant c > 0 , { T i } q 2 i =1 forms a family T ( c ) of subsets of set { 1 , . . . , n } .
The above construction could be presented as a simplified pseudocode, see Algorithm 4.
Algorithm 4: Construction of Strong-Selectors-under-Interference 1 deg ← ⌈ log ℓ n ⌉ ; 2 q ← c · ℓ · deg for some constant c ∈ [3 / 2 , 3) such that q deg +1 ≥ n and q is prime; /
* There are q deg +1 ≥ n such polynomials.
*/ 3 P 1 , P 2 , . . .
, P n ← arbitrary n polynomials of degree deg over field F q ; 4 T ( c ) ← sequence of q 2 empty sets { T i } q 2 i =1 ; 5 for i ← 1 to n do for x ← 0 to q − 1 do /
* Value of i -th polynomial for argument x .
*/ value ← P i ( x ) ; /* Encode value in unary on positions x · q + 1 , x · q + 2 , . . .
( x + 1) · q */ index ← x
Proof. of Theorem 5 Consider the constructed family T ( c ) .
Polynomial time of this construction follows directly from the fact that the space of polynomials over field [ q ] is of polynomial size in n and all the operations on them are polynomial.
The length follows from the fact that it is q 2 < 3 2 ℓ 2 log 2 ℓ n = O ( ℓ 2 log 2 ℓ n ) .
Recall that each element v ∈ [ n ] correspond to some polynomial of degree at most deg over F q .
Note that two polynomials P i and P j of degree deg with i ̸
= j , can have equal values for at most deg different arguments.
This is because they have equal values for arguments x for which
P i ( x ) − P j ( x ) = 0 .
However, P i − P j is a polynomial of degree at most deg , so it can have at most deg zeroes.
Hence, P i ( x ) =
P j ( x ) for at most deg different arguments x .
Take any polynomial P i and any other at most ℓ − 1 polynomials P j , which altogether form set Kof at most ℓ polynomials.
There are at most ( ℓ − 1) · deg different arguments where one of the other ℓ − 1 polynomials can be equal to P i .
Hence, for at least q − ( ℓ − 1) · deg different arguments, the values of the polynomial P i are different than the values of the other polynomials in K 1 .
Let us call the set of these arguments A .
Consider any set K 2 ⊆ { 1 , . . .
n } of at most κ elements (corresponding to polynomials).
Consider arguments from set A for which P i has the same value as at least α other polynomials in K 2 .
The number of such arguments is at most
[Equation]
which means it is smaller than | A | , for c ∈ [3 / 2 , 3) in the definition of q = cℓ · deg .
Therefore, there is an argument (in set A ) such that the value of P i is different from the values of all other ℓ −polynomials in K 1 and less than α polynomials in set K 2 .
As this holds for an arbitrary polynomial
P i in an arbitrary set K 1 of at most ℓ polynomials (in total) and an arbitrary set K 2 of at most κ polynomials, T ( c ) is an ( n, ℓ, κ, α ) -SSuI.
Finally, it follows directly from the construction that every element occurs in q =
O ( ℓ log ℓ n ) queries.