Group testing is an approach aimed at identifying up to $d$ defective items among a total of $n$ elements. This is accomplished by examining subsets to determine if at least one defective item is present. In our study, we focus on the problem of identifying a subset of $\ell\leq d$ defective items. We develop upper and lower bounds on the number of tests required to detect $\ell$ defective items in both the adaptive and non-adaptive settings while considering scenarios where no prior knowledge of $d$ is available, and situations where an estimate of $d$ or at least some non-trivial upper bound on $d$ is available. When no prior knowledge on $d$ is available, we prove a lower bound of $ \Omega(\frac{\ell \log^2n}{\log \ell +\log\log n})$ tests in the randomized non-adaptive settings and an upper bound of $O(\ell \log^2 n)$ for the same settings. Furthermore, we demonstrate that any non-adaptive deterministic algorithm must ask $\Theta(n)$ tests, signifying a fundamental limitation in this scenario. For adaptive algorithms, we establish tight bounds in different scenarios. In the deterministic case, we prove a tight bound of $\Theta(\ell\log{(n/\ell)})$. Moreover, in the randomized settings, we derive a tight bound of $\Theta(\ell\log{(n/d)})$. When $d$, or at least some non-trivial estimate of $d$, is known, we prove a tight bound of $\Theta(d\log (n/d))$ for the deterministic non-adaptive settings, and $\Theta(\ell\log(n/d))$ for the randomized non-adaptive settings. In the adaptive case, we present an upper bound of $O(\ell \log (n/\ell))$ for the deterministic settings, and a lower bound of $\Omega(\ell\log(n/d)+\log n)$. Additionally, we establish a tight bound of $\Theta(\ell \log(n/d))$ for the randomized adaptive settings.

In this paper, we study the learnability of the Boolean class of d-monotone functions f:𝒳→{0,1} from membership and equivalence queries, where (𝒳,≤ ) is a finite lattice. We show that the class of d-monotone functions that are represented in the form f=F(g_1,g_2,… ,g_d) , where F is any Boolean function F:{0,1}^d→{0,1} and g_1,… ,g_d:𝒳→{0,1} are any monotone functions, is learnable in time σ (𝒳)· (size(f)/d+1)^d where σ (𝒳) is the maximum sum of the number of immediate predecessors in a chain from the largest element to the smallest element in the lattice 𝒳 and size(f)=size(g_1)+⋯ +size(g_d) , where size(g_i) is the number of minimal elements in g_i^-1(1) . For the Boolean function f:{0,1}^n→{0,1} , the class of d-monotone functions that are represented in the form f=F(g_1,g_2,… ,g_d) , where F is any Boolean function and g_1,… ,g_d are any monotone DNF, is learnable in time O(n^2)· (size(f)/d+1)^d where size(f)=size(g_1)+⋯ +size(g_d) . In particular, this class is learnable in polynomial time when d is constant. Additionally, this class is learnable in polynomial time when size(g_i) is constant for all i and d=O(log n) .

Efficiently counting or detecting defective items is a crucial task in various fields ranging from biological testing to quality control to streaming algorithms. The \emph{group testing estimation problem} concerns estimating the number of defective elements $d$ in a collection of $n$ total within a given factor. We primarily consider the classical query model, in which a query reveals whether the selected group of elements contains a defective one. We show that any non-adaptive randomized algorithm that estimates the value of $d$ within a constant factor requires $\Omega(\log n)$ queries. This confirms that a known $O(\log n)$ upper bound by Bshouty (2019) is tight and resolves a conjecture by Damaschke and Sheikh Muhammad (2010). Additionally, we prove similar matching upper and lower bounds in the threshold query model.

Consider the model where we can access a parity function through random uniform labeled examples in the presence of random classification noise. In this paper, we show that approximating the number of relevant variables in the parity function is as hard as properly learning parities. More specifically, let gamma : R+ -> R+, where gamma(x) >= x, be any strictly increasing function. In our first result, we show that from any polynomial-time algorithm that returns a gamma-approximation, D (i.e., gamma(-1)(d(f)) <= D <= gamma(d(f))), of the number of relevant variables d(f) for any parity f, we can, in polynomial time, construct a solution to the long-standing open problem of polynomial-time learning k(n)-sparse parities (parities with k(n) <= n relevant variables), where k(n) = omega(n)(1). In our second result, we show that from any T(n)-time algorithm that, for any parity f, returns a gamma-approximation of the number of relevant variables d(f) of f, we can, in polynomial time, construct a poly(Gamma(n))T(Gamma(n)2)-time algorithm that properly learns parities, where Gamma(x) = gamma(gamma(x)). If T(Gamma(n)(2)) = exp(o( n/ log n)), this would resolve another long-standing open problem of properly learning parities in the presence of random classification noise in time exp(o( n/ log n)).

