# Hybrid Grover search for AUD on a NISQ device

Romain Piron, Claire Goursaud

► To cite this version:

Romain Piron, Claire Goursaud. Hybrid Grover search for AUD on a NISQ device. EUSIPCO 2024 - 32nd European signal processing conference, Aug 2024, Lyon, France. pp.1-5. hal-04654026

HAL Id: hal-04654026

https://hal.science/hal-04654026v1

Submitted on 22 Jul 2024

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
# Hybrid Grover search for AUD on a NISQ device

Romain Piron

Université de Lyon, INSA Lyon, INRIA
CITI EA 3720

69621 Villeurbanne, France
romain.piron@insa-lyon.fr

Claire Goursaud

Université de Lyon, INSA Lyon, INRIA
CITI EA 3720

69621 Villeurbanne, France
claire.goursaud@insa-lyon.fr

**Abstract**—This paper focuses on the AUD in a NOMA network. To do so with a reduced complexity, we propose a new strategy based on Grover's quantum algorithm to perform the minimum searching so as to implement the ML receiver. As current quantum processors still suffer from noise in the so-called NISQ era, we propose to use Grover's routine with a reduced number of iterations but with several trials. We show that this approach presents a complexity advantage and allows to reach higher success probabilities than Grover's. This strategy may permit to timely deploy such AUD receiver even without perfect quantum devices.

**Index Terms**—NOMA, AUD, Grover's algorithm, hybrid quantum computing, NISQ

## I. INTRODUCTION

Scenarios of 5G applications address several cases, one of them being ultra reliable low latency communications (uRLLC) [1]. Resource allocation prior to transmission is no longer adapted for uRLLC use of cases such as Industrial IoT. Non orthogonal multiple access (NOMA) appears as a promising solution to allow all users on the network to share the same resources, and for a subset of them to simultaneously transmit information to an access point with high success probability. That is why it has gained interest from the scientific community [2].

In a code domain NOMA system, each node is identified with a unique sequence $c_i \in \mathbb{C}^M$. The activity of the network is encoded in $b^{(0)} \in \{0, 1\}^n$ where $b_i^{(0)} = 1$ (resp. $b_i^{(0)} = 0$) corresponds to an active (resp. inactive) user. Assuming that one has perfect channels, the access point receives the following signal $y \in \mathbb{C}^M$:

$$y = \sum_{i=1}^{n} b_{i}^{(0)} c_{i} + w, \quad (1)$$

where $w \sim \mathcal{N}(0, \sigma^2 I_M)$ is an additive Gaussian noise and $I_M$ is the $M \times M$ identity matrix.

Estimating a posteriori the activity bit-string $b^{(0)}$ from the received signal is a key challenge in NOMA networks called active user detection (AUD). To do so, several decoders exist and the choice of the decoder usually results from a compromise between reliability and complexity. For instance, the conventional correlation receiver (CCR) $\hat{b}^{CCR}$ [3] allow to

This work was supported by the ANR under the France 2030 program, grant "NF-PERSEUS : ANR-22-PEFT-0004".

estimate $b^{(0)}$ with $\mathcal{O}(n)$ operations but with a limited reliability. Meanwhile, the most reliable estimator is the maximum likelihood (ML) decoder. As discussed in [4], the probability $P(\hat{b} = b^{(0)})$ is significantly higher for the ML than for the CCR. However, the ML is obtained with the expression [4]:

$$\hat{b}^{\text{ML}} = \arg \min_{b \in \{0,1\}^n} \left\{ \left\| \hat{y} - \sum_{i=1}^{n} b_i c_i \right\|^2 \right\}, \quad (2)$$

which clearly shows that it is NP-hard to compute since it requires $\mathcal{O}(2^n)$ tests.

Quantum algorithms offer promising results to deal with such minimisation problems. The so-called Grover's algorithm [5] allows to find an element $x_0 \in \{0, 1\}^n$ verifying a boolean constraint of the type $f(x_0) = 1$ with $\mathcal{O}(2^{n/2})$ iterations and without any prior knowledge of $x_0$. It offers a quadratic speedup over a classical exhaustive search. Thus, it has already been considered for use in for wireless communications systems [4], [6]. Thanks to the adaptation of the algorithm for minimum searching [7], one can use Grover's routine to build the ML decoder of Eq. 2.

