Exponentially fast quantum search algorithm

Exponentially fast quantum search algorithm Goong Chen

∗

and Zijian Diao

Department of Mathematics, Texas A&M University, College Station, TX 77843-3368, U.S.A (December 5, 2000) The existing quantum search algorithm, due to L.K. Grover, finds a single search target in a large database with N items in O(N 1/2 ) steps. The speedup is quadratic. In this paper, we show a new search algorithm whose speedup is exponential. The iterations are carried out dynamically utilizing varying auxiliary functions. For a data space with N items, our quantum algorithm homes in on the single search target in no more than 2dlog4 N e iterations. 03.67 Lx

∗

Corresponding author, E-mail: [email protected]

1

I. INTRODUCTION

As of now, the following two algorithms are most prominent in quantum computation: (i) P. Shor’s 1994 discovery [9] of a quantum algorithm for factorization substantially faster than any known classical algorithms of subexponential complexity, which is suitable for decipherment in cryptography; (ii) L.K. Grover’s work [7] in 1996 of a quantum search algorithm that gives a favorable quadratic speedup in the search of a single object in a large unsorted database, which is suitable for “data mining”. These two results contain stunning improvements in algorithmic complexity and have provided a tremendous impetus toward the development of the future quantum computer. Let us particularly address Grover’s algorithm in (ii) above. It is an elegant algorithm with rich geometrical and analytical features which has attracted the attention and interest of many computer scientists, mathematicians, physicists, and chemists [1, 2, 5, 6]. Application of Grover’s algorithm to other problems such as global minimization, element distinctness problem and sorting can be found in [4]. The quadratic speedup in Grover’s algorithm (from O(N ) to O(N 1/2 )) is significant. Several researchers [2, 10] have shown that in the setting(s) that Grover’s algorithm is formulated, it is actually “optimal”. A Holy Grail in computing complexity and algorithm design is to achieve exponential speedup. In this paper, we show that by using a dynamic iterative algorithm with auxiliary oracle functions, an exponential speedup for a single item data search can indeed be achieved. If the unsorted overall database has 22n items, then it takes at most 2n iterations to home in on the desired search target. This exponential speedup does not contradict the so-called “optimality” results in [2, 10] because our queries are done by the varying oracle functions (and thus the dynamic nature of the algorithm) rather than the oracle Boolean function itself in [2, 10]. Our algorithm is actually quite akin to the classical quart-section method. II. PROOF OF THE LOGARITHMIC COMPLEXITY OF THE NEW QUANTUM SEARCH ALGORITHM

Let D = {wi i = 0, 1, 2, . . . , N − 1} be a large database with N items. Without loss of generality, we assume that N = 22n for some positive integer n. We also assume that w0 is the item in D which we are searching for. an eigenstate |wi i, for Let D be encoded into the quantum computer (QC) such that each dataset wi becomes ˆ ≡ {|wi i i = 0, 1, . . . , N − 1} and the i = 0, 1, . . . , N − 1. Thus there exists a 1 − 1 correspondence between the set D set of all 2n-qubit quantum states: |wi i ←→ |a1 a2 a3 . . . a2n i, aj = 0 or 1, for j = 1, 2, . . . , 2n. We call a1 a2 a3 . . . a2n the symbol or qubit word of wi ; in notation, a1 a2 a3 . . . a2n = S(wi ). The first j qubits of S(wi ) is denoted as Sj (wi ): Sj (wi ) = a1 a2 a3 . . . aj . Corresponding to the search target w0 , there exists an oracle (Boolean) function f on D such that f (wi ) = 0 if i 6= 0; f (w0 ) = 1. This oracle function is in a black box and thus not explicitly given. Nevertheless, one can know the values of f (wi ) through making queries to the QC. ˆ be specified by ˆ H = span D. ˆ Let |wG i ∈ D Let H be the underlying Hilbert space spanned by the set D: S(wG ) = 000 . . . 0. Define, for j = 1, 2, . . . , n − 1, fj : D → {0, 1} by  1 if S2j (wi ) = S2j (wG ) = 0 . . . 0 (a string of 2j 00 s), but S(wi ) 6= S(wG ), (1) fj (wi ) = 0 otherwise , from which further define Fj = f ∨ fj , where “∨” is the “OR” logic operation, and Fn = f . We call Fj the auxiliary oracle functions, whose definitions require no more than the knowledge of f . Tentatively, assume that S1 (w0 ) = 1. Then we see that Fj−1 ({1}) has cardinality 22(n−j) . These functions Fj induce a nested sequence of linear subspaces Lj , j = 1, 2, . . . , n, where Lj = span{|wi i Fj (wi ) = 1}, which satisfies H ) L1 ) L2 ) . . . ) Ln ; Ln = span{|w0 i}. Note that dim Lk = 22(n−k) , where dim Lk stands for the dimension of Lk . We now proceed to define a dynamic iteration process inductively as follows. Step 1. Initialization: (a) Define the uniform superposition state N −1 1 X |wi i, |s0 i = √ N i=0