Let X be a set of items of size n , which may contain some defective items denoted by I, where I ⊆ X. In group testing, a test refers to a subset of items Q ⊂ X. The test outcome is 1 (positive) if Q contains at least one defective item, i.e., Q∩ I ≠∅, and 0 (negative) otherwise. We give a novel approach to obtaining tight lower bounds in non-adaptive randomized group testing. Employing this new method, we can prove the following result. Any non-adaptive randomized algorithm that, for any set of defective items I, with probability at least 2/3, returns an estimate of the number of defective items |I| to within a constant factor requires at least Ω(log n) tests. Our result matches the upper bound of O(log n) and solves the open problem posed by Damaschke and Sheikh Muhammad.

Koch, Strassle, and Tan [SODA 2023], show that, under the randomized exponential time hypothesis, there is no distribution-free PAC-learning algorithm that runs in time $n^{\tilde O(\log\log s)}$ for the classes of $n$-variable size-$s$ DNF, size-$s$ Decision Tree, and $\log s$-Junta by DNF (that returns a DNF hypothesis). Assuming a natural conjecture on the hardness of set cover, they give the lower bound $n^{\Omega(\log s)}$. This matches the best known upper bound for $n$-variable size-$s$ Decision Tree, and $\log s$-Junta. In this paper, we give the same lower bounds for PAC-learning of $n$-variable size-$s$ Monotone DNF, size-$s$ Monotone Decision Tree, and Monotone $\log s$-Junta by~DNF. This solves the open problem proposed by Koch, Strassle, and Tan and subsumes the above results. The lower bound holds, even if the learner knows the distribution, can draw a sample according to the distribution in polynomial time, and can compute the target function on all the points of the support of the distribution in polynomial time.

We study the query complexity of one-sided ϵ -testing the class of Boolean functions f:ℱ^n→{0,1} that describe affine subspaces and Boolean functions that describe axis-parallel affine subspaces, where ℱ is any finite field. We give a polynomial-time ϵ -testers that ask Õ(1/ϵ ) queries. This improves the query complexity Õ(|ℱ|/ϵ ) in [11]. We then show that any one-sided ϵ -tester with proximity parameter ϵ <1/|ℱ|^d for the class of Boolean functions that describe (n-d) -dimensional affine subspaces and Boolean functions that describe axis-parallel (n-d) -dimensional affine subspaces must make at least (1/ϵ +|ℱ|^d-1log n) and (1/ϵ +|ℱ|^d-1n) queries, respectively. This improves the lower bound (log n/loglog n) that is proved in [11] for ℱ=GF(2) . We also give testers for those classes with query complexity that almost match the lower bounds. (See the definitions of the classes in the introduction and many other results in Figs. 1 and 2).

