One-Shot Pooled COVID-19 Tests via Multi-Level Group Testing

Abstract

A key requirement in containing contagious diseases, like the COVID-19 pandemic, is the ability to efficiently carry out mass diagnosis over large populations, especially when testing resources are limited and rapid identification is essential for outbreak control. Some of the leading testing procedures, such as those utilizing qualitative polymerase chain reaction, involve using dedicated machinery which can simultaneously process a limited amount of samples. A candidate method to increase the test throughput is to examine pooled samples comprised of a mixture of samples from different patients. In this work, we study pooling-based tests which operate in a one-shot fashion, while providing an indication not solely on the presence of infection, but also on its level, without additional pool-tests, as often required in COVID-19 testing. As these requirements limit the application of traditional group-testing (GT) methods, we propose a multi-level GT scheme, which builds upon GT principles to enable accurate recovery using much fewer tests than patients, while operating in a one-shot manner and providing multi-level indications. We provide a theoretical analysis of the proposed scheme and characterize conditions under which the algorithm operates reliably and at affordable computational complexity. Our numerical results demonstrate that multi-level GT accurately and efficiently detects infection levels, while achieving improved performance and less pooled tests over previously proposed oneshot COVID-19 pooled-testing methods. Our simulations show that the efficient method proposed in this work can correctly identify the infected items and their infection levels with high probability at the known upper bound (for a maximum likelihood decoder in GT) on the number of tests. We also show that the method works well in practice when the number of infected items is not assumed to be known in advance.

1. Introduction

The Coronavirus Disease 2019 (COVID-19) pandemic forced lockdowns all over the globe, and claimed more than seven million lives worldwide [1]. In order to handle and contain pandemics, and particularly COVID-19, large portions of the population should be frequently tested [2]. One of the main difficulties in doing so stems from the limited testing resources and the lengthy duration required to identify the presence of an infection [3,4]. In particular, the main diagnosis tool for COVID-19 tests is based on Ribonucleic acid (RNA) extraction via qualitative reverse transcription polymerase chain reaction (RT-qPCR). Although various technological alternatives have been proposed [5,6], such as the rapid lateral-flow antigen tests, and rapid lateral-flow tests based on Clustered Regularly Interspaced Short Palindromic Repeats (CRISPR) gene-editing technology [7] and the Reverse Transcription Loop-Mediated Isothermal Amplification (RT-LAMP) [8], the qualitative reverse transcription polymerase chain reaction (RT-qPCR) process remains the most accurate method for COVID-19 testing. The output of this procedure represents an estimate of the viral load in the tested sample [9]. This estimation indicates the infection process and progress (when it exists and starts), e.g., for Syndrome Coronavirus 2 (SARS-CoV-2) in the cell and between cells [10]. The more efficient the virus is at entering and replicating in cells, the faster the viral load builds up. In practice, viral load analysis (when it is detected) is a complicated phenomenon that is widely considered in the medical and biological community, and there are certain factors impacting it, such as the presence/absence of specific Angiotensin-Converting Enzyme 2 (ACE2) mutations in an individual or the specific mutations accumulated in the S-protein of SARS-CoV-2. These factors are crucial to learn and conclude on the viral infection. In this work, we focus on efficient viral load detection from tested samples. We refer to the literature for more information on the viral load analysis [11,12]. Now, the main bottleneck associated with this form of COVID-19 testing follows from the fact that each qualitative reverse transcription polymerase chain reaction (RT-qPCR) machine can simultaneously process a fixed number of samples, and its procedure tends to be quite lengthy, on the order of a few hours for each test [13,14]. Computational and algorithmic methods have shown great promise in alleviating these challenges, especially during the time of limited testing resources [15].

A promising method to tackle this lengthy measurement procedure and thus to increase the efficiency of COVID-19 tests is based on pooling [16,17]. Here, each sample processed, i.e., each input to the qualitative reverse transcription polymerase chain reaction (RT-qPCR) machine, is comprised of a mixture of several samples taken from different patients. When the infected patients constitute a small subset of the overall tested individuals, pooling-based schemes allow accurate recovery using a number of tests which is notably smaller than the number of patients [18]. Several recovery schemes for pooled COVID-19 tests have been recently proposed [17,19,20,21,22,23,24,25], which can be divided according to the two main mathematical frameworks for such recovery procedures: The first is group-testing theory, originally derived for detecting infections in large populations [26], used in [16,17,19]. Group testing (GT) was first suggested to identify syphilis-infected draftees during World War II [26], and has been long studied and utilized in many fields, such as computational biology [27], biology and chemistry [28,29], communications [30,31,32], sensor networks [33], pattern matching [34], web services [35], and cyber security [36,37,38]. The second framework is compressed sensing, which deals with the recovery of sparse signals [39], and was utilized for pooled COVID-19 tests in [20,21,22,23,24,25]. Another interesting recovery method, which can be seen as an extension of classical group testing (GT), is the Semi-Quantitative Group Testing (SQGT) scheme [40]. This method assumes that varying material can be extracted from different items, resulting in discrete non-binary pooling matrices. This scheme can be useful for conflict resolution in multiple access channels and genotyping [40].

One of the main differences between classical group testing (GT) and compressed sensing (CS) is that GT deals with group detection problems, which results in binary variables. Specifically, in GT, each subject can either be infected or not infected [18], while compressed sensing (CS)-based methods result in real-valued variables. GT is traditionally adaptive, requiring multiple sequential tests [26] in order to achieve a minimal number of overall tests from which the presence of infection can be inferred. Nonetheless, GT can also be applied in a one-shot (non-adaptive) manner [41], avoiding the need to mix new samples during the testing procedure. CS focuses on the one-shot recovery of sparse real-valued vectors from lower-dimensional linear projections, and thus each subject can take any real value number [39]. The additional domain knowledge of GT, namely, the more restricted binary domain over which it operates compared to CS, allows it in some applications to operate using fewer measurements compared to CS, as shown in [42,43] in the context of quantization of sparse signals.

When testing for contagious diseases, and particularly for COVID-19, one is often interested in obtaining some score on the level of the viral load of the patients due to its epidemiological value [21,44,45]. This score is called the infection level. The infection level can correspond to an estimate of the viral load, which in turn can map to the threshold cycle value of RT-qPCR testing. For example, [46] uses viral loads to determine the effectiveness of different quarantine methods. This can be achieved using CS tools. The fact that GT and CS have their own pros and cons for pooled testing motivates the design of a recovery method which combines GT with one-shot operation and multi-level detection, as in CS.

Neither GT nor CS fully address the challenges posed by the need to identify infection levels during an ongoing pandemic of a large scale. In this work, we propose a multi-level GT recovery scheme for pooled testing. Our proposed GT-based method is designed to account for the unique characteristics of pooled tests for contagious diseases, and particularly those arising in COVID-19 testing. The proposed technique extends GT schemes to detect multiple levels of viral load, building upon our previous results on combining GT with CS concepts and multi-level discretization in [42]. The resulting multi-level GT scheme operates in a one-shot manner, and is designed to avoid dilution due to mixing too many samples in each pool [4]. This is a novel approach that identifies the non-binary infection levels, as opposed to classical GT, while requiring significantly less pooled tests than CS-based approaches. In fact, we demonstrate that our method achieves the upper bound on the number of tests of a maximum likelihood (ML) decoder, while having significantly lower complexity than a maximum likelihood (ML) decoder. All of these characteristics, alongside the proven low complexity regime in which our method works in the context of COVID-19, makes it particularly attractive for large-scale infection level detection among large populations. A comparison between the methods is available in

Table 1. Comparison of testing methods.

Method	Output Type	Identical Pooled Material	Required Number of Tests
GT	Boolean	Yes	Low
CS	Viral load	Yes	High
SQGT	Infection level	No	Low
Multi-level GT	Infection Level	Yes	Low

. Note that our proposed multi-level GT method can be readily altered to return viral loads instead of infection levels, by removing the quantization at the end.

We begin by identifying the specific requirements which arise from the setup of pooled COVID-19 testing. From these requirements, we derive the multi-level GT method. Our scheme is comprised of $\left(a\right)$ a dedicated testing matrix, determining which patients are pooled together into each test; and $\left(b\right)$ a GT-based recovery method operating in a two-stage manner, by first identifying the defective patients building upon classic GT tools, followed by a dedicated mechanism for characterizing the level of infection for the identified patients.

We theoretically analyze the proposed multi-level GT scheme. We first characterize its associated computational complexity, which is shown to be dominated by the identification of the defective subjects in the first stage of the proposed algorithm. As the complexity formulation results in a random quantity which depends on the statistical modeling of the measurement procedure, we derive the expected computational burden, and show that it results in a number of computations which is of the same order as that of low-complexity CS-based methods. Next, we derive sufficient conditions for the algorithm to yield a unique solution. While similar guarantees are also available for CS-based methods, we numerically demonstrate that our proposed scheme achieves improved accuracy over CS-based pooled recovery. While GT has been shown to be effective in real settings, and for COVID-19 in particular [47,48,49], obtaining real-world data can be challenging [50]. We therefore conduct our experimental results using the model proposed in [21] for pooled RT-qPCR testing. For these setups, we demonstrate that our multi-level GT scheme reliably recovers the infection levels, while operating at a limited computational burden, and achieves improved accuracy over existing CS-based approaches.