Despite the excellent properties of this algorithm, there is room for improvement. Indeed, its implementation on today's NISQ quantum processors yields a degradation of the reliability of the algorithm [8], [9]. Inspired by BBHT's approach [10] that launches Grover several times when the number of solutions is unknown, we propose an hybrid version of the algorithm that relies on this principle. The paper is organized as follows. First, we review the Grover's algorithm principle. Then, we show that our approach presents a complexity advantage over Grover when one targets a reliability reachable by the latter in the presence of noise. Finally, we emphasize that our algorithm is able to reach a higher success probability than Grover's algorithm in a noisy environment without increasing the complexity.

## II. GROVER'S ALGORITHM

### A. Qubits and gates

Quantum information uses the so-called qubit as the support of information, which is a superposition of two reference states $|0\rangle$ and $|1\rangle$:

$$|\psi\rangle = \alpha |0\rangle + \beta |1\rangle, \quad (3)$$
where $|0\rangle = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ and $|1\rangle = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$ form an orthonormal basis of $\mathbb{C}^2$. The coefficients $\alpha$ and $\beta$ are two complex numbers such that:

$$|\alpha|^2 + |\beta|^2 = 1. \qquad (4)$$

The probability to measure the qubit in the state $|0\rangle$ or $|1\rangle$ is respectively given by $|\alpha|^2$ and $|\beta|^2$.

One can physically act on a qubit, which is modelled by the action of a unit operator $U$ on $|\psi\rangle$. In the common terminology, $U$ is called a gate. It allows to apply logical operations on a qubit. For instance, the NOT gate usually denoted $X$ is given by:

$$\text{NOT} \equiv X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} \qquad (5)$$

As expected, $X|0\rangle = |1\rangle$ and $X|1\rangle = |0\rangle$. Another often used gate is the Hadamard gate:

$$H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}, \qquad (6)$$

which permits to have an equiprobable superposition of the basis states.

A system of $n$ qubits, often called a register, is represented by a state vector living in the tensor product space $(\mathbb{C}^2)^{\otimes n} = \mathbb{C}^2 \otimes \dots \otimes \mathbb{C}^2$ of dimension $N = 2^n$, with $\otimes$ the tensor product. One can apply the gates $U_1, \dots, U_n$ on each qubit by using the gate $U = U_1 \otimes \dots \otimes U_n$. For instance, a NOT gate applied on the first qubit of a 2-qubit register is realized with $X \otimes I_2$.

## B. Grover's algorithm description

Basic Grover's algorithm [5], denoted BG throughout this work, consists in the routine described in Alg. 1

### Algorithm 1 Grover's algorithm

**Input:** $k \in \mathbb{N}^*$

1. Initialize the register to the uniform superposition state: $|s\rangle = \frac{1}{\sqrt{N}} \sum_{x \in \{0,1\}^n} |x\rangle$

2. remainingIterations $\leftarrow k$

3. **while** remainingIterations > 0 **do**

4. Apply the oracle $U_f$

5. Apply the diffusion operator $U_s = 2|s\rangle\langle s| - I_N$

6. remainingIterations $\leftarrow$ remainingIterations - 1

7. **end while**

8. Perform a measure of the register

**Output:** $|x\rangle$

Within one iteration, the oracle first marks the states which verify $f(x) = 1$ by acting on the register as:

$$U_f|x\rangle = \begin{cases} -|x\rangle & \text{if } f(x) = 1 \\ |x\rangle & \text{if } f(x) = 0 \end{cases}, \qquad (7)$$

and the diffuser $U_s$ amplifies the probability amplitude of the marked states by the use of inverse mean (Fig. 1). After the

<figure><img src="image_2.png" /><figcaption>Figure 1: Grover Scheme with for 2 qubits. The last qubit is an ancilla qubit needed for marking the solutions.</figcaption></figure>

$k$ iterations, a measure of the register's final state returns one of the marked state with a probability of almost 1 when the number of iterations is wisely chosen.

As mentioned in the introduction, BG can be used for minimum searching problems. In our AUD scenario, we can define the function $T$ of Ref. [7] as:

$$\hat{b}^{\text{ML}} = \arg \min_{b \in \{0,1\}^n} T[b] \qquad (8)$$

and execute the routine detailed in [7]. One can thus compute the ML decoder for AUD using Grover's algorithm as done in [4]. However, the success probability of BG is likely to be reduced due to quantum perturbations in the algorithm.

## C. Quantum noise model