Let $M$ be a $n\times m$ $(0,1)$-matrix. We define the $s$-binary rank, $br_s(M)$, of $M$ to be the minimal integer $d$ such that there are $d$ monochromatic rectangles that cover all the $1$-entries in the matrix, and each $1$-entry is covered by at most $s$ rectangles. When $s=1$, this is the binary rank,~$br(M)$, known from the literature. Let $R(M)$ and $C(M)$ be the set of rows and columns of~$M$, respectively. We use the result of Sgall (Comb. 1999) to prove that if $M$ has $s$-binary rank at most~$d$, then $|R(M)|\cdot |C(M)|\le {d\choose \le s}2^{d}$ where ${d\choose \le s}=\sum_{i=0}^s{d\choose i}$. This bound is tight; that is, there exists a matrix $M'$ of $s$-binary rank $d$ such that $|R(M')|\cdot |C(M')|= {d\choose \le s}2^{d}$. Using this result, we give a new one-sided adaptive and non-adaptive testers for $(0,1)$-matrices of $s$-binary rank at most $d$ (and exactly $d$) that makes $\tilde O\left({d\choose \le s}2^d/\epsilon\right)$ and $\tilde O\left({d\choose \le s}2^d/\epsilon^2\right)$ queries, respectively. For a fixed $s$, this improves the query complexity of the tester of Parnas et al. (Theory Comput. Syst. 2021) by a factor of $\tilde \Theta (2^d)$.

In this paper, we study testing decision tree of size and depth that are significantly smaller than the number of attributes n. Our main result addresses the problem of poly(n, 1/ε) time algorithms with poly(s, 1/ε) query complexity (independent of n) that distinguish between functions that are decision trees of size s from functions that are ε-far from any decision tree of size φ(s, 1/ε), for some function φ > s. The best known result is the recent one that follows from Blanc, Lange and Tan, [3], that gives φ(s, 1/ε) = 2O((log 3 s)/ε). In this paper, we give a new algorithm that achieves φ(s, 1/ε) = 2O(log (s/ε)). Moreover, we study the testability of depth-d decision tree and give a distribution free tester that distinguishes between depth-d decision tree and functions that are ε-far from depth-d2 decision tree. 2012 ACM Subject Classification Theory of computation → Oracles and decision trees

A Boolean function f : { 0 , 1 } n → { 0 , 1 } is k -linear if it returns the sum (over the binary field F 2) of exactly k coordinates of the input. In this paper, we study property testing of the classes k -Linear, the class of all k -linear functions, and k -Linear ⁎ , the class ∪ j = 0 k j-Linear. We give a non-adaptive distribution-free two-sided ϵ -tester for k -Linear that makes O ( k log ⁡ k + 1 ϵ ) queries. This matches the lower bound known from the literature. We then give a non-adaptive distribution-free one-sided ϵ -tester for k -Linear ⁎ that makes the same number of queries and show that any non-adaptive uniform-distribution one-sided ϵ -tester for k -Linear must make at least Ω ˜ ( k ) log ⁡ n + Ω ( 1 / ϵ ) queries. The latter bound almost matches the upper bound O ( k log ⁡ n + 1 / ϵ ) known from the literature. We then show that any adaptive uniform-distribution one-sided ϵ -tester for k -Linear must make at least Ω ˜ ( k ) log ⁡ n + Ω ( 1 / ϵ ) queries.

We give the first almost optimal polynomial-time proper learning algorithm of Boolean sparse multivariate polynomial under the uniform distribution. For s-sparse polynomial over n variables and ϵ =1/s^β , β >1 , our algorithm makes q_U=( s/ϵ) ^logβ/β+O(1/β)+ Õ( s) ( log1/ϵ) log n queries. Notice that our query complexity is sublinear in 1/ϵ and almost linear in s. All previous algorithms have query complexity at least quadratic in s and linear in 1/ϵ . We then prove the almost tight lower bound q_L=( s/ϵ) ^logβ/β+(1/β)+ ( s) ( log1/ϵ) log n, Applying the reduction in [9] with the above algorithm, we give the first almost optimal polynomial-time tester for s-sparse polynomial. Our tester, for β >3.404 , makes Õ( s/ϵ) queries.

In this paper, we study learning and testing decision tree of size and depth that are significantly smaller than the number of attributes $n$. Our main result addresses the problem of poly$(n,1/\epsilon)$ time algorithms with poly$(s,1/\epsilon)$ query complexity (independent of $n$) that distinguish between functions that are decision trees of size $s$ from functions that are $\epsilon$-far from any decision tree of size $\phi(s,1/\epsilon)$, for some function $\phi > s$. The best known result is the recent one that follows from Blank, Lange and Tan,~\cite{BlancLT20}, that gives $\phi(s,1/\epsilon)=2^{O((\log^3s)/\epsilon^3)}$. In this paper, we give a new algorithm that achieves $\phi(s,1/\epsilon)=2^{O(\log^2 (s/\epsilon))}$. Moreover, we study the testability of depth-$d$ decision tree and give a {\it distribution free} tester that distinguishes between depth-$d$ decision tree and functions that are $\epsilon$-far from depth-$d^2$ decision tree. In particular, for decision trees of size $s$, the above result holds in the distribution-free model when the tree depth is $O(\log(s/\epsilon))$. We also give other new results in learning and testing of size-$s$ decision trees and depth-$d$ decision trees that follow from results in the literature and some results we prove in this paper.

We study the group testing problem with non-adaptive randomized algorithms. Several models have been discussed in the literature to determine how to randomly choose the tests. For a model ${\cal M}$, let $m_{\cal M}(n,d)$ be the minimum number of tests required to detect at most $d$ defectives within $n$ items, with success probability at least $1-\delta$, for some constant $\delta$. In this paper, we study the measures $$c_{\cal M}(d)=\lim_{n\to \infty} \frac{m_{\cal M}(n,d)}{\ln n} \mbox{ and } c_{\cal M}=\lim_{d\to \infty} \frac{c_{\cal M}(d)}{d}.$$ In the literature, the analyses of such models only give upper bounds for $c_{\cal M}(d)$ and $c_{\cal M}$, and for some of them, the bounds are not tight. We give new analyses that yield tight bounds for $c_{\cal M}(d)$ and $c_{\cal M}$ for all the known models~${\cal M}$.

We study the problem of estimating the number of defective items $d$ within a pile of $n$ elements up to a multiplicative factor of $\Delta>1$, using deterministic group testing algorithms. We bring lower and upper bounds on the number of tests required in both the adaptive and the non-adaptive deterministic settings given an upper bound $D$ on the defectives number. For the adaptive deterministic settings, our results show that, any algorithm for estimating the defectives number up to a multiplicative factor of $\Delta$ must make at least $\Omega \left((D/\Delta^2)\log (n/D) \right )$ tests. This extends the same lower bound achieved in \cite{ALA17} for non-adaptive algorithms. Moreover, we give a polynomial time adaptive algorithm that shows that our bound is tight up to a small additive term. For non-adaptive algorithms, an upper bound of $O((D/\Delta^2)$ $(\log (n/D)+\log \Delta) )$ is achieved by means of non-constructive proof. This improves the lower bound $O((\log D)/(\log\Delta))D\log n)$ from \cite{ALA17} and matches the lower bound up to a small additive term. In addition, we study polynomial time constructive algorithms. We use existing polynomial time constructible \emph{expander regular bipartite graphs}, \emph{extractors} and \emph{condensers} to construct two polynomial time algorithms. The first algorithm makes $O((D^{1+o(1)}/\Delta^2)\cdot \log n)$ tests, and the second makes $(D/\Delta^2)\cdot quazipoly$ $(\log n)$ tests. This is the first explicit construction with an almost optimal test complexity.