The rest of this paper is organized as follows: Section 2 reviews the system model, focusing on pooled COVID-19 testing and identifies the unique requirements of this procedure. Section 3 presents the proposed multi-level GT scheme. In Section 4, we analyze our approach, identifying sufficient conditions for it to reliably detect the level of infection of each patient, and characterize its complexity. Section 5 details the simulation study, and Section 6 provides concluding remarks.

Throughout the paper, we use boldface lower-case letters for vectors, e.g., $\mathit{x}$. Matrices are denoted with boldface upper-case letters, e.g., $\mathit{M}$. Let $\mathit{M}\left(i,j\right)$ denote the element at the i-th row and j-th column of $\mathit{M}$. Sets are expressed with calligraphic letters, e.g., $\mathcal{X}$, and ${\mathcal{X}}^n$ is the n-th order Cartesian power of $\mathcal{X}$. The stochastic expectation is denoted by $\mathbb{E}\{·\}$, ⋁ and ⊕ are the Boolean OR and XOR operations, respectively, and ${\mathbb{R}}_{+}$ is the set of non-negative real numbers.

2. System Model

In this section, we present the system model for which we derive the recovery algorithm in Section 3. We begin by identifying the specific characteristics of pooled COVID-19 tests in Section 2.1, based on which we present our problem formulation in Section 2.2.

2.1. Pooled COVID-19 Tests

The common approach in testing for the presence of COVID-19 is based on the RT-qPCR method. Here, a sample is collected, most commonly based on nasopharyngeal or oropharyngeal swabs or saliva. The presence of infection is then examined by Ribonucleic acid (RNA) extraction via RT-qPCR measurements, quantifying the viral load in the sample. The RT-qPCR process is quite time consuming (on the typical order of several hours), and can simultaneously examine up to a given number of m inputs (commonly on the order of several tens of samples). This results in a major bottleneck, particularly when the number of patients, denoted by n, is much larger than m.

A candidate approach to reduce the test duration, which is considered in this paper, utilizes pooling [16]. Pooling mixes the samples of groups of patients together, forming m mixed samples out of the overall n patients. Then, the presence of COVID-19 for each of the tested individuals is recovered from the mixed RT-qPCR measurements, either directly, i.e., in a one-shot fashion, or in an adaptive manner involving additional tests [51]. Some characteristics of COVID-19 tests are the following:

Assumption 1.

The number of infected measurements, denoted by k, is much smaller than the number of tested individuals n. Typically, up to 10% of the tested population is infected.

Assumption 2.

One is interested not only in identifying whether a subject is infected, but also in some discrete score on the viral load. For example, possible outputs are no (no virus), low (borderline), mid (infected), and high (highly infected).

Assumption 3.

The RT-qPCR measurements are noisy, i.e., some level of random distortion is induced in the overall process, encapsulating the randomness in the acquisition of the samples, their mixing, and the RT-qPCR reading.

Assumption 4.

One-shot tests are preferable, where we fully identify all subjects from a single RT-qPCR operation, without having to carry out additional tests based on the results.

Assumption 5.

There is a limit, denoted by $L>1$, on the number of subjects which can be mixed together in a single measurement. A typical limit on the number of subjects mixed together is $L=32$ [16]. Furthermore, the portion taken from each sample for the pooled measurements is identical, e.g., one cannot mix 30% from one patient with 70% from another patient into a single pool.

While the characteristics are identified for swab-based RT-qPCR tests, they also hold for other forms of contagious disease testing, including, e.g., serological tests [52]. Assumption 5 is crucial when dealing with a pandemic, as extracting different samples from different items can be cumbersome for laboratory technicians, impractical in many cases, and prone to human errors. We note that Assumption 5 is violated in the Semi-Quantitative Group Testing (SQGT) scheme.

An illustration of the overall flow of pooled RT-qPCR-based COVID-19 testing along with the desired one-shot recovery operation is depicted in Figure 1. On the left side of the figure, we show the true viral loads of all n items, where the first item is infected in a medium level, the fourth item is infected in a low level, and all other items are not infected. Next, pooling is conducted based on a testing matrix, which is generated prior to obtaining the samples. For example, the first pooled test involves samples from the first, third, and fifth items. This results in a measurement vector, denoted by $\mathit{z}$. This vector is fed to the recovery algorithm, which is able to tell in one shot that the first item is infected in a medium level, the fourth item is infected in a low level, and all other items are not infected.

2.2. Problem Formulation

Based on the characteristics of pooled COVID-19 tests detailed above, we consider the following problem: Let $\mathit{x}\in {\mathbb{R}}_{+}^n$ be a vector whose entries are the viral loads of the n patients. By Assumption 1, it holds that $\mathit{x}$ is k-sparse, i.e., ${\parallel \mathit{x}\parallel }_0\le k$. The pooling operation is represented by the matrix $\mathit{A}\in {\{0,1\}}^{m\times n}$. Let $l\left(i\right)\le L$ denote the number of subjects mixed together in the i-th individual pool, $i\in \{1,\dots ,m\}$. This implies that the i-th row of $\mathit{A}$, denoted by ${\mathit{A}}_i^T$, is $l\left(i\right)$-sparse by Assumption 5. The viral loads of the pooled samples are represented by the vector $\mathit{z}\in {\mathbb{R}}_{+}^m$, whose entries are given by ${\mathit{z}}_i={\displaystyle \frac{1}{l\left(i\right)}}{\mathit{A}}_i^T\mathit{x},i\in \{1,\dots ,m\}$, where the factor ${\displaystyle \frac{1}{l\left(i\right)}}$ and the structure of $\mathit{A}$ guarantee that identical portions are taken from each sample in a pool-test, as required in Assumption 5. The RT-qPCR measurements, denoted by $\mathit{y}\in {\mathbb{R}}_{+}^m$, are given by some stochastic mapping $f:{\mathbb{R}}_{+}\mapsto {\mathbb{R}}_{+}$ applied to $\mathit{z}$. This mapping represents the distortion detailed in Assumption 3, and we write the measurements as $\mathit{y}=f\left(\mathit{z}\right)$, where $f(·)$ is carried out element-wise.

To formulate our objective, we note that by Assumption 2, we are interested in recovering a discrete representation of the viral load. We thus define the discretization mapping $Q:{\mathbb{R}}_{+}\mapsto \mathcal{Q}$, where $\mathcal{Q}$ is a finite set containing the possible decisions, e.g., $\mathcal{Q}=\{no,low,med,high\}$. The decision regions are defined by the pre-specified thresholds ${\tau }_1,\dots ,{\tau }_{\left|\mathcal{Q}\right|-1}$, such that a value not larger than ${\tau }_1$ is treated and not infected, while, e.g., a value in the range $({\tau }_1,{\tau }_2]$ is treated as a low level of infection. Our goal is to design an algorithm which maps the RT-qPCR measurements $\mathit{y}$ into an estimate of the discretized viral loads, denoted by $\widehat{\mathit{x}}\in {\mathcal{Q}}^n$. We wish to minimize the error probability, defined as $e\left(\widehat{x}\right)\triangleq {\displaystyle \frac{1}{n}}{\sum }_{i=1}^n\mathrm{Pr}\left(Q\left(x_i\right)\ne {\widehat{x}}_i\right)$. The fact that $\widehat{\mathit{x}}$ is obtained directly from $\mathit{y}$ indicates that the algorithm operates in a one-shot fashion, as required in Assumption 4. By Assumption 1, we have prior knowledge of a reliable upper bound on the number of infected patients k. Such a bound is often obtained by pooling asymptomatic subjects, for which the infection ratio is typically low, on the order of 1% [20]. When k is not known or the given bound is expected to be loose, one of the methods proposed in the GT literature to approximate this number within $\mathcal{O}\left(\log n\right)$ tests can be used, e.g., [53,54].

To summarize, for the subset of k infected items of a total of n inspected patients, the goal in multi-level pooled testing is to design an $m\times n$ one-shot pooling pattern $\mathit{A}$ and a corresponding recovery algorithm for reconstructing $\widehat{\mathit{x}}$ from $\mathit{y}$. The measurement matrix should guarantee that, at most, L subjects are mixed in each pool-test. We aim to identify the subset of infected items and their discrete representation of the viral load using the recovery algorithm from $\mathit{y}$.

3. Multi-Level Group Testing

