Depth optimization of quantum search algorithms beyond Grover's algorithm

TL;DR

This paper introduces a new depth optimization method for quantum search algorithms, demonstrating that Grover's algorithm is not depth-optimal and proposing a multistage, parallelizable search approach to reduce errors on noisy quantum computers.

Contribution

It presents a novel multistage quantum search algorithm that improves depth efficiency and error resilience beyond Grover's traditional approach.

Findings

Grover's algorithm is not optimal in depth.

The proposed multistage algorithm reduces errors.

Parallel execution of stages enhances performance.

Abstract

Grover's quantum search algorithm provides a quadratic speedup over the classical one. The computational complexity is based on the number of queries to the oracle. However, depth is a more modern metric for noisy intermediate-scale quantum computers. We propose a new depth optimization method for quantum search algorithms. We show that Grover's algorithm is not optimal in depth. We propose a quantum search algorithm, which can be divided into several stages. Each stage has a new initialization, which is a rescaling of the database. This decreases errors. The multistage design is natural for parallel running of the quantum search algorithm.

Tables

Table 1. Table 1: Estimated MED of Grover’s algorithm, based on α = 1 𝛼 1 \alpha=1 . The number α 𝛼 \alpha (defined in Eq. ( 11 )) is the ratio between oracle depth and diffusion operator depth. Diffusion operators D n subscript 𝐷 𝑛 D_{n} have depth d ​ ( D n ) = { 16 , 32 , 64 , 123 , 163 , 203 , 243 } d subscript 𝐷 𝑛 16 32 64 123 163 203 243 \text{d}(D_{n})=\{16,32,64,123,163,203,243\} with n = 4 , 5 , … , 10 𝑛 4 5 … 10 n=4,5,\ldots,10 , which comes from the decomposition of an n 𝑛 n -qubit Toffoli gate Barenco  et al. ( 1995 ) . Single-run depth is the depth of the optimal sequence (without considering the success probability). The MED d G ​ ( α = 1 ) subscript d G 𝛼 1 \text{d}_{\text{G}}(\alpha=1) is defined in Eq. ( 12 ). The notation S n ​ ( j , 0 ) subscript 𝑆 𝑛 𝑗 0 S_{n}(j,0) means G n j subscript superscript 𝐺 𝑗 𝑛 G^{j}_{n} .

$n$	Optimal sequence	Success probability	Single-run depth	${\text{d}}_{\text{G}}\left(1\right)$
4	$S_4(1,0)$	0.473	30	63.47
5	$S_5(2,0)$	0.602	124	205.83
6	$S_6(4,0)$	0.816	504	617.36
7	$S_7(6,0)$	0.833	1464	1756.35
8	$S_8(9,0)$	0.861	2916	3388.03
9	$S_9(12,0)$	0.798	4848	6071.76
10	$S_{10}(18,0)$	0.838	8712	10397.28

Table 2. Table 2: MED of one-stage search algorithm optimized by local diffusion operators, based on α = 1 𝛼 1 \alpha=1 . The MED d 1 ​ ( α = 1 ) subscript d 1 𝛼 1 \text{d}_{1}(\alpha=1) is defined in Eq. ( 17 ). The depth of the diffusion operator is d ​ ( D n ) = { 8 , 16 , 32 , 64 , 123 , 163 , 203 , 243 } d subscript 𝐷 𝑛 8 16 32 64 123 163 203 243 \text{d}(D_{n})=\{8,16,32,64,123,163,203,243\} with n = 3 , 4 , … , 10 𝑛 3 4 … 10 n=3,4,\ldots,10 . The sequence notation means S n , m ​ ( j 1 , j 2 , … , j q ) = G n j q ​ G m j q − 1 ​ ⋯ ​ G n j 2 ​ G m j 1 subscript 𝑆 𝑛 𝑚 subscript 𝑗 1 subscript 𝑗 2 … subscript 𝑗 𝑞 superscript subscript 𝐺 𝑛 subscript 𝑗 𝑞 superscript subscript 𝐺 𝑚 subscript 𝑗 𝑞 1 ⋯ superscript subscript 𝐺 𝑛 subscript 𝑗 2 superscript subscript 𝐺 𝑚 subscript 𝑗 1 S_{n,m}(j_{1},j_{2},\ldots,j_{q})=G_{n}^{j_{q}}G_{m}^{j_{q-1}}\cdots G_{n}^{j_{2}}G_{m}^{j_{1}} , see Eq. ( 14 ), and j q subscript 𝑗 𝑞 j_{q} is always the number of the local diffusion operator.

$n$	Optimal sequence	Success probability	Single-run depth	${\text{d}}_1\left(1\right)$
4	$S_{4,3}(1,1)$	0.821	52	63.32
5	$S_{5,4}(1,1,1)$	0.849	154	181.48
6	$S_{6,4}(1,1,2)$	0.755	360	476.97
7	$S_{7,4}(1,1,2,1,2)$	0.887	1173	1322.75
8	$S_{8,4}(1,1,2,1,2,1,2)$	0.875	2211	2527.43
9	$S_{9,5}(1,1,2,1,2,1,2,1,2)$	0.831	3713	4470.20
10	$S_{10,5}(1,1,2,1,2,1,2,1,2,1,2,1,2)$	0.847	6453	7614.56

Table 3. Table 3: MED of the two-stage search algorithm, based on α = 1 𝛼 1 \alpha=1 . The MED d 2 ​ ( α = 1 ) subscript d 2 𝛼 1 \text{d}_{2}(\alpha=1) is defined in Eq. ( 26 ). The depth of the diffusion operator is d ​ ( D n ) = { 4 , 8 , 16 , 32 , 64 , 123 , 163 , 203 , 243 } d subscript 𝐷 𝑛 4 8 16 32 64 123 163 203 243 \text{d}(D_{n})=\{4,8,16,32,64,123,163,203,243\} with n = 2 , 3 , 4 , … , 10 𝑛 2 3 4 … 10 n=2,3,4,\ldots,10 .

$n$	Optimal sequence		Success probability		Single-run depth		${\text{d}}_2\left(1\right)$
	Stage 1	Stage 2	Stage 1	Stage 2	Stage 1	Stage 2
4	$S_{4,2}(1,1)$	$S_2(1,0)$	0.953	1	48	18	69.25
5	$S_{5,2}(1,1)$	$S_2(1,0)$	0.658	1	96	34	197.51
6	$S_{6,2}(1,1,1,1)$	$S_2(1,0)$	0.791	1	384	66	569.22
7	$S_{7,4}(1,4)$	$S_4(2,0)$	0.739	0.908	792	274	1587.09
8	$S_{8,5}(1,4,1,2)$	$S_{5,4}(1,1,2)$	0.882	0.998	1806	724	2876.40
9	$S_{9,5}(1,4,1,3,1,3)$	$S_{5,4}(1,1,2)$	0.906	0.998	3542	884	4898.88
10	$S_{10,5}(1,4,1,3,1,3,1,3)$	$S_{5,4}(1,1,2)$	0.810	0.998	5485	1044	8081.89

Table 4. Table 4: Numerical values for critical ratios α c , 1 subscript 𝛼 𝑐 1 \alpha_{c,1} in Eq. ( 31 ) and α c , 2 subscript 𝛼 𝑐 2 \alpha_{c,2} in Eq. ( 48 ). The results are based on the linear scale depth of the diffusion operator d ​ ( D n ) d subscript 𝐷 𝑛 \text{d}(D_{n}) , see Ref. Barenco  et al. ( 1995 ) . Theorem 1 shows that α c , 1 subscript 𝛼 𝑐 1 \alpha_{c,1} scales as 𝒪 ​ ( n − 1 ​ 2 n / 2 ) 𝒪 superscript 𝑛 1 superscript 2 𝑛 2 \mathcal{O}(n^{-1}2^{n/2}) . Theorem 2 shows that α c , 2 subscript 𝛼 𝑐 2 \alpha_{c,2} approaches 1 + 3 1 3 1+\sqrt{3} when N = 2 n 𝑁 superscript 2 𝑛 N=2^{n} is very large.