2

(N = 22n );

(2)

(This state is obtained through the application of the Walsh-Hadamard transformation on the ground state in O(ln N ) operations.) (b) Define the “sign -flipping operator” on L1 : I0 |wi i = (−1)F1 (wi ) |wi i, i = 1, 2, . . . , N ; X |wi ihwi |, where I is the identity operator; i.e., I0 = I − 2

(3) (4)

F1 (wi )=1

(c) Define the “inversion about the average” operator Is0 = I − 2|s0 ihs0 |.

(5)

Step 2. Induction: (a) Let |sj i, Ij and Isj be defined for j = 0, 1, 2, . . . , k, where k ≤ n − 1. (b) Define |sk+1 i = −Isk Ik |sk i,

(6)

If k = n − 1, stop and make a measurement on |sn i. Exit. Otherwise, define X |wi ihwi |, Isk+1 = I − 2|sk+1 ihsk+1 |. Ik+1 = I − 2 Fk+2 (wi )=1

Go to Step 2. We now claim that the above process will yield the search target |w0 i. Lemma 1. Assume S1 (w0 ) = 1. Let N = 22n . For j = 1, 2, . . . , n − 1, X

N −1 X

(−1)Fj+1 (wi )+1 = −22(n−j)−1 and

(−1)F1 (wi )+1 = −22n−1 = −N/2.

i=0

Fj (wi )=1

Proof: Just note that the cardinality of Fj−1 ({1}) is 22(n−j) ; 3/4 of the elements in {(−1)Fj+1 (wi )+1 wi ∈ Fj−1 ({1})} are equal to −1, and the remaining 1/4 of the elements are equal to 1.  Lemma 2 (Key Lemma). Assume S1 (w0 ) = 1. For j = 1, 2, . . . , n, |sj i =

1 2n−j

X

|wi i ∈ Lj ,

(7)

Fj (wi )=1

with hsj |sj i = 1; Ij and Isj are unitary operators. Proof: We use mathematical induction. First, we want to verify that |s1 i ∈ L1 : # " N −1 1 X F1 (wi ) (−1) |wi i |s1 i = −Is0 I0 |s0 i = −Is0 √ N i=0   N −1 2 1 X F1 (wi )+1 (−1) |wi i − √ |s0 i = √ N i=0 N N −1 i 2 1 Xh (−1)F1 (wi )+1 + 1 |wi i = √ = √ N i=0 N

Note that in (8), we have used Lemma 1. 3

X F1 (wi )=1

|wi i =

1 2n−1

(8) X

F1 (wi )=1

|wi i ∈ L1 .

It is trivial to see that hs1 |s1 i = 1 because hs0 |s0 i = 1 and I0 and Is0 are both unitary. Now, assume that the claims are valid for j = 1, 2, . . . , k, k < n. We want to derive |sk+1 i:   X 1 (−1)Fk+1 (wi ) |wi i |sk+1 i = −Isk Ik |sk i = −Isk  n−k 2 Fk (wi )=1   X 2 1 (−1)Fk+1 (wi )+1 |wi i − n−k |sk i = n−k 2 2 Fk (wi )=1 i X h 1 (by Lemma 1) (−1)Fk+1 (wi )+1 + 1 |wi i = n−k 2 Fk (wi )=1