In this section, we provide an efficient scheme which implements GT with multiple decisions. Our design builds upon the fact that the sparsity Assumption 1 implies that the recovery of pooled RT-qPCR tests can be treated as a sparse recovery problem, which is typically studied under either the framework of GT [18], or that of CS [39]. Broadly speaking, GT deals with sparse recovery of binary variables, i.e., it can recover whether a subject is infected or not. In order to evaluate the actual levels of each tested subject, as requested in Assumption 2, one would have to re-run the RT-qPCR test, violating requirement Assumption 4. The alternative approach of CS operates over the domain of real numbers, namely, it attempts to identify the exact cycle threshold or viral load for each subject, and thus tends to be less accurate compared to GT, as it does not exploit the fact that one is only interested in a discrete grade value by Assumption 2. This motivates the derivation of a dedicated algorithm for pooled COVID-19 recovery, which harnesses the strength of GT theory while extending it to the multi-level domain. The proposed multi-level GT method is presented in Section 3.1, followed by a discussion in Section 3.2.

3.1. Pooled-Testing Algorithm

Multi-level GT is comprised of two components: the design of the testing matrix $\mathit{A}$, which determines the pooling operation; and the recovery algorithm which determines the discrete level associated with each subject based on the results of the pooled tests. We next elaborate on each of these components.

3.1.1. Pooling Procedure

To determine $\mathit{A}$, we first fix the number of the pool-tests m. In principle, m should satisfy $m=\lceil (1+ϵ)k{\log }_{2}n\rceil$ (where the $\lceil \rceil$ is often omitted for ease of read), for some $ϵ>0$, as this is the sufficient number of pool-test for reliable recovery in GT using the optimal maximum likelihood (ML) decoder [55,56]. The parameter $ϵ$ controls the probability of error of the procedure [55], as we illustrate in Section 5. In practice, the number of pools-tests is often dictated by the measurement setup, e.g., it may be constrained to be an integer multiple of the number of inputs accepted by an RT-qPCR machine. Unless stated otherwise, we assume that $m=(1+ϵ)k{\log }_{2}n$, and in Section 4, we prove that this number of samples is sufficient to detect the infection levels using the proposed algorithm.

Once m is fixed, we proceed to setting $\mathit{A}$, whose binary entries dictate which patient is mixed into which pool. The traditional GT method of generating $\mathit{A}$ draws its elements in an i.i.d. fashion according to a Bernoulli distribution with parameter p. A common choice for p is $p=1-2^{-1/k}$, for which the probability of each element in $\mathit{z}$ to be zero is $1/2$. We note that an approximation of $p=1-2^{-1/k}\approx \ln 2/k$ is often used [57]. This approximation yields an error term of the order of $\mathcal{O}\left(1/k^2\right)$; hence, it is negligible for sufficiently large values of k. When k is unknown, p is chosen using a rough approximation of k. A major drawback of this approach is that Assumption 5 is not necessarily satisfied, and there is some chance that too many patients will be mixed into the same pool, causing dilution. We therefore consider an alternative method, which forces the columns of $\mathit{A}$, as well as the rows of $\mathit{A}$, to be “typical”. That is, we want every column/row to have exactly $\lceil p·m\rceil \le L$ and $\lceil p·n\rceil$ ones, respectively. This ensures that with high probability, half of the elements of $\mathit{z}$ are zero, which, in turn, reduces the required pooled tests, as demonstrated in Section 5. This requirement cannot be guaranteed in the non-asymptotic regime by generating the elements of $\mathit{A}$ in an i.i.d. fashion; hence, we force $\mathit{A}$ to be typical.

Since in practical testing setups, one is interested in using a fixed deterministic matrix rather than having to work with random matrices, we generate $\mathit{A}$ once before the pooling starts. A typical matrix is not unique, and in fact, there are many typical matrices. Generating a typical matrix that satisfies Assumption 5 and the number of required pool-tests for recovery can be performed readily. The same testing matrix can be used for multiple pooling experiments.

3.1.2. Recovery Algorithm

The proposed recovery algorithm is given in Algorithm 1. It operates in two main steps: The first step treats the recovery as a GT setup, and thus aims to divide the patients into infected and non-infected. The second step accounts for the multi-level requirement Assumption 2, and uses decisions made in the first step to determine the infection levels.

Step 1: Detection of Defective Subjects. The first part of the algorithm identifies efficiently all of the definitely defective items in two stages, without determining the infection levels. It does so by treating the problem, in which the observations and the viral loads take continuous non-negative values in general, as a GT setup which operates over binary variables. Hence, in this step, we use a binary representation of the real-valued $\mathit{y}$, denoted $Q_{0,1}\left(\mathit{y}\right)$, where $Q{(·)}_{0,1}$ divides each measured pool into infected and non-infected. Recalling that the viral level decisions are defined by the thresholds $\{{\tau }_1,\dots ,{\tau }_{\left|\mathcal{Q}\right|-1}\}$, the i-th element of $Q_{0,1}\left(\mathit{y}\right)$, denoted ${\left[Q_{0,1}\left(\mathit{y}\right)\right]}_i$, is given by