$n$	4	5	6	7	8	9	10
${\alpha }_{c,1}$	2.07	4.64	14.65	29.45	32.88	45.95	83.97
${\alpha }_{c,2}$	NA	1.21	1.53	1.76	2.00	2.17	2.28

Equations

$$|s_n⟩=H^{\otimes n}|0{⟩}^{\otimes n}$$

$$U_f(11_{2^n}\otimes H)|x⟩\otimes |1⟩=(-1{)}^{f(x)}(11_{2^n}\otimes H)|x⟩\otimes |1⟩$$

$$U_t=11_{2^n}-2|t⟩⟨t|$$

$$D_n=2|s_n⟩⟨s_n|-11_{2^n}$$

$$G_n=D_n{U}_t$$

$$P_n(j)=|⟨t|G_n^j|s_n⟩{|}^2={\sin }^2((2j+1)\theta )$$

$$D_{n,m}=11_{2^{n-m}}\otimes (2|s_m⟩⟨s_m|-11_{2^m})$$

$$G_{n,m}=D_{n,m}{U}_t$$

$$|t⟩=|t_1⟩\otimes |t_2⟩,$$

$$|ntt⟩=\frac{1}{\sqrt{b-1}}\sum _{j\ne t_2}|t_1⟩\otimes |j⟩,$$

$$|u⟩=\frac{1}{\sqrt{N-b}}\left(\sqrt{N}|s_n⟩-|t⟩-\sqrt{b-1}|ntt⟩\right)$$

$$|s_n⟩=\sin \gamma \sin {\theta }_2|t⟩+\sin \gamma \cos {\theta }_2|ntt⟩+\cos \gamma |u⟩$$

$$\alpha =\frac{\text{d}(U_t)}{\text{d}(D_n)}$$

$${\text{d}}_{\text{G}}(\alpha )=\underset{j}{\min }\frac{\text{d}(G_n^j)}{P_n(j)}$$

$${\text{d}}_{\text{G}}(\alpha )\approx 0.69\times 2^{n/2}(\alpha +1)\text{d}(D_n)$$

$$S_{n,m}(j_1,j_2,\dots ,j_q)=G_n^{j_1}{G}_m^{j_2}\cdots G_n^{j_{q-1}}{G}_m^{j_q}$$

$$j_{\text{tot}}=\sum _{p=1}^q{j}_p$$

$$P_{n,m}(j_1,j_2,\dots ,j_q)=|⟨t|S_{n,m}(j_1,j_2,\dots ,j_q)|s_n⟩{|}^2$$

$${\mathrm{d}}_1(\alpha )=\underset{m,j_1,j_2,\dots ,j_q}{\min }\frac{\mathrm{d}(S_{n,m}(j_1,j_2,\dots ,j_q))}{P_{n,m}(j_1,j_2,\dots ,j_q)}$$

$$P_6(4)=|⟨t|G_6^4|s_6⟩{|}^2\approx 0.816$$

$$S_{6,4}(1,1,2)=G_4{G}_6{G}_4^2$$

$$P_{6,4}(1,1,2)=|⟨t|S_{6,4}(1,1,2)|s_6⟩{|}^2\approx 0.755$$

$${\text{d}}_1(\alpha )\le {\text{d}}_{\text{G}}(\alpha )$$

$$|t⟩=|t_1⟩\otimes |t_2⟩$$

$$S_{n,m_2}^{(1)}(j_1,j_2,\dots ,j_q)=G_n^{j_1}{G}_{m_2}^{j_2}\cdots G_n^{j_{q-1}}{G}_{m_2}^{j_q}$$

$$|t_1^{\prime }⟩\otimes |s_{m_2}⟩$$

$$|s_{m_2}⟩=H^{\otimes m_2}|0{⟩}^{\otimes m_2}$$

$$S_{m_2,m^{\prime }}^{(2)}(j_1^{\prime },j_2^{\prime },\dots ,j_q^{\prime })=G_{m_2}^{j_1^{\prime }}{G}_{m^{\prime }}^{j_2^{\prime }}\cdots G_{m_2}^{j_{q-1}^{\prime }}{G}_{m^{\prime }}^{j_q^{\prime }}$$

$${\mathrm{d}}_2(\alpha )=\underset{m_2,m^{\prime },j_1,\dots ,j_q,j_1^{\prime },\dots ,j_q^{\prime }}{\min }\frac{\mathrm{d}(S_{n,m_2}^{(1)}(j_1,j_2,\dots ,j_q))+\mathrm{d}(S_{m_2,m^{\prime }}^{(2)}(j_1^{\prime },j_2^{\prime },\dots ,j_q^{\prime }))}{P_{n,m_2}^{(1)}(j_1,j_2,\dots ,j_q)P_{m_2,m^{\prime }}^{(2)}(j_1^{\prime },j_2^{\prime },\dots ,j_q^{\prime })}$$

$$P_4(3)=|⟨t|G_4^3|s_4⟩{|}^2\approx 0.961$$

$$P_{4,2}^{(1)}(1,1)\approx 0.953$$

Full text

I Introduction

Quantum algorithms are designed to outperform the best classical ones Nielsen and Chuang (2010). Many nondeterministic NP-hard problems still have only the exhaustive search way to solve them Bennett et al. (1997). The one-way function (oracle) $f(x)$ ($f:\{0,1\}^{n}\rightarrow\{0,1\}$) can identify the solution state: if $t$ is the solution (target state), then $f(t)=1$; otherwise the one-way function output is zero. The classical way to execute the exhaustive search is by querying each state in the database (of $N$ items) by the one-way function. In the worst case, the total number of queries to the oracle is $N-1$. The principle of quantum superposition provides a superior way to perform the exhaustive search. Suppose that $N=2^{n}$, where $n$ is the number of qubits to represent the database. Grover’s algorithm can find one target state with oracle complexity $\mathcal{O}(\sqrt{N})$, which quadratically outperforms the classical algorithm Grover (1997); Giri and Korepin (2017). The oracle in Grover’s algorithm is $U_{f}$: $U_{f}|x\rangle|y\rangle=|x\rangle|f(x)\oplus y\rangle$ with $x\in\{0,1\}^{n}$ and $y\in\{0,1\}$.

Quantum computers have been vastly developed over the last ten years Barends et al. (2014); Ballance et al. (2016); Figgatt et al. (2017); Arute et al. (2019). Still shallow-depth algorithms can be realized on real quantum computers (for the noisy intermediate-scale quantum (NISQ) era, see Ref. Preskill (2018)). The width (the number of physical qubits) represents the size of quantum computers. The algorithm’s depth (the number of consecutive gate operations) represents the physical implementation time for the algorithm. Multiplying the width and depth we get the quantum volume, which gives a metric for NISQ computers Cross et al. (2019). Coherence time is limited in NISQ computers. A set of gates which can approximate any unitary operation is called the universal quantum gate set (Solovay–Kitaev theorem) Nielsen and Chuang (2010). We assume that the quantum computer is equipped with a universal quantum gate set. So, the depth is counted by universal quantum gate operations.

The quantum oracle $U_{f}$ is realized by quantum gates from the universal quantum gate set. We assume that the depth of the quantum oracle scales polynomially with $n$ Figgatt et al. (2017). The oracle complexity would be equivalent to the depth complexity if the quantum oracle would be the only operation realized in Grover’s algorithm. However, it is not true. Another unitary operation (diffusion operator) is required for Grover’s algorithm Grover (1997); Giri and Korepin (2017). How to choose the diffusion operator is related to the initial state preparation Grover (1998); Brassard et al. (2002). The unstructured population space $\{0,1\}^{n}$ (database) can be prepared in an equal superposition state on a quantum computer polynomial efficiently:

[TABLE]

with single-qubit Hadamard gate $H$ Nielsen and Chuang (2010). Note that the initial state $|s_{n}\rangle$ can be efficiently prepared with a depth of one circuit. The diffusion operator has the constraint that the state $|s_{n}\rangle$ is the eigenvector of the diffusion operator with eigenvalue 1 Tulsi (2012, 2015).