Grover's algorithm on today's NISQ processors presents a lower success probability than the theoretical expectations. A simple model that allows to implement those noise effects is the total depolarizing channel (TDCh) [11].

In the density matrix formalism, TDCh maps the current state of the register $\rho$ to a maximally mixed state $^2$ with probability $\lambda$ and leaves it unchanged with probability $1-\lambda$:

$$\varepsilon(\rho) = (1 - \lambda)\rho + \lambda \frac{I_N}{N}. \qquad (9)$$

We adopt the model of Ref. [11], where each action on the register of $G = U_s U_f$ is followed by one action of the TDCh error model. Assuming that $t$ elements verify $f(x) = 1$, [11] showed that the success probability of the algorithm is:

$$P_{BG}^{(\lambda)}(k) = (1 - \lambda)^k \sin^2((2k + 1)\theta_G) + (1 - (1 - \lambda)^k) \frac{t}{N}, \qquad (10)$$

where $\sin^2 \theta_G = t/N$. The term $(1 - \lambda)^k$ in Eq. 10 encodes that the more iterations, the more errors due to the TDCh. The optimal number of iterations required to reach the maximum of this probability is [11]:

$$L_{\text{opt}}^{(\lambda)} = \max \left\{ \left| \frac{\pi - \arcsin(\delta^{(\lambda)}) - \arcsin((1 - 2/N)\delta^{(\lambda)})}{4\theta_G} \right|, 1 \right\}, \qquad (11)$$

<footnote n="1">¹The unitarity constraint aims to preserve the normalization $|\alpha|^2 + |\beta|^2 = 1$</footnote>

<footnote n="2">²The maximally mixed state corresponds to a uniform mixture where the register might occupy any state of $\{0, 1\}^n$ with the same probability $1/N$.</footnote>
<figure><img src="image_3.png" /><figcaption>Figure 2: Effect of the TDCh error on the success probability of BG with $n = 10$ qubits ($L_{opt}^{(0)} = 25$).</figcaption></figure>

<figure><img src="image_4.png" /><figcaption>Figure 3: Reachable success probability by Grover's algorithm for $n = 10$ users</figcaption></figure>

where $\delta^{(\lambda)}$ is defined by:

$$ \delta^{(\lambda)} = \left( 1 + \left( \frac{4\theta_G}{\log(1-\lambda)} \right)^2 \right)^{-1/2} . \qquad (12) $$

For latter convenience, we denote this maximum by:

$$ S_{BG}^{(\lambda)} = P_{BG}^{(\lambda)}(L_{opt}^{(\lambda)}) \qquad (13) $$

As $\lambda$ increases, this quantity is reduced. However, $L_{opt}^{(\lambda)}$ is also reduced which means that BG needs less iterations to reach $S_{BG}^{(\lambda)}$ as shown on Fig. 2. This plot also shows that one cannot expect a better reliability from Grover's algorithm by using more iterations than $L_{opt}^{(\lambda)}$. Indeed, increasing $k$ increases the probability to accumulate errors along the iterations.

Thus, we can define a boundary of success that cannot be crossed by Grover's algorithm as shown on Fig. 3. The dashed curve corresponds to $S_{BG}^{(\lambda)}$ and the white region represents the reachable success probabilities when $\lambda$ increases. The reliability of Grover's algorithm is significantly reduced when the noise increases.

### III. MIXED GROVER'S ALGORITHM

#### A. Proposed algorithm

We propose to use and evaluate an hybrid enhancement of Grover's algorithm denoted Mixed Grover (MG). It consists in

<figure><img src="image_5.png" /><figcaption>Figure 4: Proposed searching scheme for reducing the number of iterations in Grover's search problem.</figcaption></figure>

running BG with $k$ iterations deliberately lower than $L_{opt}^{(\lambda)}$ as a reduced number of iterations will limit the effect of the noise. Then, we test with a classical algorithm whether the output $|x\rangle$ effectively verifies $f(x) = 1$. If it does, the computation can stop which allows to use less iterations than Grover's routine. Otherwise, a new trial is launched. A maximum number of trials $T$ is set to bound computational time. We expect that, on average, MG requires less iterations than BG. The process is depicted on Fig. 4

Notice that each trial is independent of each other. Indeed, the measurement performed after each trial suppresses the quantum superposition. Thus, a new trial cannot exploit the previous ones.

#### B. Metrics for performance evaluation