$${\left[Q_{0,1}\left(\mathit{y}\right)\right]}_i=\left\{\begin{array}{cc}0\hfill & y_i\le {\tau }_1,\hfill \\ 1\hfill & y_i>{\tau }_1,\hfill \end{array}\right.i=1,\dots ,m.$$

(1)

Algorithm 1 Multi-level GT recovery.
Input: $\mathit{A},\mathit{y}$
Output: $\mathcal{S}$	▹$\mathcal{S}$ contains index and infection level tuples
1:$\mathcal{S}\leftarrow \varnothing$
Step 1: Detection of defective subjects
2:$\mathcal{P}\leftarrow \mathrm{DND}(Q_{0,1}\left(\mathit{y}\right),\mathit{A})$	▹$\mathcal{P}$ contains PD items
3: $\mathcal{D}\leftarrow \mathrm{ML}(Q_{0,1}\left(\mathit{y}\right),\mathit{A},\mathcal{P})$	▹$\mathcal{D}$ contains DD items
4: $\widehat{\mathit{A}}\leftarrow {\mathit{A}}_{\mathcal{D}}$
Step 2: Infection level recovery
Option 1: Least squares method
5: Solve least squares (LS) problem (3)
6: for all i s.t. $i\in \left\{1,\dots ,\left|\mathcal{D}\right|\right\}$ do
7:       $\mathcal{S}\leftarrow \mathcal{S}\cup \left\{\mathcal{D}\left(i\right),Q\left({\mathit{x}}_{{\mathcal{D}}_i}\right)\right\}$
8: end for
Option 2: Iterative method
9: $\overline{\mathit{y}}\leftarrow {\sum }_{i\in \mathcal{D}}{\mathit{A}}_i$
10: while $\left|\mathcal{S}\right|<K$ do
11:       for all i s.t. ${\overline{\mathit{y}}}_i=1$ do
12:             $j\leftarrow$ index s.t. ${\widehat{\mathit{A}}}_{i,j}=1$
13:             ${\widehat{\mathit{x}}}_i\leftarrow Q\left({\mathit{y}}_i\right)$
14:             $\mathcal{S}=\mathcal{S}\cup \left\{(\mathcal{D}\left(j\right),{\widehat{\mathit{x}}}_i)\right\}$
15:             $\overline{\mathit{y}}\leftarrow \overline{\mathit{y}}-{\mathit{A}}_j$	▹ From line 12
16:            $\mathit{y}\leftarrow \mathit{y}-{\mathit{A}}_j·{\mathit{y}}_i$
17:      end for
18: end while
Definitely Not Defective (DND) [41]
19: procedure DND($Q_{0,1}\left(\mathit{y}\right),\mathit{A}$)
20:      $\mathcal{P}\leftarrow \left\{1,\dots ,n\right\}$
21:      for all i s.t. $Q_{0,1}{\left(\mathit{y}\right)}_i=0$ do
22:            for all j s.t. ${\mathit{A}}_{i,j}=1$ do
23:               $\mathcal{P}\leftarrow \mathcal{P}\setminus \left\{j\right\}$
24:            end for
25:      end for
26:      return $\mathcal{P}$
27: end procedure
Maximum Likelihood (ML) [55] over Possibly Defective (PD) subjects $\mathcal{P}$
28: procedure ML($Q_{0,1}\left(\mathit{y}\right),\mathit{A},\mathcal{P}$)
29:      return $\arg {\min }_{\tilde{\mathcal{D}}\subset \mathsf{\Omega }(\mathcal{P},k)}{Q}_{0,1}\left(\mathit{y}\right)\oplus \left({\bigvee }_{k\in \tilde{\mathcal{D}}}{\mathit{A}}_k\right)$
30: end procedure

In the first stage of the first step, the definitely not defective (DND) algorithm [58] is used (lines 2 and 19–27). This stage removes all items which are definitely not defective, resulting only in a smaller possibly defective set $\mathcal{P}$. Recall that the number of pool-tests m, dictated by the testing matrix $\mathit{A}$, is fixed to allow maximum likelihood (ML) detection. The definitely not defective (DND) algorithm attempts to match the columns of $\mathit{A}$ with the vector $Q_{0,1}\left(\mathit{y}\right)$. In particular, if column j of $\mathit{A}$ has a non-zero entry while the corresponding element in $Q_{0,1}\left(\mathit{y}\right)$ is zero, the column is assumed not to correspond to a defective subject. This algorithm finds most of the subjects that are definitely not defective (DND) and drastically reduces the number of possible defective (PD) items. The set of subjects declared as possible defective (PD) after this stage, denoted by $\mathcal{P}$, is shown to be indeed much smaller than the number of patients n; this is proved rigorously in Section 4, and demonstrated empirically in our numerical study in Section 5. In particular, in Section 4, we give a precise expression for the expected size of $\mathcal{P}$. We show that $\mathbb{E}\left(\right|\mathcal{P}\left|\right)\ll n$ in the non-asymptotic regime that is of interest for COVID-19 pooled testing, and numerically assert these claims, showing that, typically, $\left|\mathcal{P}\right|<3k$. The remaining $n-\left|\mathcal{P}\right|$ subjects are declared not defective.

The fact that the number of possible defective (PD) subjects is notably smaller than the overall number of patients is exploited in the second stage of the first step, which determines the set of definitely defective (DD) patients. Here, the Boolean ML algorithm [55] is used only over the smaller set of PD subjects $\mathcal{P}$, to identify exactly the set $\mathcal{D}$ of k definitely defective (DD) subjects (lines 3 and 28–30). We use ML over the subset $\mathcal{P}$ rather than over all the patients, allowing us to carry out this typically computationally prohibitive method at affordable complexity, as we show in Section 4.5. The ML algorithm looks for a collection of k columns in $\mathit{A}$, for which $Q_{0,1}\left(\mathit{y}\right)$ is most likely. The ML decision rule is given by

$$\mathcal{D}=\underset{\tilde{\mathcal{D}}\subset \mathsf{\Omega }(\mathcal{P},k)}{\arg \min }{Q}_{0,1}\left(\mathit{y}\right)\oplus \left(\underset{k\in \tilde{\mathcal{D}}}{\bigvee }{\mathit{A}}_k\right).$$

(2)

In the ML rule, we denote by $\mathcal{K}$ the set of defective subjects, and by $\mathsf{\Omega }(\mathcal{P},k)$ the set of $\left({\displaystyle \genfrac{}{}{0pt}{}{\left|\mathcal{P}\right|}{k}}\right)$ combinations of k defective subjects in $\mathcal{P}$. While the formulation here is given with the true number of infected patients k, in practice, it is carried out with k (which is unknown) replaced by an approximation or an available upper bound on it.

Step 2: Infection Level Recovery. The output of the first step is a division of the patients into infected and non-infected, encapsulated in the set of identified defective subjects $\mathcal{D}$. In the second step, the algorithm estimates the infection level of each subject in $\mathcal{D}$. We provide two methods to do so:

Option 1—least squares: The first option uses least squares (LS) estimation [59] to identify the viral loads of all definitely defective (DD) items (line 5):

$${\widehat{\mathit{x}}}_{\mathcal{D}}=\underset{{\mathit{x}}_{\mathcal{D}}}{\arg \min }{\parallel \mathit{y}-{\mathit{A}}_{\mathcal{D}}{\mathit{x}}_{\mathcal{D}}\parallel }_2^2,$$

(3)

where ${\mathit{A}}_{\mathcal{D}}$ denotes the matrix created by taking the columns of $\mathcal{D}$ from $\mathit{A}$. The output of the algorithm is the infected items, and the quantized infection levels $Q\left({\mathit{x}}_{\mathcal{D}}\right)$ (line 10) using the threshold-based quantization mapping $Q(·)$ defined in Section 2.2, where a value of “not infected” is given to all items not in $\mathcal{D}$. For the LS solution in (3) to be unique, we should have $\mathrm{rank}\left({\mathit{A}}_{\mathcal{D}}\right)=k$. In this case, (3) is given by

$${\widehat{\mathit{x}}}_{\mathcal{D}}={\left({\mathit{A}}_{\mathcal{D}}^T{\mathit{A}}_{\mathcal{D}}\right)}^{-1}{\mathit{A}}_{\mathcal{D}}^T\mathit{y}.$$

(4)

When the measurement process induces some known non-linearity, it can be incorporated into (3), resulting in a non-linear LS formulation. The LS operation outputs a real-valued vector, while the discrete levels are obtained by quantizing the entries of (4). Note that ${\mathit{x}}_{\mathcal{D}}$ has to be non-negative; thus, one can compute the LS in (3) while constraining the entries of ${\mathit{x}}_{\mathcal{D}}$ to be non-negative. Here, we omit this constraint; the simulations conducted in Section 5 show that omitting this constraint does not affect the performance of the algorithm in the case studied in this paper. However, in the general setting, this constraint can be easily included if needed [60]. We choose this method in our analyses below, namely, the complexity analysis and the theoretical performance guarantees characterized in the sequel consider Algorithm 1 implemented with the LS recovery option. Nonetheless, we also provide an additional method to recover the infection levels based on iterative detection.

Option 2—iterative detection: An alternative approach is to iteratively estimate the viral loads using pools containing a single patient whose viral load was not yet recovered, and to update the measurements accordingly. In contrast to option 1, which jointly maps the entries of $\mathit{y}$ into an estimate of the viral loads, here, we iteratively search for the pools which represent a single unknown value, identifying their corresponding infection levels separately, and then canceling their contribution on the remaining pools. This approach facilitates recovery in setups where not only the infection levels, but also the viral loads themselves are discrete.

The iterative method for recovering the infection levels from $\mathcal{D}$ is summarized in lines 9–18 of Algorithm 1. Here, we let $\mathcal{D}\left(i\right)$ be the i-th element of $\mathcal{D}$. For a test in which only one infected subject participates according to the testing matrix (lines 11–12) (note that ∑ here represents addition over integers and not Boolean OR), the algorithm can recover the viral load directly from the measurement (lines 13–14). To obtain a discrete score, the measured value is quantized using a threshold-based mapping $Q(·)$. Then the algorithm subtracts the viral load of that subject from all the tests in which it participates (lines 15–16), and repeats until it recovers the infection levels of all declared infected subjects (line 10).

In Section 5, we compare the performance of the algorithm with the LS method vis-à-vis the iterative method. In our numerical results, which focus on a scenario with continuous-valued viral loads, the LS method is shown to achieve more accurate recovery. This follows from its ability to mitigate the effects of the noise induced in the measurement process, allowing it to retrieve viral loads that are close enough to the true viral loads. Option 2, in which detected pools are iteratively subtracted from non-detected ones, is more sensitive to noise and inaccurate identifications made in previous iterations, whose error may propagate to subsequent decisions. Note that increasing the granularity of the quantization can move us from discrete scores to continuous scores. We also would like to note that in the discussed regime of COVID-19, where there are strict limitations on how many tests can be combined (see Section 2), both options are feasible in terms of computational complexity and running time. Finally, viral load analysis is a complicated phenomenon whose study falls beyond the scope of this paper, as discussed in Section 1 and Section 6.

3.2. Discussion

The novelty of the multi-level GT algorithm stems from its two-step procedure; the first step utilizes efficient GT methods to notably reduce the number of examined patients, while the second step inspects the remaining patients and applies dedicated mechanisms to recover their level of infection. Here, we note a few remarks arising from the proposed scheme.

In Section 3.1, we describe how the matrix $\mathit{A}$ is generated. The description involves random generation, for which the resulting matrix is not guaranteed to satisfy Assumption 5. The motivation for using such randomization stems from its provable performance guarantees in GT theory [18]. In practice, once a typical testing matrix satisfying Assumption 5 is selected, one does not have to generate a new matrix for each group of n patients.

For n i.i.d. tested individuals, the probability of finding the infected items (though not necessarily their levels) is maximized by the ML rule. However, its complexity is burdensome, as it has to consider $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{k}}\right)$ options [61,62]. An efficient alternative is the DND algorithm, also known as column matching [41,58,63], whose time complexity is $\mathcal{O}\left(kn\log n\right)$ [56]. However, it requires a greater amount of pooled measurements compared to ML in order to reliably identify the detective items. The first step of our proposed multi-level GT method combines the concepts of DND with the ML algorithm, while the second step extends them to operate over non-binary fields, i.e., recover multiple levels rather than just identifying which subject is defective. Performing DND on all n items using the number of tests set to allow ML detection, i.e., $m=(1+ϵ)k{\log }_{2}n$ as opposed to the number of tests required for DND, which is $1.88\left(1+ϵ\right)k{\log }_{2}n$ [41], results in a smaller set of PD subjects $\mathcal{P}$. This, in turn, notably reduces the complexity of the recovery method. In Section 4, we give exact expressions for $\mathbb{E}\left(\right|\mathcal{P}\left|\right)$ after performing DND. Given $\mathcal{P}$, the ML decoder has to consider significantly less options, $\left({\displaystyle \genfrac{}{}{0pt}{}{\left|\mathcal{P}\right|}{k}}\right)$ which is likely to be computationally feasible and considerably faster than considering all ($\left({\displaystyle \genfrac{}{}{0pt}{}{\left|\mathcal{n}\right|}{k}}\right)$) combinations, as discussed in the complexity analysis in Section 4.5. It is important to note that ($\left({\displaystyle \genfrac{}{}{0pt}{}{\left|\mathcal{P}\right|}{k}}\right)$) options are considered only during the second stage of the first step (the ML stage). In the second step, the infection levels are produced only once (using either the LS option or the iterative detection option), after the most likely set of infected items have been generated.