Grover’s algorithm is the only threat to postquantum cryptography. The postquantum cryptography standardization proposed by NIST in 2016 introduced the depth bound. Recently, more studies focused on the resource estimation, such as width and depth, for Grover’s algorithm instead of the traditional oracle complexity Kim et al. (2018); Jaques et al. (2019). Grover’s algorithm is optimal in oracle complexity Boyer et al. (1998); Zalka (1999). However, no research addressed the depth of the quantum search algorithm. Surprisingly, the depth of the diffusion operator can be reduced to one Kato (2005); Jiang et al. (2017). However, these algorithms have 1/2 maximal successful probability, and the expected depth is not as efficient as the original Grover’s algorithm. Inspired by the quantum partial search algorithm (QPSA) Grover and Radhakrishnan (2005); Korepin and Grover (2006); Korepin (2005); Korepin and Liao (2006), we introduce a new depth optimization for the quantum search algorithm. Our algorithm can have lower depth than Grover’s algorithm. To further lower the depth, we can apply a divide-and-conquer strategy (combined with depth optimization). The divide-and-conquer strategy means that the search algorithm is realized by several stages. Each stage can find a partial address of the target state. The next-stage initial state is the rescaled version of the last-stage initial state. The divide-and-conquer strategy naturally allows the parallel running of the quantum search algorithm.

If the oracle takes much more depths than diffusion operator depth, then the oracle complexity will be approximately equivalent to the depth complexity. We can define the ratio between oracle depth and diffusion operator depth. Above a critical ratio, Grover’s algorithm is optimal in depth. Based on the depth optimization method proposed in this paper, we show that the critical ratio is $\mathcal{O}(n^{-1}2^{n/2})$. If we divide the algorithm into two stages, the critical ratio is a constant.

The paper is organized as follow. In Sec. II, we briefly review quantum search algorithms. The first one is Grover’s original algorithm and the other is QPSA. We also set up notations. In Sec. III, we introduce the depth optimization method for the quantum search algorithm. We also show how to combine the divide-and-conquer strategy with depth optimization. In Sec. IV, we talk about the critical ratios. Below the critical ratio, we can have a search algorithm which has lower depth compared to Grover’s algorithm. Parallel running of the quantum search algorithm is briefly discussed in Sec. V. Section VI gives conclusions and outlook. We wrote three Appendixes. Appendix A provides detailed examples of the $n=6$ search algorithm with depth optimizations; Appendix B lists the numerical details provided in the main text; Appendix C shows the numerical values of critical ratios.

II Review of Quantum Search Algorithms

II.1 Grover’s Algorithm

The quantum oracle $U_{f}$ flips the ancillary qubit, if the target state $|t\rangle$ is fed in. The ancillary qubit can be prepared in the superposition state $H|1\rangle=(|0\rangle-|1\rangle)/\sqrt{2}$. Then the oracle gives a sign flip acting on the target state:

[TABLE]

Here $1\!\!1_{2^{n}}$ is the identity operator on the $2^{n}$ dimensional Hilbert space. For convenience, we denote the oracle $U_{f}$ as

[TABLE]

if the ancillary qubit $H|1\rangle$ is prepared. The general phase flip can be constructed as follows: $U_{t,\phi}=1\!\!1_{2^{n}}-(1-e^{-i\phi})|t\rangle\langle t|$ with complex unit $i=\sqrt{-1}$. The generalized oracle $U_{t,\phi}$ has applications in the sure success search algorithm Brassard et al. (2002); Morales et al. (2018) and the fixed point search algorithm (for an unknown number of target states) Yoder et al. (2014). Note that the operator $U_{t,\phi}$ ($\phi\neq\pi$) can be realized by two quantum oracles $U_{f}$ Yoder et al. (2014). In this paper, we do not consider the generalized oracle $U_{t,\phi}$ (low depth consideration). We concentrate on the one-target-state case. The depth optimization method in Sec. III can be easily generalized to multitarget cases.

The oracle $U_{t}$ reflects the state over the plane perpendicular to the target state. The most efficient diffusion operator (unstructured database search) is

[TABLE]

Note that $|s_{n}\rangle$ defined in Eq. (1) is the equal superposition of all items in the database. The operator $D_{n}$ can be viewed as a reflection of the amplitude in the average. The diffusion operator $D_{n}$ does not query the oracle. Therefore, the oracle complexity does not include the resource cost by $D_{n}$. The diffusion operator $D_{n}$ is single-qubit-gate-equivalent to the generalized $n$-qubit Toffoli gate $\Lambda_{n-1}(X)$ Nielsen and Chuang (2010). Here $X$ is the NOT gate (Pauli-X gate). The notation $\Lambda_{n-1}(X)$ implies the $n-1$ control qubits NOT gate. When $n=3$, $\Lambda_{2}(X)$ is the Toffoli gate. When $n=2$, $\Lambda_{1}(X)$ is the controlled-NOT (CNOT) gate. How to realize the $\Lambda_{n-1}(X)$ gate on a real quantum computer is highly nontrivial. It is well known that an $n$-qubit $\Lambda_{n-1}(X)$ gate can be constructed with linear $n$ depth or quadratic $n^{2}$ depth from the universal gate set (CNOT gate plus single-qubit gates) Barenco et al. (1995). Recent works also show that the $n$-qubit $\Lambda_{n-1}(X)$ gate can be realized in $\log n$ depth if $n$-qubit ancillary qubits are provided He et al. (2017) or qutrit states are applied Gokhale et al. (2019).

One query to oracle $U_{t}$ defined in Eq. (3) combined with the diffusion operator $D_{n}$ defined in Eq. (4) is called the Grover iteration or Grover operator:

[TABLE]

See Fig. 1a for the quantum circuit diagram of $G_{n}$. The diffusion operator $D_{n}$ reflects the average of the whole database. The operator $G_{n}$ is also called the global Grover iteration (global Grover operator). One Grover operator $G_{n}$ uses one query to oracle $U_{f}$. Applying $G_{n}$ iteratively on the initial state $|s_{n}\rangle$, the amplitude of the target state will be amplified. After $j$ Grover iterations, the success probability $P_{n}(j)$ is

[TABLE]

with $\sin\theta=1/\sqrt{N}$. When $j$ reaches $j_{\text{max}}=\lfloor\pi\sqrt{N}/4\rfloor$, the probability of finding the target state approaches 1. The maximal iteration number $j_{\text{max}}$ is the square root of $N$. Clearly, Grover’s algorithm provides a quadratic speedup compared with the classical algorithm (in oracle complexity). The idea behind Grover’s algorithm can be generalized into the amplitude amplification algorithm Brassard et al. (2002).

The success probability (finding the target state) does not scale linearly with the number of iterations. It suggests that Grover’s algorithm becomes less efficient when $j$ approaches $j_{\text{max}}$. Previous works argued that the expected number of iterations $j/P_{n}(j)$ has the minimum at $j_{\text{exp}}=\lfloor 0.583\sqrt{N}\rfloor$, which is smaller than $j_{\text{max}}$ Boyer et al. (1998); Gingrich et al. (2000). When $j$ is $j_{\text{exp}}$, the success probability is around 0.845. In practice, the iteration number $j_{\text{exp}}$ has a high probability to find the target state. The measurement result can be verified in classical ways. If the result fails, one has to run the algorithm again. The expected number of oracles is minimized at $j_{\text{exp}}$.

II.2 Quantum Partial Search Algorithm

The QPSA was introduced by Grover and Radhakrishnan Grover and Radhakrishnan (2005). Since Grover’s algorithm is optimal (in oracle complexity), the QPSA trades accuracy for speed. A database of $N$ items is divided into $K$ blocks: $N=bK$. Here $b$ is the number of items in each block. We can assume that the number $b$ is also a power of 2: $b=2^{m}$. And the number of blocks is $K=2^{n-m}$. The QPSA can find the block which has the target state. In other words, the QPSA finds the partial $(n-m)$-bit of the target state (which is $n$ bits long). The optimized QPSA can win over Grover’s algorithm a number scaling as $\sqrt{b}$ Grover and Radhakrishnan (2005); Korepin (2005); Korepin and Grover (2006). A larger block size (less accuracy) gives a faster algorithm.