=

X

1 2n−(k+1)

|wi i.

Fk+1 (wi )=1



Therefore (7) is verified. The rest is obvious. Main Theorem 1. Assume S1 (w0 ) = 1. We have |sn i = (−Isn−1 In−1 )(−Isn−2 In−2 ) . . . (−Is1 I1 )(−Is0 I0 )|s0 i = |w0 i.

(9)

Consequently, it takes exactly n iterations to reach the search target |w0 i. Proof: Just apply Lemma 2.  The above theorem is premised on S1 (w0 ) = 1. If S1 (w0 ) = 0, then the algorithm (2)-(6) yields some final state |sn i after n iterations. After a measurement of |sn i, we obtain some eigenstate |wF i. If f (wF ) = 1 is true, then we are done. If not, we conclude S1 (w0 ) = 0 and then repeat (2)-(6); but with fj in (1) replaced by  1 if S2j (wi ) = S2j (wH ) = 1 . . . 1 (a string of 2j 1’s), but S(wi ) 6= S(wH ), fj (wi ) = 0 otherwise , ˆ specified by S(wH ) = 11 . . . 1. The proofs given above again go for j = 1, 2, . . . , n − 1, where |wH i is the state in D through, and we will hit the target |w0 i in n iterations. Therefore it takes at most 2n iterations. Now, for a general positive integer N , let n ˜ be a positive integer such that ˜. n ˜ − 1 < log4 N ≤ n n qubits. Then 22(˜n−1) < N ≤ 22˜n . The data space with N objects can be embedded and encoded into a QC with 2˜ It takes at most 2˜ n iterations to reach the search target. Therefore, it takes at most 2dlog4 N e iterations to finish the search task, where for any real number r, dre denotes the smallest integer larger than or equal to r. III. DISCUSSIONS

Remark III.1. The so-called “optimality” results of the efficiency of Grover’s quantum search algorithm is based on the assumption that the overall unitary transformation for search with T (a positive integer) queries be of the form U (w0 , T ) = (Uw0 UT )(Uw0 UT −1 ) . . . (Uw0 U1 ),

(10)

where w0 is the search target and Uw0 = I − 2|w0 ihw0 | is the query for w0 . Our overall search operator does not belong to the class of operators in the form (10) and, thus, does not cause any contradiction. Our iterations are dynamic in nature in the sense that Isj and Ij in (9) changes at each iteration  from j = 0 to n − 1 ( whereas in contrast Uw0 in (10) remains static throughout). Remark III.2. Our success can be largely attributed to the “magic number 4”. We can intuitively explain our ideas as follows. Consider N = 4 with database D = {w0 , w1 , w2 , w3 }. Then 3

|s0 i =

1X 1 π |wi i, hs0 |w0 i = = sin θ0 , θ0 = . 2 i=0 2 6 4

where θ0 is the angle formed between |s0 i and |w0 i⊥ . The operator Is0 is the “inversion about the average” or, equivalently, reflection about the axis |s0 i. The operation −Is0 Iw0 causes a combined rotation of |s0 i by 2θ0 = 2(π/6) = π/3. Therefore, the total angle between −Is0 Iw0 |s0 i and |w0 i⊥ is θ0 + 2θ0 = π/2, i.e., one Grover iteration leads |s0 i to be in line with |w0 i, reaching the search target. For N = 22n = 4n , we can observe from the proof of Key Lemma 2 that the idea is to divide the overall Hilbert space H into four quarter subspaces. Then the first iteration of our algorithm will enable us to move into the “correct quarter subspace”, i.e., the quarter subspace containing the search target. Continuing this dividing quarterly and quarterly, we then conquer.  Remark III.3. The “price to pay” in order to achieve the exponential speedup is higher energy expenditure, in comparison with Grover’s original search algorithm. This may be argued as follows. In Grover’s, the iterations are carried out by (−Is0 Iw0 )

