Sparse Graph Codes for Non-adaptive Quantitative Group Testing

TL;DR

This paper introduces a non-adaptive quantitative group testing algorithm using sparse graph codes and BCH codes, achieving near-optimal test efficiency and high probability of exact defective item recovery in large-scale scenarios.

Contribution

The paper proposes a novel non-adaptive QGT scheme with sparse graph codes and BCH codes, providing probabilistic guarantees and analyzing test complexity.

Findings

Requires at most c(t)K(t log2(ℓN/(c(t)K)+1)+1)+1 tests for large N,K

Achieves minimum tests with t=2

Decoding complexity is O(K log(N/K)) for t ≤ 4

Abstract

This paper considers the problem of Quantitative Group Testing (QGT). Consider a set of $N$ items among which $K$ items are defective. The QGT problem is to identify (all or a sufficiently large fraction of) the defective items, where the result of a test reveals the number of defective items in the tested group. In this work, we propose a non-adaptive QGT algorithm using sparse graph codes over bi-regular bipartite graphs with left-degree $\ell$ and right degree $r$ and binary $t$-error-correcting BCH codes. The proposed scheme provides exact recovery with probabilistic guarantee, i.e. recovers all the defective items with high probability. In particular, we show that for the sub-linear regime where $\frac{K}{N}$ vanishes as $K,N\rightarrow\infty$, the proposed algorithm requires at most ${m=c(t)K\left(t\log_2\left(\frac{\ell N}{c(t)K}+1\right)+1\right)+1}$ tests to recover all the defective items with probability approaching one as ${K,N\rightarrow\infty}$, where $c(t)$ depends only on $t$. The results of our theoretical analysis reveal that the minimum number of required tests is achieved by $t=2$. The encoding and decoding of the proposed algorithm for any $t\leq 4$ have the computational complexity of $\mathcal{O}(K\log^2 \frac{N}{K})$ and $\mathcal{O}(K\log \frac{N}{K})$, respectively. Our simulation results also show that the proposed algorithm significantly outperforms a non-adaptive semi-quantitative group testing algorithm recently proposed by Abdalla \emph{et al.} in terms of the required number of tests for identifying all the defective items with high probability.

Tables

Table 1. TABLE I : The function c ​ ( t ) 𝑐 𝑡 c(t) and the optimal left degree ℓ ⋆ superscript ℓ ⋆ \ell^{\star} .

$t$	1	2	3	4	5	6	7	8
$c\left(t\right)$	1.222	0.597	0.388	0.294	0.239	0.202	0.176	0.156
${\ell }^{\star }$	3	2	2	2	2	2	2	2

Equations

$$\mathbf{y}=[y_1,\cdots ,y_m{]}^{\mathsf{T}}=\mathbf{Ax}.$$

$$\mathbf{D}=\left[\begin{array}{cccc}0& 1& 0& 1\\ 0& 1& 1& 0\\ 0& 0& 1& 1\end{array}\right].$$

$$\left[\begin{array}{c}0\\ 0\\ 0\end{array}\right]\oplus \left[\begin{array}{c}1\\ 1\\ 0\end{array}\right]=\left[\begin{array}{c}0\\ 1\\ 1\end{array}\right]\oplus \left[\begin{array}{c}1\\ 0\\ 1\end{array}\right]=\left[\begin{array}{c}1\\ 1\\ 0\end{array}\right].$$

$$\{\begin{array}{ll}\text{n=2m−1}& \text{block length}\\ \text{n−k≤mt}& \text{number of parity-check digits}\\ \text{dmin≥2t+1}& \text{minimum Hamming distance}\end{array}$$

$${\mathbf{H}}_t=\left[\begin{array}{ccccc}1& \alpha & {\alpha }^2& \dots & {\alpha }^{n-1}\\ 1& ({\alpha }^3)& ({\alpha }^3{)}^2& \dots & ({\alpha }^3{)}^{n-1}\\ 1& ({\alpha }^5)& ({\alpha }^5{)}^2& \dots & ({\alpha }^5{)}^{n-1}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 1& ({\alpha }^{2t-1})& ({\alpha }^{2t-1}{)}^2& \dots & ({\alpha }^{2t-1}{)}^{n-1}\end{array}\right],$$

$$R=tm=t{\log }_2(n+1).$$

$$N\ell =Mr$$

$${\mathbf{A}}_i=[0,\dots ,0,{\mathbf{u}}_1,0,\dots ,{\mathbf{u}}_2,0,\dots ,{\mathbf{u}}_r]$$

$$\mathbf{T}_{\mathcal{G}}=\setcounter{MaxMatrixCols}{14}\begin{bmatrix}{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&0&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}&0\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&0&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&0&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}&0\end{bmatrix}.$$