Suppose that the address of the target state $|t\rangle$ is divided into $|t\rangle=|t_{1}\rangle\otimes|t_{2}\rangle$. Here $t_{1}$ is $(n-m)$ bits long and $t_{2}$ is $m$ bits long. The task is to find $t_{1}$ instead of the whole $t$. Besides the diffusion operator $D_{n}$ in Eq. (4), the QPSA introduces a new diffusion operator $D_{n,m}$:

[TABLE]

The diffusion operator $D_{n,m}$ reflects around the average in a block (simultaneously in each block). The diffusion operator $D_{n,m}$ can be viewed as the rescaled version of $D_{n}$ in Eq. (4): the database with size $2^{n}$ is rescaled into size $2^{m}$. We can define a new Grover operator as

[TABLE]

See Fig. 1b for the quantum circuit diagram of $G_{n,m}$. The diffusion operator $D_{n,m}$ reflects the average of block items. The operator $G_{n,m}$ is also called the local Grover iteration (local Grover operator). For simplicity, we shorten the notations to $D_{m}\equiv D_{n,m}$ and $G_{m}\equiv G_{n,m}$ in the rest of paper.

The QPSA is realized by applying operators $G_{m}$ and $G_{n}$ on the initial state $|s_{n}\rangle$. Then partial bits $t_{1}$ can be found with high probability (computational basis measurement on the final state). In the QPSA, the amplitudes of all nontarget items in the target block are the same, and the amplitudes of all items in the nontarget blocks are the same. Therefore, we can follow only three amplitudes. Let us introduce a basis:

[TABLE]

The state $|ntt\rangle$ is the normalized sum of all nontarget states in the target block. The state $|u\rangle$ is the normalized sum of all items in the nontarget blocks. At the new basis, the initial state $|s_{n}\rangle$ in Eq. (1) can be rewritten as

[TABLE]

The angle $\theta_{2}$ is defined as $\sin\theta_{2}=1/\sqrt{b}$. The angle $\gamma$ is defined as $\sin\gamma=1/\sqrt{K}$. The global Grover operator $G_{n}$ defined in Eq. (5) and the local Grover operator $G_{m}$ defined in Eq. (8) can be reformulated as elements in the $O(3)$ group Korepin and Vallilo (2006). Operators $G_{m}$ and $G_{n}$ have highly nontrivial commutation relations Korepin and Vallilo (2006). The order of application of these operators is the key in the QPSA. Extensive studies have suggested that the optimal sequence (in oracle complexity) is $G_{n}G_{m}^{j_{2}}G_{n}^{j_{1}}$ Korepin and Liao (2006); Korepin and Vallilo (2006). One can minimize the number of queries to the oracle (minimize $j_{1}+j_{2}+1$) given by a threshold success probability. The QPSA requires less number of oracles (the saved oracle number scales as $\sqrt{b}$) than Grover’s algorithm. The QPSA can also be generalized into multitarget cases Choi and Korepin (2007); Zhang and Korepin (2018). Interestingly, the QPSA can be performed in a hierarchical way: each time the QPSA finds several bits of the target bits $t$ Korepin and Xu (2007).

III Depth Optimization

III.1 Minimal Expected Depth

Depth is defined as the number of consecutive parallel gate operations. For example, the initial state $|s_{n}\rangle$ can be prepared with one depth circuit, see (1). Suppose that the diffusion operator $D_{n}$ in Eq. (4) has depth $\text{d}(D_{n})$, which is the same as the depth of the $n$-qubit generalized Toffoli gate $\Lambda_{n-1}(X)$ Nielsen and Chuang (2010). Different search tasks have different oracle realizations. We denote the ratio of oracle depth $U_{t}$ and diffusion operator depth $D_{n}$ as $\alpha$:

[TABLE]

It is an important parameter for depth optimization. For the one-item search algorithm, the practical minimal value for $\alpha$ is 1: $\alpha\geq 1$ Figgatt et al. (2017). The ratio $\alpha$ maybe different for the same problem with a different database size. We fix $n$; then the ratio $\alpha$ is a constant for one problem. The design for a low-depth generalized Toffoli gate can also be a benefit for oracle depth Gokhale et al. (2019).

Given by $\text{d}(D_{n})$ and $\alpha$, Grover’s algorithm can be mapped to depth complexity directly. We define the minimal expected depth (MED) of Grover’s algorithm as:

[TABLE]

Here $P_{n}(j)$ defined in Eq. (6) is the success probability of finding the target state (with $j$ Grover iterations). The numerator denotes the depth $\text{d}(G_{n}^{j})=(\alpha+1)j\text{d}(D_{n})$. The above optimization is the same as the expected iteration number optimization $j/P_{n}(j)$ Boyer et al. (1998); Gingrich et al. (2000), up to a constant factor. Therefore, we can use $j_{\text{exp}}=\lfloor 0.583\sqrt{N}\rfloor$ in the MED. Note that we have $P_{n}(j_{\text{exp}})\approx 0.845$. Then we have

[TABLE]

If the oracle can be constructed in polynomial depth $\text{d}(U_{t})=\mathcal{O}(n^{k})$, then the MED of Grover’s algorithm scales as $\mathcal{O}(n^{k}2^{n/2})$ (assume that $k>1$). Grover’s algorithm is optimal in oracle complexity Boyer et al. (1998); Zalka (1999). The minimal expected iteration number $j_{\text{exp}}$ is optimal. The scale $\mathcal{O}(n^{k}2^{n/2})$ is also optimal for depth complexity. However, we show that the number $\text{d}_{\text{G}}(\alpha)$ in Eq. (13) is not optimal (if $\alpha$ in Eq. (11) is finite).

III.2 Optimization Method

The local diffusion operator $D_{m}$ defined in Eq. (7) has lower depth than the global diffusion operator $D_{n}$ in Eq. (4). The optimization idea is to replace the global diffusion operator by the local diffusion operator. The global Grover operator $G_{n}$ defined in Eq. (5) does not commute with the local Grover operator $G_{m}$ in Eq. (8) Korepin and Vallilo (2006). The order of $G_{n}$ and $G_{m}$ is important. Suppose that we have the sequence

[TABLE]

Here $\{j_{1},j_{2},\ldots,j_{q}\}$ are some non-negative integers. We have

[TABLE]

total number of queries to the oracle. To remove the ambiguity in the notation $S_{n,m}(j_{1},j_{2},\ldots,j_{q})$, we require that the last number $j_{q}$ is always the number of local Grover operators. For example, $S_{6,4}(1,2)=G_{6}G^{2}_{4}$ and $S_{6,4}(1,1,0)=G_{4}G_{6}$. Note that $S_{n,m}(j,0)=G^{j}_{n}$ is the original Grover algorithm. Since the sequence $S_{n,m}(j,0)=G^{j}_{n}$ does not have any local Grover operators, the number $m$ is irrelevant. As convention, we choose the notation $S_{n}(j,0)=S_{n,m}(j,0)$. The sequence $S_{n,m}(j_{1},j_{2},\ldots,j_{q})$ can find the target state with probability:

[TABLE]

Then we can define the expected depth of the $S_{n,m}(j_{1},j_{2},\ldots,j_{q})$ algorithm. We want to minimize the expected depth, like for Grover’s algorithm (12). Define a new MED:

[TABLE]

The minimization goes through non-negative integers $\{j_{1},j_{2},\ldots,j_{q}\}$. We also optimize the number $m$ (positive integer), which is $m<n$. The minimal value for $m$ is 2. The subscript 1 defined in $\text{d}_{1}(\alpha)$ suggests that we find the target state in one stage, i.e., no measurement within the algorithm until the end. In the quantum circuit model, a one-stage algorithm means only three steps: initialization, unitary operations and measurements. We can define multistage algorithms, which have several rounds of initializations, unitary operations, and measurements. Later we define the MED of multistage search algorithms.