We study the problem of determining exactly the number of defective items in an adaptive Group testing by using a minimum number of tests. We improve the existing algorithm and prove a lower bound that shows that the number of tests in our algorithm is optimal up to small additive terms.

In this lecture note we give Liu-Chen-Servedio-Sheng-Xie's (LCSSX) lower bound for property testing in the non-adaptive distribution-free.

We give improved and almost optimal testers for several classes of Boolean functions on $n$ inputs that have concise representation in the uniform and distribution-free model. Classes, such as $k$-junta, $k$-linear functions, $s$-term DNF, $s$-term monotone DNF, $r$-DNF, decision list, $r$-decision list, size-$s$ decision tree, size-$s$ Boolean formula, size-$s$ branching programs, $s$-sparse polynomials over the binary field and function with Fourier degree at most $d$. The method can be extended to several other classes of functions over any domain that can be approximated by functions that have a small number of relevant variables.

We consider the problem of learning a general graph $G=(V,E)$ using edge-detecting queries, where the number of vertices $|V|=n$ is given to the learner. The information theoretic lower bound gives $m\log n$ for the number of queries, where $m=|E|$ is the number of edges. In case the number of edges $m$ is also given to the learner, Angluin-Chen's Las Vegas algorithm \cite{AC08} runs in $4$ rounds and detects the edges in $O(m\log n)$ queries. In the other harder case where the number of edges $m$ is unknown, their algorithm runs in $5$ rounds and asks $O(m\log n+\sqrt{m}\log^2 n)$ queries. There have been two open problems: \emph{(i)} can the number of queries be reduced to $O(m\log n)$ in the second case, and, \emph{(ii)} can the number of rounds be reduced without substantially increasing the number of queries (in both cases). For the first open problem (when $m$ is unknown) we give two algorithms. The first is an $O(1)$-round Las Vegas algorithm that asks $m\log n+\sqrt{m}(\log^{[k]}n)\log n$ queries for any constant $k$ where $\log^{[k]}n=\log \stackrel{k}{\cdots} \log n$. The second is an $O(\log^*n)$-round Las Vegas algorithm that asks $O(m\log n)$ queries. This solves the first open problem for any practical $n$, for example, $n 2^m$. Finally, we give a $3$-round Monte Carlo algorithm that asks $O(m\log n)$ queries for any $n$ and $m$.

We consider the problem of testing whether an unknown n-variable Boolean function is a k-junta in the distribution-free property testing model, where the distance between functions is measured with respect to an arbitrary and unknown probability distribution over {0, 1}n. Chen, Liu, Servedio, Sheng and Xie [35] showed that the distribution-free k-junta testing can be performed, with one-sided error, by an adaptive algorithm that makes Õ(k2)/ϵ queries. In this paper, we give a simple two-sided error adaptive algorithm that makes Õ{k/ϵ) queries.