n0

|s0 i, n0 = O(N 1/2 ).

(11)

The energy expended and the quantum gates concatenations for (using) the operator Is0 in (11) are comparable to those for each of Isj , j = 0, 1, . . . , n − 1 in (9). However, our operators Ij , j = 1, 2, . . . , n − 1 in (9) expends more energy than Iw0 in (11). For example, using laser techniques such as an implementation scheme suggested in [8], in order to have I1 , all the eigenstates |wj i in the quarter subspace L1 need to be excited from the ground state to an energy level E for a bi-level quantum system. This would require N4 E units of energy, in comparison with energy expenditure only E for Iw0 in (11), because only |w0 i is excited. Thus, the utilization of I1 , I2 , . . . , In−1 in (9) −n N would require at least a total of N4 E(1 + 4−1 + . . . + 4−(n−1) ) = N4 E 1−4 1−4−1 ≈ 3 E units of energy, in contrast with just ≈ n0 E = O(N 1/2 E) of units of energy with Grover’s original algorithm. Thus, our success lies in trading off energy expenditure for time, while Grover’s algorithm still maintains the advantage of being “lower-cost”.  Remark III.4. Does our algorithm contain “hidden polynomial time”? We conjecture no because the quantum gates required for the operators Ij and Isj in (9) should grow at most polynomially in 2n, where N = 22n . Thus, our total  algorithmic complexity is predicted to be at most O((ln N )k ). A rigorous proof will appear later. IV. ACKNOWLEDGMENTS

We wish to thank Victor Palmer for an elegant version of presentation given in eq. (1), particularly the definitions of fj and Fj . We also thank Andreas Klappenecker, Sam Lomonaco, David Meyer, Mike Stay, and Christof Zalka for discussions.

[1] D. Biron, O. Biham, E. Biham, M. Grassl, and D.A. Lidar, in Quantum Computing and Quantum Communications, Lecture Notes Comp. Sci. 1509 (Springer, New York, 1998), p. 140; E. Biham,O. Biham, D. Biron, M. Grassl, and D.A. Lidar, Phys. Rev. A 60, 2742 (1999). [2] M. Boyer, G. Brassard, P. Høyer, and A. Tapp, Fortsch. Phys. 46, 493 (1998). [3] G. Brassard, P. Høyer, and A. Tapp, quant-ph/9805082, May 1998; in Proceeding of 25th Int. Colloquium on Automata, Languages and Programming (ICALP’98), Lecture Notes in Comp. Sci. 1443 (Springer, New York, 1998), p. 820. [4] H. Buhrman, et al., quant-ph/0007016, July 2000; C. Durr and P. Høyer, quant-ph/9607014, July 1996; Y. Shi, quantph/0009091, September 2000. [5] G. Chen, S.A. Fulling, and M.O. Scully, Directions in Quantum Optics, edited by H.J. Carmichael, R.J. Glauber, and M.O. Scully (Springer, Berlin, in press); quant-ph/9909040; G. Chen, S.A. Fulling, and J. Chen, preprint, quantph/0007123, July 2000; G. Chen and S. Sun, preprint, quant-ph/0007124, July 2000; G. Chen and Z. Diao, quantph/0011019, November 2000. [6] E. Farhi and S. Gutmann, Phys. Rev. A 57, 2403 (1998). [7] L.K. Grover, in Proc. 28th Annual Symposium on the Theory of Computing (ACM Press, New York, 1996), p. 212; Phys. Rev. Lett. 78, 325 (1997); Phys. Rev. Lett. 80, 4329 (1998). [8] M.O. Scully, preprint. [9] P. Shor, Proc. 35th IEEE Symposium on the Foundations of Computer Sci., 1994, p. 124; P. Shor, SIAM J. Comp. 26, 1484 (1997). [10] C. Zalka, quant-ph/9711070, November 1997.

5