$${\mathbf{H}}_1=\left[\begin{array}{cccc}1& \alpha & \cdots & {\alpha }^6\end{array}\right]=\left[\begin{array}{ccccccc}0& 0& 1& 0& 1& 1& 1\\ 0& 1& 0& 1& 1& 1& 0\\ 1& 0& 0& 1& 0& 1& 1\end{array}\right],$$

$$\mathbf{U}=\begin{bmatrix}{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}0}&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}0}\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0}&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\end{bmatrix}.$$

$$\mathbf{A}=\setcounter{MaxMatrixCols}{14}\begin{bmatrix}{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}0}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}0}\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ \hline\cr 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&0&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&0&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}0}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&0&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}0}\\ 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&0&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0}&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}\\ \hline\cr 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}&0\\ 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}0}&0&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}&0\\ 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}0}&0\\ 0&{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&0&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&0&0&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0}&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&0&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}&0\\ \hline\cr{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&0&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&0&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}&0\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&0&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}1}&0&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}0}&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}&0\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}0}&0&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}1}&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&0&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}1}&0&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}0}&0\\ {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}1}&0&0&{\color[rgb]{.75,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{.75,1,0}0}&{\color[rgb]{1,.5,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,.5,0}0}&0&0&{\color[rgb]{0,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,1,0}1}&{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}0}&0&0&{\color[rgb]{.75,.5,.25}\definecolor[named]{pgfstrokecolor}{rgb}{.75,.5,.25}1}&{\color[rgb]{1,1,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,1,0}\pgfsys@color@cmyk@stroke{0}{0}{1}{0}\pgfsys@color@cmyk@fill{0}{0}{1}{0}1}&0\\ \end{bmatrix}.$$

$${\mathbf{z}}_i=[z_{i,1},z_{i,2},\cdots ,z_{i,s}{]}^{\mathsf{T}}={\mathbf{A}}_i\mathbf{x},\forall i\in \{1,\cdots ,M\}.$$

$$\mathbf{y}=\left[\begin{array}{c}{\mathbf{z}}_1\\ {\mathbf{z}}_2\\ {\mathbf{z}}_3\\ {\mathbf{z}}_4\end{array}\right]=\mathbf{Ax}=\left[\begin{array}{c}{\mathbf{u}}_1\\ {\mathbf{u}}_5\\ {\mathbf{u}}_2+{\mathbf{u}}_5\\ {\mathbf{u}}_1+{\mathbf{u}}_2\end{array}\right]$$

$${\mathbf{z}}_1={\mathbf{u}}_1=[1,0,0,1{]}^{\mathsf{T}}$$

$${\mathbf{z}}_2={\mathbf{u}}_5=[1,1,1,0{]}^{\mathsf{T}}$$

$${\mathbf{z}}_3={\mathbf{u}}_2+{\mathbf{u}}_5=[2,1,2,0{]}^{\mathsf{T}}$$

$${\mathbf{z}}_4={\mathbf{u}}_1+{\mathbf{u}}_2=[2,0,1,1{]}^{\mathsf{T}}$$

$${\mathbf{z}}_3={\mathbf{u}}_2=[1,0,1,0{]}^{\mathsf{T}}$$

$${\mathbf{z}}_4={\mathbf{u}}_2=[1,0,1,0{]}^{\mathsf{T}}$$

$$q_j=\sum _{i=1}^t{\rho }_i+\sum _{i=t+1}^{\min (K,r)}{\rho }_i\sum _{k=0}^{t-1}\left(\genfrac{}{}{0ex}{}{i-1}{k}\right)p_j^k(1-p_j{)}^{i-k-1},$$

$$p_{j+1}=(1-q_j{)}^{\ell -1},$$

$$\underset{\ell \in \{2,3,\dots \}}{\min }\frac{\ell }{{\lambda }_T(\ell )}K.$$

$$\begin{gathered} c(t)K\left(t{\log }_2\left(\frac{\ell N}{c(t)K}+1\right)+1\right)+1\ge \\ c(t)K\beta \left(t{\log }_2\left(\frac{\ell N}{c(t)K\beta }+1\right)+1\right). \end{gathered}$$

$$p_{j+1}={\left(1-\sum _{i=1}^{\min (K,r)}{\rho }_i(1-p_j{)}^{i-1}\right)}^{\ell -1}.$$

$$p_{j+1}={\left(1-e^{-\lambda }\sum _{i=1}^{\min (K,r)}\frac{{\lambda }^{i-1}}{(i-1)!}(1-p_j{)}^{i-1}\right)}^{\ell -1}.$$

$$p_{j+1}={\left(1-e^{-\lambda p_j}\right)}^{\ell -1}.$$

$$\lambda =\left(\frac{\ln \left(1-p_{j+1}^{\frac{1}{\ell -1}}\right)}{-p_j}\right).$$