Let us see one example. For $n=6$, Grover’s algorithm has the MED when $j=4$:

[TABLE]

Consider a new sequence:

[TABLE]

and $S_{6,4}(1,1,2)$ gives the success probability

[TABLE]

Note that both sequences $G_{6}^{4}$ and $G_{4}G_{6}G_{4}^{2}$ have four oracles. According to Barenco et al. (1995), six-qubit and four-qubit Toffoli gates can be decomposed into 64 and 16 depth circuits (with single- and two-qubit gates). We suppose that $\text{d}(D_{6})=64$ and $\text{d}(D_{4})=16$. One can find that if the ratio $\alpha$ in Eq. (11) is $\alpha<2.029$, then the new sequence $G_{4}G_{6}G_{4}^{2}$ has a lower expected depth. More examples (about the $n=6$ search algorithm) with quantum circuit diagrams can be found in Appendix A.

We can go back to Grover’s algorithm if the number of $G_{m}$ is zero. We always have

[TABLE]

The choice of subspace (acted upon by local diffusion operators $D_{m}$ defined in (7)) can be arbitrary, such as qubits with high connectivity in real quantum computers. But all local diffusion operators $D_{m}$ should act on the same qubits. For example, the sequence $S_{6,4}(1,1,2)$ has three local Grover operators. The three local diffusion operators are acting on the same four qubits. Making the wrong choice of the subspace can dramatically increase the number of invariant amplitude subspaces. Such a strategy may have some advantages in search algorithms, but it is beyond the scope of this paper.

The minimization results will depend on: the size of the database (the number $n$), the ratio between oracle depth $\text{d}(U_{t})$ and diffusion operator depth $\text{d}(D_{n})$ (the value of $\alpha$ defined in (11)); how $\text{d}(D_{n})$ scales with $n$ (logarithmic, linear, or quadratic with $n$). In numerical optimizations, we can set some constraints which rule out the possibility $\text{d}_{1}(\alpha)<\text{d}_{\text{G}}(\alpha)$. For example, we can set the total number of $G_{n}$ to less than $\lfloor 0.69\sqrt{N}\rfloor$; if the number of $G_{n}$ is $j$, then the number of $G_{m}$ should be less than $\lfloor(0.69\sqrt{N}-j)(\alpha+1)/\alpha\rfloor$. As examples, we find the optimal sequence for $n=4,5,\ldots,10$ with $\alpha=1$ (assuming $\mathcal{O}(n)$ depth of the $\Lambda_{n-1}(X)$ gate Barenco et al. (1995)). The estimated depths are plotted in Fig. 2. Details of the corresponding optimal sequences and success probabilities can be found in Appendix B.

III.3 Depth Optimizations for Multistage Quantum Search Algorithms

In the NISQ era, errors can be suppressed if a long algorithm is divided into shorter pieces (by new initializations and measurements). Inspired by the hierarchy QPSA Korepin and Xu (2007), we propose depth optimizations for the multistage quantum search algorithm. For simplicity, we consider the two-stage quantum search algorithm firstly.

Suppose that the target state is divided into two-parts:

[TABLE]

Suppose that the bit length of $t_{1}$ is $m_{1}$ and the bit length of $t_{2}$ is $m_{2}$. Note that we have $m_{1}+m_{2}=n$. After first stage, the search algorithm can find $|t_{1}\rangle$ with high probability. Based on the result on the first stage, we can rescale the database. After the second stage, the algorithm can find $|t_{2}\rangle$ with high probability (if $|t_{1}\rangle$ is found in the first stage). The algorithm has the following steps:

1. Step 1:

Initialize the state to $|s_{n}\rangle$ defined in Eq. (1). 2. Step 2:

Perform the sequence

[TABLE]

on the initial state $|s_{n}\rangle$. The local diffusion operator $D_{m_{2}}$ (defined in $G_{m_{2}}$) is acting on $m_{2}$ qubits. 3. Step 3:

Measure the qubits (computational basis measurements) which do not have the local diffusion operator $D_{m_{2}}$ acting on them. Suppose that we get the classical results: $t^{\prime}_{1}\in\{0,1\}^{m_{1}}$. The probability that $t^{\prime}_{1}=t_{1}$ is denoted as $P^{(1)}_{n,m_{2}}(j_{1},j_{2},\ldots,j_{q})$. 4. Step 4:

Initialize the state to

[TABLE]

Here $|s_{m_{2}}\rangle$ is the rescaled initial state:

[TABLE] 5. Step 5:

Perform the sequence

[TABLE]

on the new initial state. We have $m^{\prime}<m_{2}$. The diffusion operator $D_{m_{2}}$ (defined in $G_{m_{2}}$) is acting on $|s_{m_{2}}\rangle$. And the diffusion operator $D_{m^{\prime}}$ is acting on the subspace of $|s_{m_{2}}\rangle$. 6. Step 6:

Measure the qubits (computational basis measurements) which have the initial state $|s_{m_{2}}\rangle$. Suppose that we get the classical results: $t^{\prime}_{2}\in\{0,1\}^{m_{2}}$. The probability that $t^{\prime}_{2}=t_{2}$ is denoted as $P^{(2)}_{m_{2},m^{\prime}}(j^{\prime}_{1},j^{\prime}_{2},\ldots,j^{\prime}_{q})$. 7. Step 7:

Verify the solution $|t^{\prime}\rangle=|t_{1}^{\prime}\rangle\otimes|t_{2}^{\prime}\rangle$ by classical oracle. If the solution is the target item, then stop; if not, back to step 1.

Steps 1-3 are the first stage: we find $t_{1}$ with high probability. Steps 4-6 are the second stage: we find the remaining bits of the target state. Step 7 is used to verify. Different sequences $S^{(1)}_{n,m_{2}}(j_{1},j_{2},\ldots,j_{q})$ and $S^{(2)}_{m_{2},m^{\prime}}(j^{\prime}_{1},j^{\prime}_{2},\ldots,j^{\prime}_{q})$ give different success probabilities $P^{(1)}_{n,m_{2}}(j_{1},j_{2},\ldots,j_{q})$ and $P^{(2)}_{m_{2},m^{\prime}}(j^{\prime}_{1},j^{\prime}_{2},\ldots,j^{\prime}_{q})$. We want to find the MED. The MED of the two-stages search algorithm is

[TABLE]

We optimize the total expected depth. We do not optimize the expected stage depth, because we cannot verify the partial bit by neither classical nor quantum oracle. Note that $m_{2}$ is the bit length of $t_{2}$. We can either fix $m_{2}$ or optimize different choices of $m_{2}$. In the definition of ${\rm d}_{2}(\alpha)$, we optimize the choices of $m_{2}$. The second-stage algorithm is a rescaled version of the full search algorithm. Such a two-stage quantum search algorithm (with depth optimization) can be easily generalized to the multi-stage quantum search algorithm.

As an example, let us consider the $n=4$ two-stage search algorithm. Grover’s algorithm (one-stage search algorithm) has the success probability

[TABLE]

In a two-stage search algorithm, we divide the target state into two parts: $|t\rangle=|t_{1}\rangle|t_{2}\rangle$. We choose the first-stage sequence as $S^{(1)}_{4,2}(1,1)=G_{4}G_{2}$. Then we measure the two qubits which do not have $D_{2}$ (defined in $G_{2}$) acting on them. The probability that the measurement results reveal $|t_{1}\rangle$ is

[TABLE]

Suppose that the measurement results are $|t^{\prime}_{1}\rangle$ after the first stage. Then we rescale the initial state as $|t^{\prime}_{1}\rangle\otimes|s_{2}\rangle$. We choose the second stage sequence as $S^{(2)}_{2}(1,0)=G_{2}$. Recall that the two-qubit Grover’s algorithm can find the target state with 100% probability with one Grover operator. Therefore, the second-stage success probability is