Algorithm 1 requires two conditions to hold. First, the number of PD items, i.e., $\left|\mathcal{P}\right|$, should be relatively small, preferably close to k, so that the ML algorithm is feasible. Furthermore, for the LS recovery method to have a unique solution, it should hold that $\mathrm{rank}\left({\mathit{A}}_{\mathcal{D}}\right)=k$. If the solution is not unique, the algorithm may produce an undesirable output of different decisions when applied to the same pooled measurements. Both these requirements are numerically asserted to hold in the experimental scenarios considered in the paper, and their validity is also theoretically studied in the following section.

We note that in this paper, we assume that the binary quantization of the tests $Q_{0,1}\left(\mathit{y}\right)$ does not have any error. If this does not hold, one can use the noisy variants of the DND and the ML algorithms of Step 1, as known in the GT literature [41,55]. We leave this case for future work.

In our numerical evaluations of multi-level GT, we demonstrate its ability to achieve error-free detection when the number of measurements m satisfies the upper bound on this quantity for which the computationally prohibitive ML GT is guaranteed to approach zero error, i.e., $m=\left(1+ϵ\right)k{\log }_{2}n$ for some $ϵ>0$ [55]. Furthermore, in the case where it is possible to identify the number of infected subjects in a pool-test by observing its measurement, i.e., when one can separately tell for each element of $\mathit{y}$ how many defective patients are mixed into it (though not necessarily their infection level), we notice empirically that it is possible to achieve the lower bound number of pool-tests suggested for GT using the ML algorithm, i.e., $m\approx {\log }_2\left({\displaystyle \genfrac{}{}{0pt}{}{n}{k}}\right)\le k{\log }_2(n/k)$ [41,55] (for further details, see Section 5). We leave the analysis of this case for future work.

3.3. Unknown k

It is commonly assumed in the GT literature that the number of infected items k is known in advance [62], or that it can be estimated correctly within $\mathcal{O}\left(\log n\right)$ tests [53,54]. We mainly study this scenario in this paper to focus on the novel aspects of our proposed method. However, in practical scenarios, let alone during a pandemic, this assumption can be restrictive, and the estimations may suffer from errors, especially in the pooled tests that are noisy. In this section, we assume that the estimated number of infected items $\widehat{k}$ is different than the actual number of infected items k. We propose an adaptation to the proposed method that can handle this mismatch. Recall that our method is comprised of two main steps: designing the pooling procedure and executing the recovery algorithm.

Designing the pooling procedure boils down to designing the pooling matrix $\mathit{A}$. We propose to use the estimate $\widehat{k}$ when constructing the pooling matrix, i.e., $m=\left(1+ϵ\right)\widehat{k}{\log }_{2}n$. We break the analysis for the two possible mismatches.

• $\widehat{k}>k$: In this case, the DND step will result in fewer PD items than if we designed the pooling matrix with the correct estimation for k. In the non-asymptotic regime discussed in this paper, such mismatch is likely to result in the DND step correctly identifying all the infected items, as the number of tests required to correctly identify all infected items using the DND algorithm is $\left(1+ϵ\right)1.88k{\log }_{2}n$ [41,58].
• $\widehat{k}<k$: In this case, the DND step is likely to generate more PD items since this estimation is equivalent to lowering $ϵ$ in the number of tests m. Assuming the error in the estimation is not severe, the modified ML step can identify the correct infected items with manageable complexity, as we next discuss. For a numerical example, see the discussion in Section 4.1.

It is worth mentioning that once the pooling matrix $\mathit{A}$ is set, the DND step does not require knowledge of the number of infected items. Hence, the DND step remains unchanged.

The ML step in Algorithm 1 assumes that the number of infected items is known in advance. If k is not known in advance, one can alter the ML procedure of Algorithm 1 (starting at Line 28) to look for any set of defective items. The objective is to find the smallest number of infected items that would explain the output results $Q_{0,1}\left(\mathit{y}\right)$. This changes the ML procedure to the one given in Algorithm 2. The adapted version of the algorithm is still able to find the infected items correctly with high probability. This is also supported by our simulations.

We do note that in the case where the number of infected items k is known in advance, declaring that k items are infected is equivalent to declaring that the rest $n-k$ items are not infected. However, in the case where k is unknown, the ML step identifies the smallest set of items that are declared infected $\mathcal{D}$ among the $\mathcal{P}$ PD items. In this case, we cannot say for certain that the rest of $\mathcal{P}\setminus \mathcal{D}$ are not infected. We also empirically show that the infected items are identified correctly with high probability, and there may be some false positives among the non-infected items. Recall that in the context of COVID-19, falsely identifying non-infected items as infected is not as severe an error as false negatives, where infected items are declared as not infected.

Algorithm 2 Maximum Likelihood (ML) over PD subjects $\mathcal{P}$, unknown k

procedure ML($Q_{0,1}\left(\mathit{y}\right),\mathit{A},\mathcal{P}$)     for k=0, 1, … do         ${\mathcal{D}}_k=\arg {\min }_{\tilde{\mathcal{D}}\subset \mathsf{\Omega }(\mathcal{P},k)}{Q}_{0,1}\left(\mathit{y}\right)\oplus \left({\bigvee }_{k\in \tilde{\mathcal{D}}}{\mathit{A}}_k\right)$         if ${\mathcal{D}}_k$ explains $Q_{0,1}\left(\mathit{y}\right)$ then            return ${\mathcal{D}}_k$         end if     end for end procedure

4. Theoretical Analysis

In this section, we provide a theoretical analysis of the proposed multi-level GT scheme. In particular, we characterize two key components of Algorithm 1: the expected number of PD subjects, which dominates the computational complexity of the algorithm, and guarantees for LS recovery to have a unique solution. We then proceed to analyze the complexity of Algorithm 1, and show it is computationally efficient in the regimes of interest in the context of COVID-19. Our theoretical results are given as a function of the system parameters, i.e., the overall number of patients n and the number of infected ones k (assumed in this section to be the true number of infected patients and not a bound on it), as well as using those of the pooling pattern, namely, the number of measurements m and the Bernoulli distribution parameter p. While our theoretical measures are given using the true number of infected patients, we recall that Algorithm 1 can be applied using an approximation or an upper bound on this quantity. For the analysis in this section, we assume that $\mathit{A}$ is drawn according to an i.i.d. Bernoulli distribution with parameter p. It is known in the literature that there is approximately a 10% performance gap between picking a typical $\mathit{A}$ and an i.i.d. one, so this can serve as a bound on the performance [64]. We also empirically demonstrate this result in Section 5.2.

In our analysis of the expected number of PD subjects, we consider different models of the noise in Step 1. Following conventional GT terminology [55], the cases we treat are as follows:

• Noiseless case—here, the noise induced by the measurement process does not affect the ability to identify whether or not a pool contains a defected subject. Namely, $Q_{0,1}\left(\mathit{y}\right)=Q_{0,1}\left(\mathit{z}\right)$.
• Additive noise—here, the presence of noise may result in a pool not containing any defected subject being measured as an infected pool. This implies that $Q_{0,1}\left({\mathit{y}}_i\right)\ge Q_{0,1}\left({\mathit{z}}_i\right)$ for each $i\in 1,\dots ,m$.
• Dilution noise—dilution implies that pools containing infected subjects may be falsely measured as non-defective. In this case, $Q_{0,1}\left({\mathit{y}}_i\right)\le Q_{0,1}\left({\mathit{z}}_i\right)$ for each $i\in 1,\dots ,m$.

These cases are studied individually in Section 4.1, Section 4.2 and Section 4.3, respectively, for arbitrary settings of the parameters $k,n,p,m$; conditions for uniqueness of the LS solution are stated in Section 4.4, and the complexity of Algorithm 1 is characterized in Section 4.5.

4.1. Noiseless Case

We first calculate how many items are declared PD after running DND in Algorithm 1 in the noiseless setting. Recall that in this stage, we use the DND algorithm to declare the PD subjects. In the noiseless setting, all defective k items are declared PD, and there is some probability that each non-defective item is declared PD by the DND algorithm. For Algorithm 1 to run in reasonable time, it is essential that $\left|\mathcal{P}\right|$ is small enough, so the number of options to be considered by the ML decoder $\left({\displaystyle \genfrac{}{}{0pt}{}{\left|\mathcal{P}\right|}{k}}\right)$ is not exponentially large. In the noiseless setting, the expected number of PD subjects $\mathbb{E}\left(\right|\mathcal{P}\left|\right)$ is stated in the following theorem:

Theorem 1.

The expected number of items declared PD by the DND algorithm (first stage of the first step of Algorithm 1) in the noiseless setting is given by