Let us now define the metrics to evaluate the performances of our MG proposal. We first focus on its success probability. One retrieves a solution after exactly $j$ trials with probability $(P_{BG}^{(\lambda)}(k)) \times (1 - P_{BG}^{(\lambda)}(k))^{j-1}$. Thus, the success probability is obtained by considering all the trials values up to $T$:

$$ \begin{aligned} P_{MG}^{(\lambda)}(k, T) &= \sum_{j=1}^{T} (P_{BG}^{(\lambda)}(k)) \cdot (1 - P_{BG}^{(\lambda)}(k))^{j-1} \\ &= 1 - (1 - P_{BG}^{(\lambda)}(k))^{T} \end{aligned} \qquad (14) $$

On the other hand, we evaluate the complexity with the number of iterations. In the worst case, MG parameterized with the pair $(k, T)$ will cost $k \times T$ total iterations. Fortunately, it often costs less resources since one stops the algorithm as soon as a marked element is found. Hence the number of iterations is rather a random variable whose mean value is meaningful. Thus, we define the expected number of iterations
<figure><img src="image_6.png" /><figcaption>Figure 5: Comparison between the complexity of MG and BG to reach the targeted success p for n = 10, λ = 0.02.</figcaption></figure>

<figure><img src="image_7.png" /><figcaption>Figure 6: Complexity of BG and MG to reach the success p for n = 10, λ = 0.02.</figcaption></figure>

to evaluate MG’s complexity:

$$
\begin{equation}
\begin{aligned}
E_i^{(\lambda)}(k, T) = & \sum_{j=1}^{T-1} \left( j \cdot k \cdot (P_{BG}^{(\lambda)}(k)) \cdot (1 - P_{BG}^{(\lambda)}(k))^{j-1} \right) \\
& + T \cdot k \cdot (1 - P_{BG}^{(\lambda)}(k))^{T-1}
\end{aligned}
\tag{15}
\end{equation}
$$

From this expression, one can show that:

$$
E_i^{(\lambda)}(k, T) = \frac{k}{P_{BG}^{(\lambda)}(k)} P_{MG}^{(\lambda)}(k, T). \quad (16)
$$

IV. BENEFITS OF MIXED GROVER

In this section, we compare the MG performances with the
BG ones.

A. Complexity comparison

We first focus on $n = 10$ users and $\lambda = 0.02$ so that BG's reliability is not too low ($S_{BG}^{(\lambda=0.02)} = 0.624$, see Fig. 3). An appropriate parameterization of the MG algorithm ($k, T$) must fulfill a reliability requirement while consuming as less iterations as possible. Thus, given a *targeted success* $p$ and a number of users $n$, we define the optimal pair as:

$$
(k^*, T^*) = \arg \min_{(k,T) \in (\mathbb{N}^*)^2} \left\{ E_i^{(\lambda)}(k,T) \text{ s.t } P_{MG}^{(\lambda)}(k,T) \ge p \right\} \quad (17)
$$

One can find it by an exhaustive search over a well chosen
region for *k* and *T*. First, it is easy to show that:

$$
E_i^{(\lambda)}(k, T) \ge k, \tag{18}
$$

hence MG with $k > L_{opt}^{(\lambda)}$ cannot provide any complexity
advantage over BG. Thus, $k$ can be bounded in $[1, L_{opt}^{(\lambda)}]$. As for
$T$, one can notice that $P_{MG}^{(\lambda)}$, and so $E_i^{(\lambda)}(k, T)$ from Eq. 16,
both grow with $T$ at fixed $k$. Hence $(k^*, T^*)$ can be obtained
by an exhaustive search over the pairs $(k, T(k, p))$ where $k$ is
bounded in $[1, L_{opt}^{(\lambda)}]$ and $T(k, p)$ is the smallest integer such
that $P_{MG}^{(\lambda)}(k, T) \ge p$.

We have reported on Fig. 5 the expected number of itera-
tions obtained with the pairs (k, T(k, p)) for two values of p.

The configuration ($k^*, T^*$) that must be chosen to minimize
the complexity is indicated with a red star. For $p = 0.3$, Fig.
5a shows that the minimum is obtained for $T^* = 1$ which
amounts to use BG algorithm. However, Fig. 5b shows that
there exists a pair with $T^* = 3$ and $k^* = 3$ for $p = 0.62$ such
that ³:

$$
E_i^{(\lambda=0.02)}(k^*, T^*) < \left(P_{BG}^{(\lambda)}\right)^{-1}(p) \quad (19)
$$

It means that in this case, MG presents a complexity advan-
tage over BG while the reliability is still guaranteed by the
constraint $P_{MG}^{(\lambda)}(k, T) \ge p$.

The tendency shown on Fig. 6 underlines that this advantage
shows up when *p* is close to *S*<sub>BG</sub><sup>(*λ*)</sup> for *n* and *λ* fixed. We can see
that MG amounts to use BG when *p* < 0.6 and then becomes
the better solution above this critical value of *p*.

B. Reliability comparison

Contrarily to BG, the maximum success probability of MG
algorithm is always 1. Indeed, for a given value of k:

$$
\lim_{T \to \infty} P_{MG}^{(\lambda)}(k, T) = 1 \quad \forall \lambda > 0 \quad (20)
$$

However, *T* is an additional degree of freedom corresponding
to a classical operation, namely restart Grover’s algorithm
from scratch. Thus, naively pushing *T* too high might result
in a lost of the quadratic speedup.

An interesting compromise might be to find the following
parameterization for a given level of noise $\lambda$:

$$
(k^+, T^+) = \arg \max_{(k,T) \in (\mathbb{N}^*)^2} \left\{ P_{MG}^{(\lambda)}(k,T) \text{ s.t } E_i^{(\lambda)}(k,T) \le C \times L_{opt}^{(0)} \right\} \quad (21)
$$

where *C* is a constant. This way, we enforce MG to keep a
complexity with the same magnitude as the BG one without
noise. Similarly to the previous part, we obtain (*k*<sup>+</sup>, *T*<sup>+</sup>) by an
iterative search over the pairs (*k*, *T*(*k*, *λ*)) where *k* is bounded
in [*1*, *L*<sub>opt</sub><sup>(*λ*)</sup>] but this time *T*(*k*, *λ*) is the biggest integer such
that *E*<sub>*i*</sub><sup>(*λ*)</sup>(*k*, *T*) ≤ *C*L<sub>opt</sub><sup>(0)</sup>.

<footnote>$^3(P_{BG}^{(\lambda)})^{-1}(p)$ gives the minimum number of iterations in $[1, L_{opt}^{(\lambda)}]$ required by Grover's algorithm to reach the success probability $p$</footnote>
<figure><img src="image_8.png" /><figcaption>Figure 7: Success probability of MG under the constraint $E_i^{(\lambda)} \le L_{opt}^{(0)}$ ($C=1$) compared to $S_{BG}^{(\lambda)}$ for $n=10$.</figcaption></figure>

<figure><img src="image_9.png" /><figcaption>Figure 8: Reliability boundary of MG bounded to $CL_{opt}^{(0)}$ iterations compared to $S_{BG}^{(\lambda)}$ for $n=10$.</figcaption></figure>

Fig. 7a (resp. Fig. 7b) shows that MG bounded to 25 iterations for 10 users can reach a success $p \approx 0.8$ for $\lambda = 0.02$ while BG is limited to $S_{BG}^{(\lambda=0.02)} = 0.62$ (resp. $p \approx 0.5$ for $\lambda = 0.05$ while $S_{BG}^{(\lambda=0.05)} = 0.33$). In those examples, our algorithm increases of 20% the success probability of Grover's search without increasing the complexity.

We can plot an analogue of the reliability boundary for MG when its expected number of iterations is bounded. Fig. 8 confirms that our algorithm pushes forward the maximum reachable success at a level of noise $\lambda$. This effect is significantly amplified as $C$ increases. Thanks to the additional degree of freedom, MG permits to improve the success probability for a given complexity budget.

## V. CONCLUSION

In this work, we proposed to use Grover's algorithm in an hybrid format which consists in performing the usual routine several times but with a reduced number of iterations. It might permit to run the ML detector on a noisy quantum processor. Our approach is promising for two main reasons:

* It presents a complexity advantage in the region of success probabilities reachable by BG. Either MG amounts to use BG when $T^* = 1$, or MG beats BG in terms of number of iterations when $p$ is close to $S_{BG}^{(\lambda)}$

* It allows to reach success probabilities out of the accessible range for Grover's algorithm for a given value of the depolarizing rate $\lambda$. It is true even if we bound the expected number of iterations so that MG keeps the quadratic speedup property of Grover's algorithm.