[TABLE]

Then the total success probability is

[TABLE]

The result is quite close to Grover’s algorithm with the same number of oracles, but the depth in each stage is less than in Grover’s algorithm.

Another interesting example (two-stage $n=4$ search algorithm) is that the sequence $S^{(1)}_{4,2}(1,2)$ gives probability $1$ for finding $t_{1}$. Combined with the second-stage sequence $S^{(2)}_{2}(1,0)$, we find a new approach for the $n=4$ exact search algorithm Diao (2010). We estimate $\text{d}_{2}(\alpha)$ with $\alpha=1$ for the $n=4,5\ldots,10$ search algorithms, see Fig. 2. The corresponding optimal sequences are listed in Appendix B. See Appendix A for more examples (with quantum circuit diagrams) on two-stage quantum search algorithms.

IV Critical Ratios

IV.1 The Critical Ratio for the One-stage Algorithm

Grover’s algorithm is optimal in the number of queries to the oracle Boyer et al. (1998); Zalka (1999). Grover’s algorithm is a one-stage search algorithm: no measurement occurs within the algorithm until the end. When $\alpha\rightarrow\infty$, we expect ${\rm d}_{1}(\alpha)=\text{d}_{\text{G}}(\alpha)$ (no local diffusion operators). Here ${\rm d}_{1}(\alpha)$ is defined in Eq. (17). And $\text{d}_{G}(\alpha)$ defined in Eq. (12) is the MED of Grover’s algorithm. We define the critical alpha $\alpha_{c,1}$ for the one-stage search algorithm:

[TABLE]

The subscript 1 in $\alpha_{c,1}$ denotes the one-stage search algorithm. Below $\alpha_{c,1}$, the depth of Grover’s algorithm is not optimal. Based on the depth optimization method proposed in Sec. III.2, we can give an estimation of $\alpha_{c,1}$:

Theorem 1**.**

$\alpha_{c,1}=\mathcal{O}(n^{-1}2^{n/2})$.

Proof.

The MED $\text{d}_{1}(\alpha)$ defined in Eq. (17) is a search algorithm with two different diffusion operators. One is the local diffusion operator $D_{m}$, see (7). The other is the global diffusion operator $D_{n}$, see (4). The local diffusion operator $D_{m}$ is only acting on the subspace of the database. We can follow a three-dimensional subspace: the target state $|t\rangle$ defined in Eq. (9a); the normalized sum of nontarget states in the target block $|ntt\rangle$ defined in Eq. (9b); the normalized sum of rest states in the database $|u\rangle$ defined in Eq. (9c). The notations are taken from the QPSA, see Sec. II.2 and Korepin (2005); Korepin and Grover (2006).

Operators $G_{n}$ and $G_{m}$ only change the relative amplitudes of states $|t\rangle$, $|ntt\rangle$, and $|u\rangle$. Therefore, operators $G_{n}$ and $G_{m}$ are elements of the $O(3)$ group Korepin and Vallilo (2006). It is interesting to see that operator $G_{m}$ can be viewed as a rescaled version of $G_{n}$. In the new basis $\{|t\rangle,|ntt\rangle,|u\rangle\}$, the sequence $S_{n,m}(j)=G^{j}_{m}$ (which only has local Grover operators $G_{m}$) has the representation

[TABLE]

For example, the matrix element $\sin(2j\theta_{2})$ is obtained from

[TABLE]

The angle is defined as

[TABLE]

We want to estimate the critical ratio $\alpha_{c,1}$. We consider the sequence:

[TABLE]

Here we choose $m=n-1$. It means that the database is divided into two blocks. At the basis $\{|t\rangle,|ntt\rangle,|u\rangle\}$ defined in Eqs. (9a)-(9c), the sequence $S_{n,n-1}(1,1,1)$ has the matrix representation

[TABLE]

with short notations $c=\cos\theta_{2}$ and $s=\sin\theta_{2}$. Note that $\sin\theta_{2}=\sqrt{2/N}$ since we choose $m=n-1$. The matrix $S_{n,n-1}(1,1,1)$ has the eigenvalues:

[TABLE]

with

[TABLE]

The corresponding normalized eigenvectors are denoted as $|v_{0}\rangle$ (with eigenvalue $\lambda_{0}$) and $|v_{\pm}\rangle$ (with eigenvalue $\lambda_{\pm}$). States $|v_{0}\rangle$ and $|v_{\pm}\rangle$ have the form:

[TABLE]

The notation $T$ means transpose. $\mathcal{N}_{0}$ and $\mathcal{N}_{\pm}$ are normalizations. Note that the eigenvector $|v_{0}\rangle$ (with eigenvalue $-1$) is orthogonal to the target state, i.e., $\langle t|v_{0}\rangle=0$. We can view the operator $S_{n,n-1}(1,1,1)$ as rotation combined with reflection. Rotation is around an axis perpendicular to $|t\rangle$. The rotation angle is $\gamma$. Reflection is around a plane perpendicular to $|t\rangle$. Iteration $S_{n,n-1}(1,1,1)$ on the initial state gives

[TABLE]

We have $\langle t|v_{\pm}\rangle=\mp i/\sqrt{2}$. Because $N=2^{n}$ is a large number, the angle $\theta_{2}$ is a small number. We can expand:

[TABLE]

We substitute the above relations into Eq. (40). After some algebra, we can get the success probability of finding the target state:

[TABLE]

Because the sandwich sequence $S_{n,n-1}(1,1,1)$ has three oracles, we set $\tilde{j}=3j$. Then the probability difference between $S^{\tilde{j}}_{n,n-1}(1,1,1)$ and Grover’s algorithm (with the same number of oracles) is

[TABLE]

Here $\delta$ is a small number:

[TABLE]

Grover’s algorithm (with $j$ Grover iterations) has success probability $P_{n}(j)$, see Eq. (6). Then the success probability for the $S^{\tilde{j}}_{n,n-1}(1,1,1)$ sequence (with $\tilde{j}=j/3$ iterations) is $P_{n}(j)-\delta$. If we want the new sequence $S^{\tilde{j}}_{n,n-1}(1,1,1)$ to have lower expected depth than Grover’s algorithm, we can set

[TABLE]

The left-hand side (times $j/3$) is the expected depth of Grover’s algorithm. The right-hand side (times $\tilde{j}=j/3$) is the expect depth of the $S^{\tilde{j}}_{n,n-1}(1,1,1)$ algorithm. The above inequality gives

[TABLE]

The diffusion operator $D_{n}$ has the depth $\text{d}(D_{n})=\mathcal{O}(n)$ or $\text{d}(D_{n})=\mathcal{O}(n^{2})$ Barenco et al. (1995). Then we have

[TABLE]

This is the end of the proof. ∎

As examples, we numerically estimate $\alpha_{c,1}$ defined in Eq. (31) for $n=4,5,\ldots,10$ based on the linear depth of $D_{n}$, see Appendix C and Table 4. Below the critical ratio $\alpha_{c,1}$, at least two-third of the global diffusion operators $D_{n}$ can be replaced by $D_{n-1}$ (to have lower expected depth). The saved depth scales as $\mathcal{O}(2^{n/2})$.

IV.2 The Critical Ratio for the Two-stage Algorithm

Similar to the one-stage search algorithm, we can define the critical ratio for the two-stage algorithm:

[TABLE]

Here $\text{d}_{2}(\alpha)$ is the MED of the two-stage search algorithm, defined in Eq. (26). The two-stage search algorithm has two measurements. After the first measurement, we reinitialize the state in the rescaled database. The amplified amplitude of the target state $|t\rangle$ is lost in the new initialization. One can argue that

[TABLE]

and it implies that $\alpha_{c,2}<\alpha_{c,1}$. Analytically, we can prove the following theorem.

Theorem 2**.**

$\lim_{N\rightarrow\infty}\alpha_{c,2}=1+\sqrt{3}\approx 2.732$.

Proof.