$$\mathbb{E}\left|\mathcal{P}\right|=k+\left(n-k\right){\left(1-p{\left(1-p\right)}^k\right)}^m.$$

(5)

The proof is given in Appendix A.1.

Theorem 1 characterizes the exact expected number of PD items declared by DND in the noiseless setting. This characterization holds regardless of the fact that the outputs of the DND method are later used for identifying infection levels. Note that the second part of (5) is similar to a known result on the DND algorithm, e.g., [65] (Equation (8)). The main difference is that it is traditionally used to bound the probability of error of the algorithm using a union bound, whereas we use this expression to calculate the exact expected number of PD items.

To affirm and numerically evaluate Theorem 1, we depict in Figure 2a the expected number of items declared PD, computed via (5), plotted as the dashed lines, as a function of the number of defective items k. This theoretical quantity is compared to the empirical expected number of items declared PD, averaged over ${10}^4$ Monte-Carlo simulations. The number of tests are chosen to match the upper ML bound $m=\left(1+ϵ\right)k{\log }_{2}n$, as described in Section 5. We observe in Figure 2a that the simulation results agree with the theoretical values dictated by Theorem 1. The figure also shows that in the non-asymptotic regime, which is of interest for applications such as COVID-19 pooled testing, the expected number of PD items is significantly smaller than the number of patients n, and in particular, often lies in $\left[k,3k\right]$. This means that the second part of Step 1 of Algorithm 1, which uses an ML decoder, has to consider much less combinations compared to that needed without the prior DND subject identification. Similar observations are reported in Figure 3a, which considers the same comparison as in Figure 2a, only with a significantly larger number of items n. The figure shows that the average number of PD items after DND is substantially smaller than n, indicating that the gains of using DND in reducing the computational burden are more dominant as the number of patients grows. In Figure 2b and Figure 3b, we empirically show that, using the results of [66], the probability that the number of PD items is significantly larger than the calculated expected value is small. Namely, we show that $P\left(\left|\mathcal{P}\right|-\mathbb{E}\left(\right|\mathcal{P}\left|\right)>g\right)$ is small for $g\in \left\{2k,3k\right\}$, as we show in Figure 2a and Figure 3a, where g is a selected threshold. This ensures that the complexity associated with carrying out the ML step is manageable. The complexity can be controlled and further reduced by increasing the number of pooled tests m.

This paper studies GT-based methods to identify patients infected with COVID-19 using the RT-qPCR method. As such, the regime in mind is a non-asymptotic regime (see Assumption 5). However, in the GT literature, the analysis is often conducted in the asymptotic regime, where $k,n$ are large and $k\ll n$. In this regime, the number of non-defective items declared PD by the DND step goes to zero for $ϵ>1$ (see Appendix A.2 for further details). This demonstrates the trade off between the desired complexity of the ML step and the number of tests m.

Figure 2a,b also show that it is feasible to perform the ML step in the case of a mismatch between the actual number of infected items and the estimated number of infected items (as elaborated in Section 3.3). In Figure 2a, the number of pooled tests m is designed for the case where there are $k=5$ infected items and $ϵ=0.4$. We see that when the true number of infected items k exceeds 5, the expected number of PD items $\left|\mathcal{P}\right|$ is small enough, and Figure 2b shows it will not be too far from $\mathbb{E}\left|\mathcal{P}\right|$ with high probability. For example, when the actual number of infected items is k = 7, the DND step returns $\left|\mathcal{P}\right|$ = 16 PD items on average. The number of combinations considered by the ML step, assuming all the infected items are correctly identified, is equal to ${\sum }_{k^{\prime }=0}^{k=7}\left({\displaystyle \genfrac{}{}{0pt}{}{\left|\mathcal{P}\right|}{k^{\prime }}}\right)\approx {10}^5$, which is a feasible number of combinations to consider by the ML step. Figure 2b shows that the probability to exceed $\left|\mathcal{P}\right|$ = 16 items is bounded above by 0.05.

4.2. Additive Noise

In the additive noise model, a test may be positive even if no defective items participate in it [55]. This case reflects the possibility of false positives in traditional binary GT. This happens with probability q, i.i.d. between different tests. That is, we define a set of i.i.d. random variables ${\left\{W_i\right\}}_{i=1}^m$, such that $W_i$ obeys a Bernoulli distribution with parameter q. The binarized test results of the i-th test are here modelled as a Boolean OR function of the test result without additive noise and $W_i$ i.e., $Q_{0,1}\left({\mathit{y}}_i\right)=Q_{0,1}\left({\mathit{z}}_i\right)\bigvee W_i,i\in 1,\dots ,m$. It follows from [55] that the DND algorithm can still guarantee accurate recovery of the PD subjects when the number of tests is increased by a factor of at least $1/\left(1-q\right)$ with respect to the noiseless scenario. We expand the results of Theorem 1 in the following theorem:

Theorem 2.

Let q be the probability that a test without infected items comes out positive. The expected number of items declared PD by DND algorithm (first stage of the first step of Algorithm 1) in the additive noise setting is given by

$$\mathbb{E}\left(\right|\mathcal{P}\left|\right)=k+\left(n-k\right){\left(1-\left(1-q\right)p{\left(1-p\right)}^k\right)}^m.$$

(6)

The proof is given in Appendix A.3.

Theorem 2 extends Theorem 1 to the case of additive noise. Note that when $q=0$, i.e., the effect of the additive noise vanishes, we obtain the corresponding expected value derived in Theorem 1 for the noiseless case.

To exemplify the difference between the expected number of PD subjects for noiseless and noisy setups, we next evaluate (6) with the parameters used in Figure 2a for the noiseless case. Specifically, we set $m=47,n=105$, and focus on $k=5$ defective items. In the presence of additive noise with Bernoulli parameter $q=0.1$, we obtain that $\mathbb{E}\left(\right|\mathcal{P}\left|\right)=98.52$, as opposed to $\mathbb{E}\left(\right|\mathcal{P}\left|\right)=9.3$ in the noiseless case. This demonstrates the importance of adjusting the number of tests in the additive noise scenario: when we use a number of tests that corresponds to the noiseless case, DND, on average, outputs that most of the items are PD.

4.3. Dilution Noise

In the dilution noise model, a test may come negative even if defective items participate it [55]. This case reflects the possibility of false negatives in traditional binary GT, which are often more severe than false positives, especially in the context of COVID-19. In particular, if a defective item is declared DND in Step 1 of Algorithm 1, then it will not be detected as infected by the algorithm.

To model the presence of dilution noise, we let each defective item be diluted with probability u, independently of other defective items in the test. In order to handle the presence of dilution noise, the DND algorithm has to be adjusted. In the modified DND algorithm, a patient is declared PD if it participates in at least $\tau$ tests that come out positive [41,65]. As a result, the number of positive tests that an item participates in is distributed according to a binomial distribution with m trials. The probability to participate in a test depends on whether the item is infected or not. We denote the probability that an infected/non-infected item participates in a positive result by ${\widehat{p}}_u,{\tilde{p}}_u$, respectively. Consequently, the number of positive tests an infected/non infected item participates in is distributed according to $\mathrm{Bin}\left(m,{\widehat{p}}_u\right)$, $\mathrm{Bin}\left(m,{\tilde{p}}_u\right)$, respectively. Here, $\mathrm{Bin}\left(a,b\right)$ is the binomial distribution with a trials and probability of success b.

In the presence of dilution noise, we are no longer guaranteed that a defective item would always be declared as PD. We define ${\mathcal{P}}_{\mathcal{D}},{\mathcal{P}}_{{\mathcal{D}}^c}$ as the set of all defective/non-defective items that are marked PD, respectively, i.e., ${\mathcal{P}}_{{\mathcal{D}}^c}\cup {\mathcal{P}}_{\mathcal{D}}=\mathcal{P}$ while ${\mathcal{P}}_{{\mathcal{D}}^c}\cap {\mathcal{P}}_{\mathcal{D}}$ is an empty set. The extension of Theorem 1 to the presence of dilution noise is given in the following theorem:

Theorem 3.

Let u denote the dilution probability of a defective item in each test, and τ be the threshold used by the modified DND algorithm. Then, the set subjects declared PD is comprised of the distinct sets ${\mathcal{P}}_{\mathcal{D}},{\mathcal{P}}_{{\mathcal{D}}^c}$ which satisfy $\mathbb{E}\left(|{\mathcal{P}}_{{\mathcal{D}}^c}|\right)=\left(n-k\right)·\mathrm{Pr}\left(\mathrm{Bin}\left(m,{\tilde{p}}_u\right)\ge \tau \right)$,

$\mathbb{E}\left(|{\mathcal{P}}_{\mathcal{D}}|\right)=k·\mathrm{Pr}\left(\mathrm{Bin}\left(m,{\widehat{p}}_u\right)\ge \tau \right)$

and thus