$${\lambda }_T(\ell )\triangleq \underset{0<x<1}{\inf }\left(\frac{\ln (1-x^{\frac{1}{\ell -1}})}{-x}\right).$$

$$\{\begin{array}{ll}{p}^{\ast }=0,& 0<\lambda <{\lambda }_T(\ell ),\\ p^{\ast }>0,& \lambda \ge {\lambda }_T(\ell ).\end{array}$$

Full text

I introduction

In this work, we consider the problem of Quantitative Group Testing (QGT). Consider a set of $N$ items among which $K$ items are defective. The QGT problem is to identify (all or a sufficiently large fraction of) the defective items, where the result of a test reveals the number of defective items in the tested group. The key difference between the QGT problem and the original group testing problem is that, unlike the former, in the latter the result of each test is either $1$ or [math] depending on whether the tested group contains any defective items or not. The objective of QGT is to design a test plan with minimum number of tests that identifies (all or a sufficiently large fraction of) the defective items.

There are two general categories of test strategies: non-adaptive and adaptive. In an adaptive scheme, each test depends on the outcomes of the previous tests. On the other hand, in a non-adaptive scheme, all tests are planned in advance. In other words, the result of one test does not affect the design of another test. Although, in general, adaptive algorithms require fewer tests, in most practical applications non-adaptive algorithms are preferred since they allow one to perform all tests at once in parallel.

Let $S$ be the index set of the defective items and $\hat{S}$ be an estimation of $S$. Depending on the application at hand, there can be different requirements for the closeness of $\hat{S}$ to $S$ [1, 2]. The strongest condition for closeness is exact recovery when it is required that $\hat{S}=S$. Two weaker conditions are partial recovery without false detections when it is required that $\hat{S}\subseteq S$ and $|\hat{S}|\geq(1-\epsilon)|S|$, and partial recovery without missed detections when it is required that $S\subseteq\hat{S}$ and $|\hat{S}|\leq(1+\epsilon)|S|$. There are also different types of the recovery guarantees [2]. The strongest guarantee is perfect recovery guarantee when the exact or partial recovery needs to be achieved with probability $1$ (over the space of all problem instances). A slightly weaker guarantee is probabilistic recovery guarantee when it suffices to achieve the exact or partial recovery with high probability only (and not necessarily with probability $1$). In this work, we are interested in the exact recovery of all defective items with the probabilistic recovery guarantee.

I-A Related Work and Applications

The QGT problem has been extensively studied for a wide range of applications, e.g., multi-access communication, spectrum sensing, and network tomography, see, e.g., [3, 4, 5], and references therein. This problem was first introduced by Shapiro in [6]. Several non-adaptive and adaptive QGT strategies have been previously proposed, see, e.g., [7, 3, 8]. It was shown in [9] that any non-adaptive algorithm must perform at least $(2K\log_{2}(N/K))/\log_{2}K$ tests. Various order optimal or near-optimal non-adaptive strategies were previously proposed, see, e.g., [9, 8, 7]. The best known polynomial-time non-adaptive algorithms require $K\log N$ tests [10, 9]. Recently, a semi-quantitative group testing scheme based on sparse graph codes was proposed in [11], where the result of each test is an integer in the set $\{0,1,2,\dots,L\}$. This strategy identifies a $(1-\epsilon)$ fraction of defective items using $c(\epsilon,L)K\log_{2}N$ tests with high probability, where $c(\epsilon,L)$ depends only on $\epsilon$ and $L$.

I-B Connection with Compressed Sensing

A closely related problem to QGT is the problem of compressed sensing (CS) in which the goal is to recover a sparse signal from a set of (linear) measurements. Given an $N$-dimensional sparse signal with a support size up to $K$, the objective is to identify the indices and the values of non-zero elements of the signal with minimum number of measurements. The main differences between the CS problem and the QGT problem are in the signal model and the constraints on the measurement matrix. Most of the existing works on the CS problem consider real-valued signals and measurement matrices. The QGT problem, however, deals with binary signals and requires the measurement matrix to be binary-valued.

There are a number of CS algorithms in the literature that use binary-valued measurement matrices, see, e.g. [12, 13] and references therein. However, these strategies either use techniques which are not applicable to binary signals, or provide different types of closeness and guarantee than those required in this work. There are also several CS algorithms for the support recovery where the objective is to determine the indices of the non-zero elements of the signal but not their values [14, 15, 16]. The support recovery problem is indeed equivalent to the QGT problem. Notwithstanding, the existing schemes for support recovery rely on non-binary measurement matrices, and hence are not suitable for the QGT problem.

Last but not least, to the best of our knowledge, the majority of works on the CS problem focus mainly on the order optimality of the number of measurements, whereas in this work for the QGT problem we are also interested in minimizing the constant factor hidden in the order.

I-C Main Contributions

In this work, we propose a non-adaptive quantitative group testing strategy for the sub-linear regime where $\frac{K}{N}$ vanishes as $K,N\rightarrow\infty$. We utilize sparse graph codes over bi-regular bipartite graphs with left-degree $\ell$ and right-degree $r$ and binary $t$-error-correcting BCH codes for the design of the proposed strategy. Leveraging powerful density evolution techniques for the analysis enables us not only to determine the exact value of constants in the number of tests needed but also to provide provable performance guarantees. We show that the proposed scheme provides exact recovery with probabilistic guarantee, i.e. recovers all the defective items with high probability. In particular, for the sub-linear regime, the proposed algorithm requires at most ${m=c(t)K\left(t\log_{2}\left(\frac{\ell N}{c(t)K}+1\right)+1\right)+1}$ tests to recover all defective items with probability approaching one as ${K,N\rightarrow\infty}$, where $c(t)$ depends only on $t$.

The results of our theoretical analysis reveal that the minimum number of required tests for the proposed algorithm is achieved by $t=2$. Moreover, for any $t\leq 4$, the encoding and decoding of the proposed algorithm have the computational complexity of $\mathcal{O}(K\log^{2}\frac{N}{K})$ and $\mathcal{O}(K\log\frac{N}{K})$, respectively.

II Problem Setup and Notation

Throughout the paper, we use bold-face small and capital letters to denote vectors and matrices, respectively.

In this work, we consider the problem of quantitative group testing (QGT) with exact recovery and probabilistic guarantee, defined as follows. Consider a set of $N$ items among which $K$ items are defective. We focus on the sub-linear regime where the ratio $\frac{K}{N}$ vanishes as $K,N\rightarrow\infty$. The problem is to identify all the defective items with high probability while using minimum number of tests on subsets (groups) of the items, where the result of each test shows the number of defective items in the tested group.

Let the vector $\mathbf{x}\in\{0,1\}^{N}$ represent the set of $N$ items in which the coordinates with value $1$ correspond to the defective items. A non-adaptive group testing problem consisting of $m$ tests can be represented by a measurement matrix ${\textbf{A}\in\{0,1\}^{m\times N}}$, where the $i$-th row of the matrix corresponds to the $i$-th test. That is, the coordinates with value $1$ in the $i$-th row correspond to the items in the $i$-th test. The results of the $m$ tests are expressed in the test vector $\mathbf{y}\in\{0,1,\dots\}^{m}$, i.e.,

[TABLE]

The goal is to design a testing matrix $\mathbf{A}$ that has a small number of rows (tests), $m$, and can identify with high probability all the defective items given the test vector $\mathbf{y}$.

III Proposed Algorithm

III-A Binary $t$-error-correcting codes and $t$-separable matrices

Definition 1**.**

($t$-separable matrix) A binary matrix ${\mathbf{D}\in\{0,1\}^{m\times n}}$ (for $n>t$) is $t$-separable over field $\mathbb{F}$ if the sum (over field $\mathbb{F}$) of any set of $t$ columns is distinct.

Example 1**.**

Consider the following matrix,

[TABLE]

The matrix $\mathbf{D}$ is $2$-separable over real field $\mathbb{R}$, but it is not $2$-separable over $\mathbb{F}_{2}$ since, for instance, the sum of the first and second columns over $\mathbb{F}_{2}$ is the same as the sum of the third and fourth columns over $\mathbb{F}_{2}$.

[TABLE]

From the definition, it can be easily seen that if a matrix $\mathbf{D}$ (with $n$ columns) is $t$-separable over a field $\mathbb{F}$, then $\mathbf{D}$ is also $s$-separable over $\mathbb{F}$ for any $1\leq s<t<n$.

The vector of test results, $\mathbf{y}$, is the sum of the columns in the testing matrix corresponding to the coordinates of the defective items. When a $t$-separable matrix over $\mathbb{R}$ is used as the testing matrix, the vector $\mathbf{y}$ will be distinct for any set of $t$ defective items. Thus, a $t$-separable matrix over $\mathbb{R}$ can be used as the testing matrix for identifying $t$ defective items. However, the construction of $t$-separable matrices for arbitrary $t$ with minimum number of rows is an open problem. Instead, we can leverage the idea that the parity-check matrix of any binary $t$-error-correcting code is a $t$-separable matrix over $\mathbb{F}_{2}$. Note that $t$-separability over $\mathbb{F}_{2}$ results in $t$-separability over $\mathbb{R}$. Hence, a possible choice for designing a $t$-separable matrix over $\mathbb{R}$ is utilizing the parity-check matrix of a binary $t$-error-correcting code.

In this work, we use binary BCH codes for this purpose. The key feature of the BCH codes which make them suitable for designing $t$-separable matrices is that it is possible to design binary BCH codes, capable of correcting any combination of $t$ or fewer errors.

Definition 2**.**

[17]** (Binary BCH codes) For any positive integers $m\geq 3$ and $t<2^{m-1}$, there exists a binary $t$-error-correcting BCH code with the following parameters:

[TABLE]

The $t\times n$ parity-check matrix of such a code is given by

[TABLE]

where $\alpha$ is a primitive element in $\mathbb{F}_{2^{m}}$.

Since each entry of $\mathbf{H}_{t}$ is an element in $\mathbb{F}_{2^{m}}$, it can be represented by an $m$-tuple over $\mathbb{F}_{2}$. Thus, the number of rows in the binary representation of $\mathbf{H}_{t}$ is given by

[TABLE]

III-B Encoding algorithm

The design of the measurement matrix $\mathbf{A}$ in our scheme is based on an architectural philosophy that was proposed in [2] and [18]. The key idea is to design $\mathbf{A}$ using a sparse bi-regular bipartite graph and to apply a peeling-based iterative algorithm for recovering the defective items given $\mathbf{y}$.

Let $G_{\ell,r}(N,M)$ be a randomly generated bipartite graph where each of the $N$ left nodes is connected to $\ell$ right nodes uniformly at random, and each of the $M$ right nodes is connected to $r$ left nodes uniformly at random. Note that there are $N\ell$ edge connections from the left side and $Mr$ edge connections from the right side,

[TABLE]

Let $\mathbf{T}_{G}\in\{0,1\}^{M\times N}$ be the adjacency matrix of the graph $G_{\ell,r}(N,M)$, where each column in $\mathbf{T}_{\mathcal{G}}$ corresponds to a left node and has exactly $\ell$ ones, and each row corresponds to a right node and has exactly $r$ ones. Let $\mathbf{t}_{i}\in\{0,1\}^{N}$ denote the $i$-th row of $\mathbf{T}_{G}$, i.e., $\mathbf{T}_{G}=[\mathbf{t}_{1}^{\mathsf{T}},\mathbf{t}_{2}^{\mathsf{T}},\cdots,\mathbf{t}_{M}^{\mathsf{T}}]^{\mathsf{T}}$. We assign $s$ tests to each right node based on a signature matrix $\mathbf{U}\in\{0,1\}^{s\times r}$. The signature matrix is chosen as ${\mathbf{U}=[\mathbf{1}_{1\times r}^{\mathsf{T}},\mathbf{H}_{t}^{\mathsf{T}}]^{\mathsf{T}}}$, where $\mathbf{1}_{1\times r}$ is an all-ones row of length $r$, and ${\mathbf{H}_{t}\in\{0,1\}^{t\log_{2}(r+1)\times r}}$ is the parity-check matrix of a binary $t$-error-correcting BCH code of length $r$. From (2), it can be easily seen that ${s=R+1=t\log_{2}(r+1)+1}$.

The measurement matrix is given by ${\mathbf{A}=[\mathbf{A}_{1}^{\mathsf{T}},\cdots,\mathbf{A}_{M}^{\mathsf{T}}]^{\mathsf{T}}}$ where ${\mathbf{A}_{i}\in\{0,1\}^{s\times N}}$ is a matrix that defines the $s$ tests at the $i$-th right node. There are exactly $r$ ones in each row $\mathbf{t}_{i}$ of $\mathbf{T}_{G}$, and the signature matrix $\mathbf{U}=[\mathbf{u}_{1},\mathbf{u}_{2},\cdots,\mathbf{u}_{r}]$ has $r$ columns. Note that $\mathbf{u}_{i}=[1,\mathbf{h}_{i}^{\mathsf{T}}]^{\mathsf{T}}$ is the $i$-th column of $\mathbf{U}$, where $\mathbf{h}_{i}$ is the $i$-th column of $\mathbf{H}_{t}$. $\mathbf{A}_{i}$ is obtained by placing the $r$ columns of $\mathbf{U}$ at the coordinates of the $r$ ones of the row vector $\mathbf{t}_{i}$, and replacing zeros by all-zero columns,

[TABLE]

where $\mathbf{t}_{i}=[0,\ldots,0,\hskip 2.58334pt1,\hskip 3.87495pt0,\ldots,\hskip 2.58334pt1,\hskip 3.87495pt0,\ldots,\hskip 3.87495pt1]$.

The number of rows in the measurement matrix $\mathbf{A}$, ${m=M\times s}$ where $s=t\log_{2}(r+1)+1$, represents the total number of tests in the proposed scheme.

Example 2**.**

Let $N=14$ be the total number of items. Let $G$ be a randomly generated left-and-right-regular graph with $N$ left nodes of degree $\ell=2$ and $M=4$ right nodes of degree $r=7$. For this example, suppose that the adjacency matrix $\mathbf{T}_{G}$ of the graph $G$ is given by

[TABLE]

Consider the parity-check matrix $\mathbf{H}_{1}$ of a binary $t=1$-error-correcting BCH code of length $r=7$ given by

[TABLE]

where $\alpha\in\mathbb{F}_{2^{3}}$ is a root of the primitive polynomial ${\alpha^{3}+\alpha+1=0}$. The signature matrix ${\mathbf{U}=[\mathbf{1}_{1\times 7}^{\mathsf{T}},\mathbf{H}_{1}^{\mathsf{T}}]^{\mathsf{T}}}$ is then given by

[TABLE]

Following the construction procedure explained earlier, the testing matrix $\mathbf{A}$ is then given by

[TABLE]

III-C Decoding algorithm

Let the observation vector corresponding to the $i$-th right node be defined as

[TABLE]

Note that ${\mathbf{z}_{i}=[y_{(i-1)s+1},\cdots,y_{is}]^{\mathsf{T}}}$.

Definition 3**.**

($t$-resolvable right node) A right node is called $t$-resolvable if it is connected to $t$ or fewer defective items.

The following lemma is useful for resolving the right nodes. (The proofs of all lemmas can be found in the appendix.)

Lemma 1**.**

The proposed algorithm detects and resolves all the $t$-resolvable right nodes.

The decoding algorithm performs in rounds as follows. In each round, the decoding algorithm first iterates through all the right node observation vectors $\{\mathbf{z}_{i}\}_{i=1}^{M}$, and resolves all $t$-resolvable right nodes (by BCH decoding, as discussed in the proof of Lemma 1). Then, given the identities of the recovered left nodes, the edges connected to these defective items are peeled off the graph. That is, the contributions of the recovered defective items will be removed from the unresolved right nodes so that new right nodes may become $t$-resolvable for the next round. The decoding algorithm terminates when there is no more $t$-resolvable right nodes.

Example 3**.**

Consider the group testing problem in the Example 2. Let the number of defective items be $K=3$ and let $\mathbf{x}=[1,0,0,1,0,0,0,0,0,1,0,0,0,0]^{T}$, i.e., item $1$, item $4$, and item $10$ are defective items. We show how the proposed scheme can identify the defective items. The result of the tests can be expressed as follows,

[TABLE]

Then, the right-node observation vectors are given by

[TABLE]

[TABLE]

[TABLE]

[TABLE]

Because the signature matrix is built using a $1$-separable matrix, each right node can be resolved if it is connected to at most one defective item.

Iteration $1$: we first find the $1$-resolvable right nodes. The first and second right nodes are $1$-resolvable because $z_{1,1}=z_{2,1}=1$. Using a BCH decoding algorithm, one can find that the defective items connected to the first and second right nodes are item $1$ and item $10$, respectively. Next, we remove the contributions of the items $1$ and $10$ from the unresolved right nodes. The new observation vectors will be as follows,

[TABLE]

[TABLE]

Iteration $2$: it can be easily observed that the third and forth right nodes are $1$-resolvable since $z_{3,1}=z_{4,1}=1$. Using a BCH decoding algorithm, it follows that the item $4$ is the defective item connected to both right nodes $3$ and $4$. Since all the $K=3$ defective items are identified, the decoding algorithm terminates.

IV Main Results

In this section, we present our main results. Theorem 1 characterizes the required number of tests that guarantees the identification of all defective items with probability approaching one as $K,N\rightarrow\infty$. Theorem 2 presents the computational complexity of the proposed algorithm. The proofs of Theorems 1 and 2 are given in Section V.

Theorem 1**.**

For the sub-linear regime, the proposed scheme recovers all defective items with probability approaching one (as $K,N\rightarrow\infty$) with at most ${m=c(t)K\left(t\log_{2}\left(\frac{\ell N}{c(t)K}+1\right)+1\right)+1}$ tests, where $c(t)$ depends only on $t$. Table I shows the values of $c(t)$ for $t\leq 8$.

Theorem 2**.**

The encoding and decoding of the proposed algorithm for any $t\leq 4$ have the computational complexity of $\mathcal{O}(K\log^{2}\frac{N}{K})$ and $\mathcal{O}(K\log\frac{N}{K})$, respectively.

V Proofs of Main Theorems

V-A Proof of Theorem 1

Let $N$ be the total number of items, out of which $K$ items are defective. Note that in the QGT problem, performing one initial test (on all items) would suffice to obtain the number of defective items. As mentioned in Section III-C, our scheme employs an iterative decoding algorithm. In each iteration, the algorithm finds and resolves all the $t$-resolvable right nodes. At the end of each iteration, the decoder subtracts the contribution of the identified defective items from the unresolved right nodes. This process is repeated until there is no $t$-resolvable right nodes left in the graph. The fraction of defective items that remain unidentified when the decoding algorithm terminates can be analyzed using density evolution as follows.

Assuming that the exact number of the defective items, $K$, is known and the values assigned to the defective and non-defective items are one and zero, respectively, the left-and-right-regular bipartite graph can be pruned. All the zero left nodes and their respective edges are removed from the graph. The number of left nodes in the pruned graph is $K$, but the degree of these nodes remains unchanged. On the other hand, the number of right nodes remains unchanged, but the resulting graph is not right-regular any longer.

Let $\lambda$ be the average right degree, i.e., $\lambda=\frac{K\ell}{M}$. Let $\rho(x)\triangleq\sum_{i=1}^{\min(K,r)}\rho_{i}x^{i-1}$ be the right edge degree distribution, where $\rho_{i}$ is the probability that a randomly picked edge in the pruned graph is connected to a right node of degree $i$, and $\min(K,r)$ is the maximum degree of a right node. As shown in [18], as $K,N\rightarrow\infty$, we have $\rho_{i}=e^{-\lambda}\frac{\lambda^{i-1}}{(i-1)!}$.

The following lemma is useful for computing the fraction of unidentified defective items at each iteration $j$ of the decoding algorithm.

Lemma 2**.**

Let $p_{j}$ be the probability that a randomly chosen defective item is not recovered at iteration $j$ of the decoding algorithm; and let $q_{j}$ be the probability that a randomly picked right node is resolved at iteration $j$ of the decoding algorithm. The relation between $p_{j}$ and $p_{j+1}$ is determined by the following density evolution equations:

[TABLE]

[TABLE]

where $t$ is the level of separability, and $\rho_{i}$ is the probability that a randomly picked edge in the pruned graph is connected to a right node of degree $i$.

Note that $p_{j}$ is only a function of the variables $t$, $\ell$, and $\lambda$ when $\min(K,r)\rightarrow\infty$. Recall that the goal is to minimize the total number of tests, i.e., ${M\times s}$, where $M$ is the number of right nodes, and $s$ is the number of rows in the signature matrix. The number of rows, $s$, in the signature matrix depends only on the level of separability, $t$. For a given $t$, we can minimize the number of right nodes ${M=\frac{\ell}{\lambda}K}$ subject to the constraint ${\lim_{j\rightarrow\infty}p_{j}(\ell,\lambda)=0}$, so as to minimize the total number of the tests. The constraint $\lim_{j\rightarrow\infty}p_{j}(\ell,\lambda)=0$ guarantees that running the decoding algorithm for sufficiently large number of iterations, the probability that a randomly chosen defective item remains unidentified approaches zero. For any ${\ell\geq 2}$, let ${\lambda_{T}(\ell)\triangleq\sup\{\lambda:\lim_{j\rightarrow\infty}p_{j}(\ell,\lambda)=0\}}$. Then, for any ${\ell\geq 2}$ and $\lambda<\lambda_{T}(\ell)$, we have ${\lim_{j\rightarrow\infty}p_{j}(\ell,\lambda)=0}$. Accordingly, for any ${\ell\geq 2}$ and $M=\frac{\ell}{\lambda}K>\frac{\ell}{\lambda_{T}(\ell)}K$, it follows that $\lim_{j\rightarrow\infty}p_{j}(\ell,\lambda)=0$. Our goal is then to compute

[TABLE]

We can solve this problem numerically and attain the optimal value of $\ell$, i.e., $\ell^{\star}$. Let ${c(t)\triangleq\frac{\ell^{\star}}{\lambda_{T}(\ell^{\star})}}$. The number of right nodes can then be chosen as ${M=c(t)K\beta}$ for any $\beta>1$ to guarantee that ${M>c(t)K=\frac{\ell^{\star}}{\lambda_{T}(\ell^{\star})}K}$. Substituting ${M=c(t)K\beta}$ in (3) results in ${r=\frac{\ell N}{c(t)K\beta}}$. Therefore, the total number of tests will become ${M\times s=c(t)K\beta\left(t\log_{2}\left(\frac{\ell N}{c(t)K\beta}+1\right)+1\right)}$.

Lemma 3**.**

There exist some $\beta>1$ such that

[TABLE]

By combining the result of Lemma 3 and the preceding arguments, it follows that with probability approaching one as $K,N\rightarrow\infty$, $m=c(t)K\left(t\log_{2}\left(\frac{\ell N}{c(t)K}+1\right)+1\right)+1$ tests would suffice for the proposed algorithm to recover all defective items. This completes the proof.

V-B Proof of Theorem 2

Lemma 4**.**

For any $t\leq 4$, the computational complexity of resolving each $t$-resolvable right node is $\mathcal{O}(\log r)$.

The total number of right nodes, $M$, is $\mathcal{O}(K)$. From Lemma 4, it then follows that the complexity of the decoding algorithm is $\mathcal{O}(K\log r)$. Using (3), it is easy to see that for any $t\leq 4$ the decoding algorithm has complexity $\mathcal{O}(K\log\frac{N}{K})$. The total number of measurements is $m$ and for each measurement $r$ summations are performed. Hence, the complexity of the encoding algorithm is $\mathcal{O}(mr)$, which becomes equivalent to $\mathcal{O}(K\log^{2}\frac{N}{K})$ for any $t\leq 4$.

VI Evaluation of $c(t)$

In this section, we present the complete analysis for the case of $t=1$, and show how one can evaluate $c(t)$ at $t=1$, i.e., $c(1)$. The same procedure can be used for evaluating $c(t)$ at any $t>1$.

To compute ${c(1)=\frac{\ell^{\star}}{\lambda_{T}(\ell^{\star})}}$, we compute the ratio $\frac{\ell}{\lambda_{T}(\ell)}$ for each $\ell\geq 2$ and its corresponding $\lambda_{T}(\ell)$. The optimal $\ell$, i.e., $\ell^{\star}$, is the one that yields the minimum value for $\frac{\ell}{\lambda_{T}(\ell)}$.

For the case of $t=1$, the density evolution equations (6) and (7) can be combined as

[TABLE]

Obviously, $p_{1}=1$. Substituting ${\rho_{i}=e^{-\lambda}\frac{\lambda^{i-1}}{(i-1)!}}$, we can rewrite (9) as

[TABLE]

For the sub-linear regime, $\frac{K}{N}\rightarrow 0$ (by definition) as $K,N\rightarrow\infty$, and hence, $r\rightarrow\infty$ (by (3)). Thus, in the asymptotic regime of our interest, $\min(K,r)\rightarrow\infty$. Letting $\min(K,r)\rightarrow\infty$, the equation (10) reduces to

[TABLE]

Using (11), we can write

[TABLE]

The following two lemmas are useful for computing $\lambda_{T}(\ell)=\sup\{\lambda:\lim_{j\rightarrow\infty}p_{j}(\ell,\lambda)=0\}$ for each $\ell\geq 2$.

Lemma 5**.**

For any $\ell\geq 2$ and any $\lambda>0$, the infinite sequence $\{p_{1},p_{2},\cdots\}$ converges.

Lemma 6**.**

Let $p^{*}$ be the limit of the sequence $\{p_{1},p_{2},\cdots\}$, and let

[TABLE]

Then, for any $\ell\geq 2$, we have

[TABLE]

By the result of Lemma 6, for any ${\ell\geq 2}$ the value of $\lambda_{T}(\ell)$ can be computed numerically. One can then obtain the optimal value of $\ell$, i.e., $\ell^{\star}$, which minimizes the ratio of $\frac{\ell}{\lambda_{T}(\ell)}$, and accordingly ${c(1)=\frac{\ell^{\star}}{\lambda_{T}(\ell^{\star})}}$ can be computed.

VII Comparison Results

In this section we will evaluate the performance of the proposed algorithm based on our theoretical analysis and the Monte Carlo simulations.

Based on the results in Theorem 1 and Table I, Fig. 2 depicts the total number of tests ($m$) required to identify all the defective items for different values of $t$. The number of items is assumed to be $N=2^{16}$. As it can be seen, when $t\in\{1,2,3\}$ the required number of tests for identifying all the defective items is less than that for larger values of $t$.

Using the Monte Carlo simulation, we also compare the performance of the proposed scheme for $t\in\{1,2,3\}$ with the performance of the Multi-Level Group Testing (MLGT) algorithm from [11]. The MLGT scheme is a semi-quantitative group testing scheme where the result of each test is an integer in the set $\{0,1,2,\cdots,L\}$. Letting ${L\rightarrow\infty}$, the MLGT scheme becomes a QGT scheme. Based on the optimization that we have performed, the optimal left degree for the MLGT scheme is $\ell^{\star}=3$ when $L\rightarrow\infty$. For $K=100$ defective items among a population of $N=2^{16}$ items, the average fraction of unidentified defective items for the MLGT scheme and the proposed scheme are shown in Fig. 3 for different values of $m/K$. As it can be observed, the proposed scheme for all the three tested values of $t$ outperforms the MLGT scheme significantly. For instance, when the fraction of unidentified defective items is $2\times 10^{-4}$, the required number of tests for the MLGT scheme (for $\ell=3$) is $3$ times, $5$ times, and $7$ times more than that of the proposed scheme for $t=1$, $t=2$, and $t=3$, respectively.