Similar to the proof of Theorem 1, we construct a special sequence. Then we compare the expected depth of such a sequence with the expected depth of Grover’s algorithm. Since we consider the two-stage search algorithm, we need two sequences for two stages. First, we assume that the target state $|t\rangle$ has two parts $|t\rangle=|t_{1}\rangle\otimes|t_{2}\rangle$, the same as in Eq. (22). And the bit length of $t_{2}$ is 2. For the first stage, we consider the sequence:

[TABLE]

In the first stage (by the sequence $S^{\tilde{j}}_{n,2}(1,1)$), we find $t_{1}$ with high probability. The probability is denoted as $P^{(1)}_{n,2}$. In the second stage, we have a rescaled two-qubit search algorithm. One Grover operator $G_{2}$ can find the target state with $100\%$ probability. Therefore, the second stage has the sequence:

[TABLE]

The probability of finding $t_{2}$ is $P^{(2)}_{2}=1$.

In the basis $\{|t\rangle,|ntt\rangle,|u\rangle\}$ defined in Eqs. (9a)-(9c), the sequence $S_{n,2}(1,1)$ has the matrix representation

[TABLE]

with $\sin\gamma=2/\sqrt{N}$. We can easily find eigenvalues and eigenvectors of $S_{n,2}(1,1)$. Then we can have a matrix expression for $S^{\tilde{j}}_{n,2}(1,1)$. Applying $S^{\tilde{j}}_{n,2}(1,1)$ on the initial state $|s_{n}\rangle$ (Eq. 10),

[TABLE]

Note that $|\langle u|S^{\tilde{j}}_{n,2}(1,1)|s_{n}\rangle|^{2}$ is the probability of finding the state in the nontarget block. In other words, we have

[TABLE]

The second stage has probability 1 (the two-qubit Grover’s algorithm with one Grover operator has probability 1). Then $P^{(1)}_{n,2}$ is also the probability of finding the target state.

The two stages designed above have a total of $2\tilde{j}+1$ queries to the oracle. In order to compare with Grover’s algorithm, we set $j=\sqrt{3}\tilde{j}$ (where $j$ is the number of queries to the oracle in Grover’s algorithm). Grover’s algorithm with $j$ iterations has a success probability $P_{n}(j)$ of finding the target state, see Eq. (6). Then the two-stage search algorithm (with sequences $S^{\tilde{j}}_{n,2}(1,1)$ and $S_{2}(1,0)$) can find the target state with probability $P_{n}(j)+\delta$. Here $\delta$ is a small number in order $\delta=\mathcal{O}(2^{-n/2})$. If we want the two-stage search algorithm to have lower expected depth than Grover’s algorithm, we need

[TABLE]

The left-hand side (times $j$) is the expected depth of Grover’s algorithm (with $j$ iterations). The right-hand side (times $j$) gives the expected depth of the designed two-stage search algorithm. Note that the second-stage circuit only contributes order $\mathcal{O}(2^{-n/2})$ to the critical value $\alpha_{c,2}$; therefore, we can neglect it here. Then we can solve the inequality

[TABLE]

For large $N$, we have the critical ratio

[TABLE]

This ends of the proof. ∎

Theorem 2 suggests that the two-stage search algorithm can have lower expected depth than Grover’s algorithm, only when the oracle can be realized as efficiently as the global diffusion operator. The real advantage of the two-stage algorithm is to mitigate the error accumulations for long circuits. For examples, see Fig. 2 and Appendixes A and B. We numerically estimate the value $\alpha_{c,2}$ ($n=4,5,\ldots,10$) based on a linear scale depth of $\text{d}(D_{n})$, see Appendix C and Table 4.

V Parallel Running of Quantum Search Algorithm

Now we discuss how to run the quantum search algorithm on several quantum computers in parallel. The simplest idea is running a low-success-probability search algorithm on different quantum computers. We verify the result by classical oracle and continue the algorithm until one of the quantum computers finds the target state Gingrich et al. (2000). First we can set a threshold success probability. Then we find the optimal sequence which gives the MED (the success probability is lower than the threshold success probability). We can run such a sequence on several quantum computers.

Another parallel running method is to combine the random guess with search algorithm, as mentioned in Ref. Korepin (2005) for the QPSA. For example, the target state is divided into two parts: $|t\rangle=|t_{1}\rangle\otimes|t_{2}\rangle$, the same as in Eq. (22). One can randomly guess the bits $t_{1}$. Then one performs the search algorithm on bits $t_{2}$. Each quantum computer can pick up one guess. However, if more than half of the bits are chosen randomly, the quadratic speedup is lost. Such a strategy is more efficient if some of the bits have higher probability (prior information about the target state).

If we want near-deterministic (the fail probability is $\mathcal{O}(2^{-n/2})$) parallel running of the search algorithm, then we can apply the multistage search algorithm on different quantum computers. Suppose the target state has length $n$. The target state is divided into $p$ parts, and each part has equal $n/p$ length. Then we can assign the search algorithm on $p$ quantum computers. Each quantum computer finds one part of the target state. Combining all the results from each quantum computers, we can piece together the whole solution $t$ at one time. The sequence running on each quantum computer can be found by maximizing the number of local Grover operators $G_{m}$ defined in Eq. (8), based on some threshold success probability ($\mathcal{O}(1-2^{-n/2})$). It requires at most $n$ quantum computers. Each quantum computer finds one bit of the target state. However, the most efficient way to find one bit of the target state is by running the random-guess one-bit search algorithm Korepin (2005).

VI Conclusion and Outlook

In this paper, we propose a new way to optimize the depth of quantum search algorithms. The quantum search algorithm can be realized by global and local diffusion operators. The ratio of the depth of the oracle and global diffusion operator is important. The ratio is denoted by $\alpha$, and defined in Eq. (11). The minimal practical value for $\alpha$ is 1 (in one target search algorithm). When $\alpha$ is below a threshold, we can design a new algorithm (new sequence) which has a lower expected depth than Grover’s algorithm. We gave examples for $\alpha=1$. In examples, our algorithm has around $20\%$ lower depth than Grover’s algorithm. We also study the depth optimization in the multi-stage quantum search algorithm. In each stage, the circuit has lower depth than in Grover’s algorithm. The multistage quantum search algorithm gives a natural way for parallel running of the quantum search algorithm.

Ideas in this work can be easily generalized to the multitarget solution search Boyer et al. (1998). However, the exact number of target states is required in order to find the optimal sequence. In this paper, we only consider two kinds of diffusion operators (at each stage). Further improvement is possible if more diffusion operators are working together. It will be interesting to optimize the depth of the amplitude amplification algorithm Grover (1998); Brassard et al. (2002). Grover’s algorithm is only optimal in the oracle measure. Our search algorithm has lower depth than Grover’s algorithm.

Acknowledgements.

The authors are grateful to Professor Jin Wang and Yulun Wang. V.K. is supported by SUNY Center for Quantum Information Science at Long Island Project No. CSP181035.

Appendix A Example for $n=6$ Search Algorithm with Depth Optimization

Different problems have different oracles. For demonstration, we can consider the simplest oracle. As mentioned in Ref. Figgatt et al. (2017), the oracle is single-qubit-gate equivalent to the $n$-qubit Toffoli gate $\Lambda_{n-1}(X)$. Suppose $|t\rangle=|000000\rangle$ ($n=6$). We can have the oracle:

[TABLE]

According to Ref. Barenco et al. (1995), the $\Lambda_{5}(X)$ gate can be realized by a depth of 61 circuit: $\text{d}(\Lambda_{5}(X))=61$ (if the quantum computer can perform any single-qubit gates and any two-qubit controlled gates). In real quantum computers, the depth $\text{d}(\Lambda_{5}(X))$ may be much larger since not all qubits are connected. Nevertheless, we can set

[TABLE]

The global diffusion operator ($n=6$) is also single-qubit-gate equivalent to the six-qubit Toffoli gate $\Lambda_{5}(X)$. We have

[TABLE]

Therefore, we can set

[TABLE]