$\mathbb{E}\left(\right|\mathcal{P}\left|\right)=\left(n-k\right)·\mathrm{Pr}\left(\mathrm{Bin}\left(m,{\tilde{p}}_u\right)\ge \tau \right)+k·\mathrm{Pr}\left(\mathrm{Bin}\left(m,{\widehat{p}}_u\right)\ge \tau \right)$.

The proof is given in Appendix A.4.

Theorem 3 characterizes the overall number of PD items, as performed in Theorems 1 and 2 for the noiseless and additive noise setups, respectively. In addition to expressing $\mathbb{E}\left(\right|\mathcal{P}\left|\right)$, Theorem 3 also identifies the expected number of patients which are not defective but are identified as PD by the DND algorithm. Unlike the models used in deriving Theorems 1 and 2, under the dilution noise model, we are no longer guaranteed that a defective item is declared DD. Thus, there is a non-zero probability that some of the k infected patients are not assigned into $\mathcal{P}$ by the DND algorithm, and thus $\mathbb{E}\left(\right|\mathcal{P}\left|\right)\le k$.

4.4. Uniqueness of LS Recovery

Next, we identify sufficient conditions under which the LS solution is unique. Step 2 recovers the infection levels based on the output of Step 1, i.e., $\mathcal{D}$. Therefore, to provide a lower bound on the probability that this output enables recovery of infection levels via LS followed by discretization of the values, in the following, we focus on the case where all the infected items have been identified by the first step of the algorithm.

Once the set of infected items, whose indices are denoted by $\mathcal{D}$, has been identified by the GT procedure in Step 1, the infection levels of those subjects are recovered by quantizing the LS solution to (3). Notice that since we are left with k subjects to resolve, it holds that ${\mathit{A}}_{\mathcal{D}}\in {\left\{0,1\right\}}^{m\times k}$, and $m>k$. When solving (3), we treat ${\mathit{A}}_{\mathcal{D}}$ as a real matrix rather than a matrix over the binary field. A unique solution exists to the LS problem in this scenario if ${\mathit{A}}_{\mathcal{D}}$ is of full rank, namely $\mathrm{rank}\left({\mathit{A}}_{\mathcal{D}}\right)=k$. When this holds, the unique solution to the LS procedure is used to estimate viral loads. Our proposed Algorithm 1 recovers the infection levels by quantizing these estimates, which is numerically demonstrated to yield accurate identification of the infection levels in Section 5. The following theorem bounds the probability that ${\mathit{A}}_{\mathcal{D}}$ is rank-deficient:

Theorem 4.

Let the number of tests satisfy $m=\left(1+ϵ\right)k{\log }_2\left(n\right)$ for some $ϵ>0$, and the Bernoulli parameter p satisfy $p=1-2^{-1/k}$. Then, the probability that the solution of (3) is not unique is bounded as

$$\begin{array}{c}\hfill \mathrm{Pr}\left(\mathrm{rank}\left({\mathit{A}}_{\mathcal{D}}\right)<k\right)\le 1-{\left(1-n^{-\left(1+ϵ\right)}\right)}^{2^k-1}.\end{array}$$

(7)

The proof is given in Appendix A.5.

Theorem 4 guarantees that Step 2 of Algorithm 1 uses a unique LS estimate with high probability, assuming that Step 1 of the algorithm has successfully identified the infected items. The resulting probability depends on the number of pools m via the parameter $ϵ>0$. In Section 5, we assess in simulation that the high probability of ${\mathit{A}}_{\mathcal{D}}$ having a full rank in Step 2 results in identifying the correct infection levels.

4.5. Complexity Analysis

One of the key features of the proposed multi-level GT methods is its reduced complexity compared to ML-based GT. To fully analyze this aspect of Algorithm 1, we give the following proposition which characterizes its complexity, focusing on the implementation with LS recovery.

Proposition 1.

Let $ϵ=\mathcal{O}\left(1\right)$ be a design parameter. The overall complexity of Algorithm 1, when used with $m=\left(1+ϵ\right)k{\log }_{2}n$, is given by

$$\begin{array}{c}\hfill \mathcal{O}\left(\left(n+\left({\displaystyle \genfrac{}{}{0pt}{}{\left|\mathcal{P}\right|}{k}}\right)k+k^2\right)k\log n\right).\end{array}$$

(8)

Proof. 

The complexity of DND is $\mathcal{O}\left(kn\log n\right)$ [56]. Once PD items are identified, the complexity of the ML algorithm is $\mathcal{O}\left(\left({\displaystyle \genfrac{}{}{0pt}{}{\left|\mathcal{P}\right|}{k}}\right)km\right)$, as we have to compute a Boolean OR of k vectors of size m, and compare it with $Q_{0,1}\left(\mathit{y}\right)$. The complexity of LS depends on the dimensions of ${\mathit{A}}_{\mathcal{D}}$, but also on the specific implementation. Since ${\mathit{A}}_{\mathcal{D}}\in {\left\{0,1\right\}}^{m\times k}$, LS involves $\mathcal{O}\left(m{k}^2\right)$ operations [67]. We note that it is likely that the matrix ${\mathit{A}}_{\mathcal{D}}$ is sparse [39], and it becomes more sparse as p decreases. Efficient algorithms for solving LS are known in the literature when the matrix is sparse, e.g., LSQR [68]. Substituting $m=\left(1+ϵ\right)k{\log }_{2}n$ as the number of tests, we obtain (8), thus proving the proposition. □

The complexity expression in Proposition 1 includes three terms, as the algorithm has three main components: the DND algorithm, which identifies the subset of PD items $\mathcal{P}$; the ML search in (2) on $\mathcal{P}$; and the recovery of the infection levels using LS. The computational complexity of the ML stage is dictated by the set $\mathcal{P}$, which is a random quantity depending on the observations. As shown in the previous subsections, the expected cardinality of the PD set can be computed in closed form depending on the assumed noise model.

To analyze the dominant part of the algorithm in terms of complexity, we consider the values $n=105,k=5$ that are used in Section 5, which are representative values when testing for COVID-19 using pooled RT-qPCR measurements [21]. In this regime, it holds that $k^2\ll n$, and so the third component (representing the LS complexity) is negligible. To quantify the complexity associated with ML, which is dictated by the random set $\mathcal{P}$, we adopt here the noiseless model for the binary measurements. In this case, when the number of tests is set to $m=\left(1+ϵ\right)k{\log }_{2}n$, which corresponds to the upper bound on the number of tests required for ML decoding, we have that $\mathbb{E}\left(\right|\mathcal{P}\left|\right)<2k$ (see Figure 2a). Under these settings and when replacing $\left|\mathcal{P}\right|$ with its expected value, the ML decoder has to consider $\left({\displaystyle \genfrac{}{}{0pt}{}{2k}{k}}\right)=252$ combinations. This overhead is much lower than that required in order to apply ML directly to the measurements, which involves a search over $\left({\displaystyle \genfrac{}{}{0pt}{}{n}{k}}\right)>9·{10}^7$ different combinations. As $\left({\displaystyle \genfrac{}{}{0pt}{}{2k}{k}}\right)$ is greater than n, the dominant complexity factor corresponds to that required by the ML decoder. This complexity term is not prohibitive in the considered regime, and is of the same order as low complexity CS-based recovery, such as the Orthogonal Matching Pursuit algorithm, which typically requires $\mathcal{O}\left(nk\log n\right)$ operations (after plugging in the number of tests m) [69].

5. Numerical Evaluations

In this section, we numerically evaluate the performance of the proposed multi-level GT method recovering COVID-19 infection levels from pooled RT-qPCR measurements.

5.1. Experimental Setup

We consider the model used in [21] for representing the RT-qPCR operation, i.e., the element-wise mapping $f(·)$ which yields $\mathit{y}=f\left(\mathit{z}\right)$. In particular, the RT-qPCR measurement operation is modeled via

$${\mathit{y}}_i={\mathit{z}}_i{(1+q)}^{{\zeta }_i},i=1,\dots ,m,$$

(9)

where q is a constant and ${\left\{{\zeta }_i\right\}}_i$ is a set of i.i.d. zero-mean Gaussian random variables with variance ${\sigma }^2$.

The elements of the test matrix are chosen such that the rows and columns of $\mathit{A}$ are typical, and satisfy requirement Assumption 5 with $L=32$, by generating matrices according to a Bernoulli i.i.d. distribution until a typical matrix is obtained. Unless stated otherwise, Algorithm 1 implements recovery in Step 2 via LS, and the number of patients considered is $n=105$, out of which $k=5$ are infected. The viral load of each defective subject is drawn from a uniform distribution within $\left[0,1000\right]$, as in [21]. The infection level score is based on a division of this interval into four regions with thresholds $[{\tau }_1,{\tau }_2,{\tau }_3]=[50,300,700]$, namely, $[0,50)$ = no; $[50,300)$ = low (borderline); $[300,700)$ = mid; and >700 = high. The threshold of 300 is the recommended threshold according to the Centers for Disease Control and Prevention (CDC) guidelines [16]. We average over 1000 Monte-Carlo simulations. We choose $q=0.95$ and $\sigma =0.01$.