This way, Grover's algorithm is a promising way to perform AUD in a more efficient way. Indeed, the computation of the ML detector (Eq. 2) for $n = 10$ users costs $2^{10} \sim 10^3$ iterations with a classical algorithm. On the other hand, our proposal would require $\sqrt{2^{10}} = 32$ iterations to get a potential solution of the problem. We considered a simple model for the quantum errors. The next step would consist in testing the algorithm on a real quantum processor to further validate this approach.

## REFERENCES

[1] P. Popovski, C. Stefanovic, J. J. Nielsen, et al., "Wireless Access in Ultra-Reliable Low-Latency Communication (URLLC)", en, *IEEE Transactions on Communications*, vol. 67, no. 8, pp. 5783–5801, Aug. 2019. [Online]. Available: https://ieeexplore.ieee.org/document/8705373/.

[2] M. Shirvanimoghaddam, M. Dohler, and S. Johnson, "Massive Non-Orthogonal Multiple Access for Cellular IoT: Potentials and Limitations", *IEEE Communications Magazine*, vol. 55, no. 9, pp. 55–61, 2017, arXiv:1612.00552 [cs, math]. [Online]. Available: http://arxiv.org/abs/1612.00552.

[3] C. Goursaud, A. Julien-Vergonjanne, C. Aupetit-Berthelemot, J.-P. Cances, and J.-M. Dumas, "DS-OCDMA receivers based on parallel interference cancellation and hard limiters", en, *IEEE Transactions on Communications*, vol. 54, no. 9, pp. 1663–1671, Sep. 2006. [Online]. Available: http://ieeexplore.ieee.org/document/1703824/.

[4] M. I. Habibie, J. Hamie, and C. Goursaud, "A Performance Comparison of Classical and Quantum Algorithm for Active User Detection", in *SPAWC 2022 - The 23rd IEEE International Workshop on Signal Processing Advances in Wireless Communications*, Oulu, Finland, Jul. 2022. [Online]. Available: https://hal.science/hal-03820291.

[5] L. K. Grover, *A fast quantum mechanical algorithm for database search*, Nov. 1996. [Online]. Available: http://arxiv.org/abs/quant-ph/9605043.

[6] P. Botsinis, D. Alanis, Z. Babar, et al., "Quantum Search Algorithms for Wireless Communications", en, *IEEE Communications Surveys & Tutorials*, vol. 21, no. 2, pp. 1209–1242, 2019. [Online]. Available: https://ieeexplore.ieee.org/document/8540839/.

[7] C. Durr and P. Hoyer, *A Quantum Algorithm for Finding the Minimum*, Jan. 1999. [Online]. Available: http://arxiv.org/abs/quant-ph/9607014.

[8] Y. Wang and P. S. Krstic, "Prospect of using Grover's search in the noisy-intermediate-scale quantum-computer era", *Physical Review A*, vol. 102, no. 4, p. 042609, Oct. 2020, arXiv:2006.10037 [quant-ph]. [Online]. Available: http://arxiv.org/abs/2006.10037.

[9] Y. E. Kaderi, A. Honecker, and I. Andriyanova, "Performance of Uncoded Implementation of Grover's Algorithm on Today's Quantum Processors", in *2023 IEEE Information Theory Workshop (ITW)*, arXiv:2212.10482 [quant-ph], Apr. 2023, pp. 209–214. [Online]. Available: http://arxiv.org/abs/2212.10482.

[10] M. Boyer, G. Brassard, P. Hoeyer, and A. Tapp, "Tight bounds on quantum searching", *Fortschritte der Physik*, vol. 46, no. 4-5, pp. 493–505, Jun. 1998. [Online]. Available: http://arxiv.org/abs/quant-ph/9605034.

[11] I. Cohn, A. L. F. de Oliveira, E. Buksman, and J. G. L. de Lacalle, "Grover's search with local and total depolarizing channel errors", *International Journal of Quantum Information*, vol. 14, no. 02, p. 1650009, Mar. 2016. [Online]. Available: http://arxiv.org/abs/1508.03302.

[12] J. Xiao, X. Ma, and S. W. McLaughlin, "Quantifying information rate losses with zero-forcing and maximum-likelihood detectors", en, in *2010 IEEE International Conference on Acoustics, Speech and Signal Processing*, Dallas, TX, USA: IEEE, 2010, pp. 3342–3345. [Online]. Available: http://ieeexplore.ieee.org/document/5496010/.