Therefore, we have the ratio $\alpha=1$, see Eq. (11). The local diffusion operators are acting on the subspace of six qubits. For example, the $D_{4}$ diffusion operator has the quantum circuit diagram

[TABLE]

And the local diffusion operator $D_{2}$ is single-qubit-gate equivalent to the CNOT gate:

[TABLE]

Accordingly, we have

[TABLE]

Near-term quantum (or NISQ) computers are subjected to limited coherence time. We have to design a low depth algorithm, or divide a long circuit into shorter pieces. In the case of the $n=6$ search algorithm, Grover’s algorithm needs six iterations to give the maximal probability of finding the target state. In experiments, we do not need to run the quantum search algorithm until the maximal probability is reached. For low depth consideration, we give examples of search algorithms with one or two oracles. Even in such simple scenarios, we can do better by using local diffusion operators.

A.1 One-oracle Algorithm

• •

Grover’s algorithm. The one-iteration Grover’s algorithm gives

[TABLE]

Measurements at the end are computational basis measurements. The whole circuit has depth

[TABLE]

We can incorporate the initial Hadamard gates into $G_{6}$. The success probability of finding the target state is

[TABLE]

The result is better than that of the classical algorithm. The optimal classical search has a success probability of $3.15\%$: a single query followed by a random guess if the query fails ($1/64+1/63\approx 3.15\%$). To evaluate the efficiency, we can calculate the expected depth:

[TABLE]

• •

Our optimized algorithm. In order to lower the depth, we can apply, for example, one iteration of the local operator $G_{4}$. The one-iteration local Grover operator has the circuit

[TABLE]

Note that $S_{6,4}(1)=G_{4}$ is still a six-qubit gate, although $D_{4}$ is a four-qubit gate. For notation about $S_{6,4}(1)$, see Eq. (14). The whole circuit has depth

[TABLE]

The depth is lower compared with that of $G_{6}$. The success probability of finding the target state is

[TABLE]

The success probability decreases a little bit, but still outperforms the classical case. The expected depth is:

[TABLE]

The circuit is $\bm{38\%}$ shorter than one $\bm{G_{6}}$ iteration. The expected depth is $\bm{29\%}$ lower. The local diffusion operator may decrease the success probability, but it saves depth.

A.2 Two-oracle Algorithm

We can apply same strategy for the two-iteration search algorithm: design a circuit with local diffusion operators and find the optimal one with the least expected depth. We can also design a two-stage quantum search algorithm. And for each stage we use two oracles.

• •

Grover’s algorithm. The two-iteration Grover’s algorithm gives:

[TABLE]

The whole circuit has depth

[TABLE]

The success probability of finding the target state is

[TABLE]

and the expected depth is

[TABLE]

• •

Our two-stage search algorithm. We divide the target state into two parts: $|t_{1}\rangle$ and $|t_{2}\rangle$. Here $t_{1}$ is two bits long and $t_{2}$ is four bits long. Accordingly, we can design a search algorithm which has two stages: the first stage finds $|t_{1}\rangle$ and the second stage finds $|t_{2}\rangle$. In each stage, we only have two Grover operators (local or global Grover operators).

The first stage has the sequence $S^{(1)}_{6,4}(1,1,0)=G_{4}G_{6}$. We have the circuit diagram:

[TABLE]

We only measure the qubit which does not have $D_{4}$ (defined in $G_{4}$) performed. The probability of finding $|t_{1}\rangle$ is $P^{(1)}_{6,4}(1,1,0)$:

[TABLE]

The first-stage circuit has depth

[TABLE]

In the first stage, suppose that the two classical measurement bits are $b_{1}$ and $b_{2}$ ($b_{1},b_{2}\in\{0,1\}$). We cannot verify the partial bits $b_{1}$ and $b_{2}$. Since $P_{6,4}(1,1,0)>1/2$, the majority vote can be applied.

In the second stage, we choose the sequence

[TABLE]

And we have the circuit

[TABLE]

The initial state is the rescaled database. For example, in the first stage we find the $|01\rangle$ state; then we prepare the input $|01\rangle\otimes H^{\otimes 4}|0\rangle^{\otimes 4}$. The probability of finding $|t_{2}\rangle$ is $P^{(2)}_{4}(2,0)$:

[TABLE]

The second-stage circuit has depth

[TABLE]

We have the expected depth

[TABLE]

The expected depth is still $\bm{4.50\%}$ lower than that of the two-iteration Grover’s algorithm. And the first stage has $\bm{19.05\%}$ shorter depth and the second stage has $\bm{38.10\%}$ shorter depth. Besides, the two-stage strategy is subjected to half the errors from measurements.

Appendix B Optimal Sequences Based on $\alpha=1$

We present detailed numerical results plotted in Fig. 2. Suppose that we have quantum computers equipped with arbitrary single-qubit gates and arbitrary controlled two-qubit gates. It is well known that the $n$-qubit Toffoli gate $\Lambda_{n-1}(X)$ can be linearly decomposed into basic operators with one ancillary qubit Barenco et al. (1995). We set the depth of the $n$-qubit Toffoli gate as $\text{d}(\Lambda_{n-1}(X))=\{1,5,13,29,61,120,160,200,240\}$ with $n=2,3,\ldots,10$, see Ref. Barenco et al. (1995). Then the depth of the diffusion operator $D_{n}$ (4) is

[TABLE]

See Fig. 1. The depth of the oracle $U_{t}$ is characterized by the ratio $\alpha=\text{d}(U_{t})/\text{d}(D_{n})$. The ratio $\alpha$ is defined in Eq. (11). As an example, we set $\alpha=1$. The ratio $\alpha=1$ implies the simplest oracle construction, see Ref. Figgatt et al. (2017). We list the optimal strategy (with the MED) of Grover’s algorithm ($n=4,5,\ldots,10$) in Table 1. When $N=2^{n}$ is large, the optimized iteration number in Grover’s algorithm converges to $\lfloor 0.583\sqrt{N}\rfloor$, and the success probability converges to 0.844. The optimizations are independent of $\alpha$, see $\text{d}_{\text{G}}(\alpha)$ in Eq. (13).

We numerically find the optimal sequence (optimized by the local diffusion operator). Similarly, we set $\alpha=1$. The MED is given by $\text{d}_{1}(\alpha=1)$, see Eq. (17). The results are listed in Table 2. We also numerically find the optimal sequence for the two-stage search algorithm. The MED is given by $\text{d}_{2}(\alpha=1)$, see Eq. (26). The results are listed in Table 3. In general, different values of $\alpha$ will give different optimal sequences. It is clear that both the single-run depth (depth of the optimal sequence) and the expected depth in Table 2 and 3 are smaller than that for Grover’s algorithm (Table 1). In practice, once $\alpha$ is known, one can guess the optimal sequence based on results with small $n$. For example, when $n$ is large, the optimal sequence is closed to (assuming that $n$ is even)

[TABLE]

See Table 2. The repetition number of $G_{n}G^{2}_{n/2}$ can be found either by numerical or analytical methods.

Appendix C Examples for Critical Ratios

The ratio $\alpha$ defined in Eq. (11) is an important parameter. If $\alpha\rightarrow\infty$, Grover’s algorithm is optimal in depth. The critical ratios $\alpha_{c,1}$ in Eq. (31) and $\alpha_{c,2}$ in Eq. (48) are threshold values. Below $\alpha_{c,1}$ (or $\alpha_{c,2}$), we can find a lower expected depth algorithm than Grover’s algorithm. The diffusion operator $\text{d}(D_{n})$ is single-qubit-gate equivalent to the $n$-qubit Toffoli gate $\Lambda_{n-1}(X)$. We can set $\text{d}(\Lambda_{n-1}(X))=\{1,5,13,29,61,120,160,200,240\}$ with $n=2,3,\ldots,10$, see Ref. Barenco et al. (1995). Based on the depth optimization method defined in Secs. III.2 and III.3, we numerically find the critical ratios $\alpha_{c,1}$ and $\alpha_{c,2}$ in Table 4.