The recovery performance of the proposed Algorithm 1 is compared to upper and lower bounds on ML recovery in GT theory. These bounds represent the necessary and the sufficient number of test pools m one has to use in order to be able to guarantee accurate detection of which of the subjects are infected, respectively, assuming a noiseless GT model as detailed in Section 4.1 [55]. The ML lower bound is

$$m_{\mathrm{ML}}^{\mathrm{lb}}={\log }_2\left({\displaystyle \genfrac{}{}{0pt}{}{n}{k}}\right),$$

(10)

while the upper bound is given by

$$m_{\mathrm{ML}}^{\mathrm{ub}}=\left(1+ϵ\right)k{\log }_{2}n,$$

(11)

for any $ϵ>0$. The bounds in (10) and (11) guarantee detecting the presence of infection using computationally prohibitive ML-based GT; we are interested not only in detecting which patients are defective, but also in characterizing their infection levels. In addition to the ML bounds, we also compare the performance of Algorithm 1 to that reported in [20,21].

5.2. Results

We first evaluate the success probability of Algorithm 1 as a function of the number of pool-tests m. In particular, we evaluate the algorithm using two forms of success probability: finding defective items, for which an error is declared when there is at least a single defective subject who is not detected out of a set of n patients; and finding infection levels, where an error implies that there is at least one patient whose infection level is not correctly recovered. The resulting error probabilities are depicted in Figure 4a, and compared to the ML lower/upper bound on the number of tests m computed via (10) and (11), respectively. From the plot, we see that the success probability of finding the defective items and the success probability of finding the infection levels coincide. That is, whenever the defective set was recovered successfully, the correct infection levels were also estimated successfully, indicating the validity of Step 2 of Algorithm 1. We also see that when the number of tests is at the ML upper bound, the probability of success approaches one.

Figure 4b shows the number of true positives, i.e., the number of defective subjects that are declared defective. We observe that when m matches the ML upper bound, we have no false negatives with high probability. In the context of COVID-19, false negatives are the worst outcomes of a test. Figure 4c illustrates the probability of the detected non-defective subjects after the DND stage in Algorithm 1. This is calculated as the number of non-defective items declared by the DND algorithm, divided by the total number of non-defective items $n-k$. We see that when the number of tests satisfies the ML upper bound, DND identifies $\approx {\displaystyle \frac{95}{100}}=95\%$ of the subjects as non-defective, i.e., $\left|\mathcal{P}\right|\approx 2k$. These will be candidates to be tested in the second stage as PD, demonstrating the notable complexity reduction achieved by the two-step process. Similar results are obtained when the non-negativity constraint is enforced on ${\mathit{x}}_{\mathcal{D}}$ in the LS formulation.

The results in Figure 4a–c evaluate the error probability, but do not capture which types of errors are produced. We thus report in Figure 5 the confusion matrix for the considered scenario, as well as when repeating the setup with a much larger amount of patients of $n=961$ (and with the same number of infected patients $k=5$), using merely $m\in \{70,93\}$ pool-tests. We observe in Figure 5 that the algorithm rarely classifies infected items as non-infected, and vice versa. For example, for $(n,m)=(105,45)$, only $\approx$0.1% of infected items are declared non-infected, akin to the results achieved in [21] for the same parameters. This behavior is more notable when jointly testing $n=961$ subjects in Figure 5b,c, where, for example, for $\left(n,m\right)=\left(961,93\right)$ (Figure 5b), no false negatives are reported. Comparing these results to [21], it is noted that multi-level GT achieves improved false positive and false negative probabilities with only $m=70$ test-pools compared to that achieved using all CS methods examined in [21] with $m=93$ test-pools. For instance, for $(n,m)=(961,93)$ [21] reported false positive probabilities varied from 0.1% to 0.8%. This indicates the potential of multi-level GT in facilitating pooled testing of large numbers of subjects.

The gains noted in Figure 5a stem from the combination of GT tools (Step 1 in Algorithm 1) with LS-based recovery (Step 2) which identifies the infection levels and handles the presence of noise in the DD subjects. To quantify the gains of using LS recovery, we repeat the same simulation where the iterative method (Option 2 for Step 2 in Algorithm 1) is used, reporting the confusion matrices are in Figure 6. We note that here, LS outperforms the iterative method. The iterative method does not attempt to denoise the measured viral loads; thus, it is more susceptible to noise. This problem is mitigated by the LS method, which inherently tries to estimate viral loads that would minimize the sum of squared errors between the measured viral loads and the estimated ones.

In Figure 7, we depict the performance of multi-level GT as a function of different numbers of infected items and total items. The results presented are for the upper bound of the required number of pool-tests, $m_{\mathrm{ML}}^{\mathrm{ub}}$, using an ML decoder as given in (11). It can be clearly seen that the number of pool-tests scales linearly with k and logarithmic with n. In Figure 8, we demonstrate the linear trend showing the error probability using Algorithm 1 over 200 iterations, with $n=200$ and k varied from 2 to 9. In Figure 9, we demonstrate the logarithmic trend for $k=3$ and n varying from 30 to 1000.

Next, we compare the performance achievable when using the typical and random pool-testing matrices described in Section 3. Figure 10 plots the success probability of multi-level GT using both generation methods with $\left(n,k\right)=\left(384,3\right)$. We see that when $\mathit{A}$ is typical, one can identify the infected items with about 21% fewer pool-tests, and that the performance achieved with random $\mathit{A}$ also holds with typical $\mathit{A}$.

In Section 3, we describe how in the first GT-based step of Algorithm 1, the measured pooled viral loads are represented using the mapping $Q_{0,1}\left(\mathit{y}\right)$. We use this quantity for each pooled test as an indication to whether it includes an infected item or not; nonetheless, we do not have a similar indication regarding the number of infected items in a pooled test. We next explore how Algorithm 1 fares when given access to such an indication on how many infected items participate in each pooled test. While not being the main focus of this paper, this scenario may be useful if we are able to output the number of infected items in each pooled test. When the number of infected items in a pooled test can be estimated in the recovery process, we may utilize such knowledge to reduce the number of pooled tests to the known lower bound for ML decoding of GT [55]. Figure 11 plots the success probability measures as in Figure 4a versus m, when the number of infected items in a test is either known (in teal circles) or unknown (in orange exes). The number of infected items and total number of items $\left(n,k\right)=\left(384,4\right)$, similar to the experiment reported in [20]. Figure 11 shows that like [20], multi-level GT is able to correctly identify the infected items. Unlike [20], multi-level GT is also able to recover the correct infection level of the infected items, when the number of tests is set according to the upper bound for ML decoding. Moreover, if the number of infected items in each pooled test is revealed, multi-level GT also achieves the lower bound required for ML detection, namely, it can operate reliably with the minimal necessary number of test pools dictated by GT theory. Note that without this additional information, i.e., the number of infected items in each test, no existing solution in the literature achieves this lower bound.

In Section 3.3, we discussed how the proposed method can be modified to handle the case where the number of infected items k is not assumed to be known in advance. Figure 12 shows the probability to correctly identify the infected items using the version of the ML decoder (Algorithm 2) that does not assume the number of infected items in advance. In this example, $n=105$ and the pooling matrix $\mathit{A}$ is designed assuming the number of infected items is $\widehat{k}=5$. The figure shows that the proposed method can successfully identify the infected items with high probability, even without prior knowledge of the number of infected items k. As previously discussed, this version of the ML step cannot guarantee that the remaining PD items are not infected. Figure 13 shows that when $\widehat{k}<k$, the DND step declares more non-infected items as PD. These items may result in false positives, which is not the severe type of error in the context of COVID-19 identification. We also see that when $\widehat{k}>k$, the DND step successfully identifies all the infected items and does not produce any additional PD items. This is expected since this case corresponds to enlarging $ϵ$, hence reducing the probability of error.

6. Conclusions

In this work, we proposed multi-level GT for one-shot pooled COVID-19 tests. We first identified the unique characteristics and requirements of RT-qPCR-based tests. Based on these requirements, we designed multi-level GT to combine traditional GT methods with one-shot operation and multi-level outputs, while implementing a preliminary DND detection mechanism to facilitate recovery at reduced complexity. We provided theoretical analysis of the algorithm, and identified conditions under which it operates with feasible complexity, which include the regimes of interest in the context of COVID-19. We numerically demonstrate that multi-level GT reliably identifies the infection levels when examining far fewer samples compared to the number of tested subjects. These results highlight the applicability of our method in real-world scenarios where testing speed, resource constraints, and infection quantification are all critical—making it particularly suited for large-scale outbreaks like COVID-19.

Future work could explore different noise models that are known in the literature and mentioned in the paper, as noise arises naturally in practical testing scenarios during pandemics. The assumption that infected items are not correlated may not be realistic, though omitting it can be an interesting venue of further research, e.g, as considered recently for Boolean GT in [66]. Incorporating prior biological or epidemiological information—such as typical viral load distributions or population-level infection patterns—into the multi-level GT framework is another promising avenue for future research.