A better lower bound for quantum algorithms searching an ordered list

Transcription

1 A better lower bound for quantum algorithms searching an ordered list Andris Ambainis Computer Science Division University of California Berkeley, CA 94720, Abstract We show that any quantum algorithm searching an ordered list of n elements needs to examine at least log 2 n 2 O() of them. Classically, log 2 n queries are both necessary and sufficient. This shows that quantum algorithms can achieve only a constant speedup for this problem. Our result improves lower bounds of Buhrman and de Wolf(quant-ph/98046) and Farhi, Goldstone, Gutmann and Sipser (quantph/982057). Introduction One of main results in quantum computation is Grover s algorithm[0]. This quantum algorithm allows to search an unordered list of n elements by examining just O( n) of them. Any classical algorithm needs to examine all n elements. Grover s algorithm is very important because it can be applied to any search problem (not just searching a list). For example, it can be used to find a Hamilton cycle in an n-vertex graph by checking only n! out of n! possible Hamilton cycles. After Grover s paper appeared, unordered search and related problems received a lot of attention in quantum computation community. It was shown that O( n) is optimal[2]. Then, Grover s algorithm has been used as subroutine in other quantum algorithms[5, 4]. Optimality proof of [2] has been generalized as well[, 6]. Grover s algorithm works well for unordered lists but cannot be used for searching ordered lists. An ordered list of n elements can be searched by examining just log 2 n elements Supported by Berkeley Fellowship for Graduate Studies.

2 classically and there is no evident way of speeding it up by methods similar to Grover s algorithm. Searching ordered lists by a quantum algorithm was first considered by Buhrman and de Wolf[6] who proved a log n/ log log n lower bound for quantum case. This lower bound was improved to log n/2 log log n by Farhi, Goldstone, Gutmann and Sipser[7]. The log n/2 log log n bound was independently discovered (but not published) by the author of this paper in June 998. We improve the lower bound to log n O(), showing that only a constant speedup 2 is possible for the ordered search. The best quantum algorithm for ordered search uses 0.53 log n queries[8]. Thus, a constant speedup is possible. The proof of our lower bound combines the method of [2] (adapted to ordered case by [7]) with a new idea inspired by weighted majority algorithms in the learning theory[9, ]. 2 Preliminaries 2. Quantum binary search In the binary search problem, we are given x IR,..., x n IR, y IR such that x x 2... x n and have to find the smallest i such that y x i. Normally, x,..., x n are accessed by queries. The input to the query is i, the answer is x i. This is a classical problem in computer science and it is well known that log 2 n queries are both necessary and sufficient to solve it classically. In this paper, we consider how many queries one needs in the quantum world. We will prove a log n O() lower bound. For our proof, it is enough to consider the case when 2 x {0, },..., x n {0, } and y =. Then the problem becomes following. 0- valued binary search. Given x {0, },..., x n {0, } such that x x 2... x n, find the smallest i such that x i =. Similarly to classical world, we consider algorithms that access the input by queries. A quantum algorithm A can be represented as a sequence of unitary transformations U 0 O U O... U T O U T on a state space with finitely many basis states. U j s are arbitrary unitary transformations that do not depend on x,..., x N and O s are queries to the input. We use O k to denote the query transformation corresponding to the input x =... = x k = 0, x k+ =... = x n =. To define O k, we represent the basis states as i, b, z where i consists of log n bits, b is one bit and z consists of all other qubits. Then, O k maps i, b, z to i, b x i, z. (I.e., the first log n qubits are interpreted as an index i for an input bit x i and this input bit is XORed on the next qubit.) A different quantum algorithm with c log n queries for c < was claimed in [2]. However, a bug was discovered in the proof of [2] and it is not clear whether the proof can be fixed. 2

3 Running a quantum algorithm A on an input x =... = x k = 0, x k+ =... = x n = means applying the transformation U T O k U T... U O k U 0 to the initial state 0 and measuring the first log n bits of the final state. The algorithm computes the binary search function if, for any input x =... = x k = 0, x k+ =... = x n =, this process gives k with probability at least 3/ Technical lemmas In this section, we state several results that we will use. The first result is the well-known formula for the sum of decreasing geometric progression. If q >, then i=0 q = i, q q = () i q The second result is a lemma from [3]. It relates the l 2 -distance between two superpositions and the variational distance between probability distributions that we obtain by observing two superpositions. The variational distance between two probability distributions p(x) and p (x) is just the sum x p(x) p (x). Lemma 3 [3] Let ψ and φ be superpositions such that ψ φ ɛ. Then the total variational distance resulting from measurements of φ and ψ is at most 4ɛ. In our case, ψ and φ are final superpositions of a quantum algorithm A on two different inputs x =... = x j = 0, x j+ =... = x n = and x =... = x k = 0, x k+ =... = x n =. For the first input, j is the correct answer and the measurement must return j with probability at least 3. The probability that the measurement gives k can be at most 4 3 =. For the second input, the probability of j can be at most and the probability of k must be at least 3. This means that the variational distance must be at least 2( 3 ) = By Lemma, this is only possible if ψ φ. We have shown 4 Lemma 2 If ψ and φ are final superpositions of a quantum binary search algorithm, then ψ φ 4. 3 Result 3. log n/2 log log n lower bound We start with a sketch of log n/2 log log n lower bound discovered independently by the author of this paper and Farhi, Gutmann, Goldstone and Sipser[7]. After that, we describe how to modify this argument to obtain an Ω(log n) lower bound. 2 One can replace 3/4 by any other constant in (0, ) and our proof would still give a 2 log n O() lower bound, with a slightly different constant in the O() term. 3 Ronald de Wolf has shown that 4ɛ can be improved to 2ɛ in this lemma. This can be used to improve O() constant in our 2 log n O() lower bound. 3

4 Assume we are given a quantum algorithm A for binary search that uses less than log n/2 log log n queries. We construct an input on which A works incorrectly. In the first stage, we partition [, n] into log 2 n intervals of length n/ log 2 n each. We simulate A up to the first query. There is an interval [(l ) n/ log 2 n +, l n/ log 2 n] that is queried with probability that less than or equal to / log 2 n. We answer the first query of A with x i = 0 for i l n/ log 2 n and x i = for i > l n/ log 2 n. Then, we split the interval [(l ) n/ log 2 n +, l n/ log 2 n] into log 2 n parts of size n/ log 4 n, find the one queried with the smallest probability, answer the second query by x i = 0 for i up to this interval and x i = for greater i and so on. We repeat the splitting until the interval is smaller than log 2 n. This means doing log n/ log(log 2 n) = log n/2 log log n splittings. Let [(l )m +, lm] be the final interval. Consider two inputs x =... = x lm = 0, x lm =... = x n = and x =... = x lm = 0, x lm+ =... = x n =. The only value where these two inputs differ is x lm and, by our construction, it is queried with a probability at most / log 2 n in each of log n/2 log log n steps. By a hybrid argument similar to [2], this implies that the final superpositions of the quantum algorithm A on these two inputs are within distance O(/ log log n). Hence, the results of measuring final superpositions on two inputs will be close as well (cf. Lemma ). 3.2 log n/2 lower bound To obtain an Ω(log n) lower bound, we must split the interval into a constant number of pieces at every step (rather than log 2 n pieces). However, if we split the interval into a constant number of pieces, we can only guarantee that the new interval has the probability of being queried smaller than some constant (not smaller than / log 2 n). Then, it may happen that x lm gets queried with a constant probability in each of c log n queries, giving the total probability much higher than. In this case, the quantum algorithm A can easily distinguish two inputs that differ only in x lm. To avoid this, we do the splitting in a different way. Instead of considering just the probabilities of an interval being queried in the last step, we consider the probabilities of it being queried in the previous steps as well and try to decrease them all. This is done by using a weighted sum of these probabilities. The precise argument follows. Theorem Let q IR, q >, t IN, u IN and be such that q(q ) u <. Then, at least binary search on n elements. q = t + 2 q log n O() queries are necessary for the quantum u log t Proof: Assume we are given a quantum algorithm A doing binary search on x,..., x n with less than log n c queries where the constant c will be specified later. We construct two u log t inputs that A cannot distinguish. 4

5 First, we describe an auxiliary procedure subdivide. This procedure takes an interval [(l )m +, lm] and returns a subinterval [(l )m +, l m ]. subdivide(m, l, s):. Let m = m/t. Split [(l )m +, lm] into t subintervals: [(l )m +, (l )m + m ], [(l )m + m +, (l )m + 2m ],..., [(l )m + (t )m +, (l )m + tm ]. 2. Simulate the first s query steps (and unitary transformations between these steps) of A on the input x =... = x lm = 0, x lm+ =... = x n =. Let φ i = U i O lm U i 2... U O lm U 0 ( 0 ) be the superposition before the i th query step, ψ i be its part corresponding to querying x k for k [(l )m +, lm] and ψ i,r be the part of ψ i corresponding to querying x k for k [(l )m + (r )m +, (l )m + rm ]. 3. For every r {,..., t}, compute the sum S r = ψ s,r + q ψ (s ),r + q 2 ψ (s 2),r q s ψ,r. 4. Take the r minimizing S r and set l = (l )k + r. Then, [(l )m +, l m ] is equal to [(l )m + (r )m +, (l )m + rm ]. Next, we analyze this procedure. Let S = ψ s + q ψ s + q 2 ψ s q s ψ,j. Let φ i and ψ i be the counterparts for φ i and ψ i, given the input x =... = x l m = 0, x l m + =... = x n =. We define S = ψ s + q ψ s + q 2 ψ s Lemma 3 S q S. Proof: We bound the difference between superpositions ψ i (used to define S ) and ψ i,r (used to define S r ). To do that, we first bound the difference between φ i and φ i. Claim φ i φ i 2( ψ ψ i ). 5

6 Proof: By induction. If i =, then φ i = φ i. Next, we assume that φ i φ i 2( ψ ψ i 2 ). φ i is the result of applying U i O lm to φ i and φ i is the result of applying U i O l m to φ i. U i is just a unitary transformation and it does not change distances. Hence, we have φ i φ i = U io lm ( φ i ) U i O l m ( φ i ) = O lm( φ i ) O l m ( φ i ) O lm ( φ i ) O l m ( φ i ) + O l m ( φ i ) O l m ( φ i ). The second part is just φ i φ i and it is at most 2( ψ ψ i 2 ) by inductive assumption. To bound the first part, let ϕ i = φ i ψ i. Then, ϕ i is the part of superposition φ i corresponding to querying k / [(l )m +, lm]. O lm and O l m are the same for such k. Therefore, O lm( ϕ i ) = O l m ( ϕ i ) and O lm ( φ i ) O l m ( φ i ) = O lm ( ψ i ) O l m ( ψ i ) O lm ( ψ i ) + O l m ( ψ i ) = 2 ψ i. Consider the subspace of the Hilbert space consisting of states that correspond to querying k [(l )m, l m ]. ψ i,r and ψ i are projections of φ i and φ i to this subspace. Hence, ψ i,r ψ i is the projection of φ i φ i. For any vector, the norm of its projection is at most the norm of the vector itself. Therefore, we have Claim 2 This means ψ i,r ψ i 2( ψ ψ i ). S = q s i ψ i q s i ( ψ i,r + 2( ψ ψ i )) = q s i ψ i,r + 2 (q s i i ψ j ). (2) j= The first term is just S r. Next, we bound the second term. (q s i i ψ j ) = ( ψ j q s i ) < ( ψ j q s i ) = j= j= i=j+ j= i=j+ ( ψ j q s j j= q ) = ψ i j qs j j= q = S. (3) q Putting (2), (3) together, we get S S r + 2 q S. Next, we bound S r. 6

7 Claim 3 S r t S. (4) Proof: We have ψ i = ψ i, ψ i,t. This implies By a Cauchy-Schwartz inequality Therefore, ψ i 2 = ψ i, ψ i,t 2. ψ i, ψ i,t 2 ( ψ i, ψ i,t ) 2. t ψ i ψ i, ψ i,t t. S is just a weighted sum of ψ i and S,..., S t are weighted sums of ψ i,,..., ψ i,t, respectively. Hence, S S +...+S t t and S S t ts. By definition of r, S r is the smallest of S,..., S t. This implies (4). Claim 3 gives S S r + 2 q S ( + 2 t q )S = q S. This completes the proof of Lemma 3. Next, we use the subdivide procedure to construct two inputs that are not distinguished by A. This is done as follows. Let v be (log( ( 0 q(q ) u )( ))/ log q q.. Let m = n, l =, s =. 2. While m t v, repeat: 2.. u times do subdivide(m, l, s) and set l = l, m = m s = s v u times do subdivide(m, l, s) and set l = l, m = m. At the beginning, m = n. Each execution of step 2 decreases m by a factor of t u and step 2 is repeated while m t v. Hence, it gets repeated at least log(n/t v ) log(t u ) = log n v log t u log t = log n u log t v u = log n u log t O() times. The final interval [(l )m+, lm] has a small probability of being queried and, therefore it is impossible to distinguish x =... = x k = 0, x k+ =... x n = for different k [(l )m +, lm] one from another. To prove this, we first show the following invariant: 7

8 Lemma 4. At the beginning of step 2.., S is at most q(q ) u. 2. At the end of step 2.., S is at most (q ) u q(q ) u. Proof: By induction. When we first start step 2.., s =, S = ψ and <. q(q ) u For the inductive case, if we have S at the beginning of step, each subdivide decreases it q times and S (q ) u q(q ) u q(q ) u at the end of the step. Also, if S = q s i ψ i at the end of one step, then, in the next step, S will be s+ q s+ i ψ i = ψ s+ + q q s i (q ) u ψ i + q q(q ) = u q(q ). u This completes the proof of the lemma. By the same argument, S at the end of step 3. The definition of v implies S (q ) v q(q ) u 0 ( q(q ) u )( q ) q(q ) u = 0 ( q ). Together with S = s q s i ψ i q s i ψ i, this implies ψ i q. (5) 0qs i Now, we use a hybrid argument similar to [2, 7]. Consider A working on the input x =... = x lm = 0, x lm+ =... = x n = and on the input x =... = x lm = 0, x lm =... = x n =. The final superpositions on these two inputs are ϕ = U T O lm U T... U 0 ( 0 ), ϕ = U T O lm U T... U 0 ( 0 ). We are going to show that ϕ and ϕ are close. superpositions (also called hybrids) To show this, we introduce intermediate Then, ϕ = ϕ s, ϕ = ϕ 0. ϕ i = U T O lm U T... U i+ O lm U i O lm U i... U 0 ( 0 ). Claim 4 ϕ i ϕ i q. (6) 5qs i 8

9 Proof: The only different transformation is the i th query which is O lm for ϕ i and O lm for ϕ i. Before this transformation, the state is φ i = U i O lm U i 2... U 0 ( 0 ) The part of this superposition corresponding to querying [(l )m +, lm] is ψ i. This is the only part of φ i on which O lm and O lm are different. Therefore, O lm ( φ i ) O lm ( φ i ) = O lm ( ψ i ) O lm ( ψ i ) 2 ψ i 5 q q s i. The next transformations (U T O lm U T... U i ) are the same again. This implies (6). By triangle inequality (and formulas (6) and ()), s q ϕ 0 ϕ s ϕ i ϕ i i=0 5q i = q 5 s i=0 q q i 5 q = 5. However, ϕ 0 is the final superposition for the input x =... = x lm = 0, x lm =... = x n =, ϕ s is the final superposition for the input x =... = x lm = 0, x lm+ =... = x n = and, by Lemma 2, the distance between them must be at least /4. This shows that there is no quantum algorithm A that solves the binary search problem with at most log n v queries. u log t u By optimizing the parameters in theorem, we get Corollary At least log n O() queries are necessary for quantum binary search on n 2 elements. Proof: Substitute q = 8.3, t = 8, u = 4 into Theorem. 4 Conclusion We have shown that any quantum algorithm needs at least log 2 n/2 queries to do binary search. This shows that at most a constant speedup is possible for this problem in the query model (compared to the best classical algorithm). Similarly to other lower bounds on quantum algorithms, this result should not be considered as pessimistic. First, the classical binary search is very sequential algorithm and, therefore, it is not so surprising that it is impossible to speed it up by using quantum algorithms. Second, the classical binary search is already fast enough for most (if not all) practical purposes. We hope that our lower bound technique will be useful for proving other lower bounds on quantum algorithms. One of main open problems in this area is the collision problem[4] for which there is no quantum lower bounds at all. Acknowledgments. I thank Ashwin Nayak for suggesting this problem and Ronald de Wolf for useful comments. 9

10 References [] R. Beals, H. Buhrman, R. Cleve, M. Mosca, R. de Wolf. Quantum lower bounds by polynomials. Proceedings of FOCS 98. Also quant-ph/ [2] C. Bennett, E. Bernstein, G. Brassard, U. Vazirani. Strengths and weaknesses of quantum computing. SIAM Journal on Computing, 26(3):50-523, 997, quantph/ [3] E. Bernstein, U. Vazirani, Quantum complexity theory. SIAM Journal on Computing, 26:4-473, 997. [4] G. Brassard, P. Hoyer, A. Tapp. Quantum algorithm for the collision problem, quantph/ [5] G. Brassard, P. Hoyer, A. Tapp. Quantum counting. Proceedings of ICALP 98, Lecture Notes in Computer Science, 443:820-83, 998. Also quant-ph/ [6] H. Buhrman, R. de Wolf. Lower bounds for quantum search and derandomization, quant-ph/ [7] E. Farhi, J. Goldstone, S. Gutmann, M. Sipser. A limit on the speed of quantum computation for insertion into an ordered list, quant-ph/ [8] E. Farhi, J. Goldstone, S. Gutmann, M. Sipser. Invariant quantum algorithms for insertion into an ordered list, quant-ph/ [9] R. Freivalds, J. Bārzdiņš, K. Podnieks. Inductive inference of recursive functions: complexity bounds, in Baltic Computer Science, Lecture Notes in Computer Science, 502:-55, 99. [0] L. Grover. A fast quantum mechanical algorithm for database search, Proceedings of the 28th ACM Symposium on Theory of Computing, pp , 996, quant-ph/ [] N. Littlestone, M. Warmuth. The weighted majority algorithm, Information and Computation, 08(2):22-26, 994. [2] H. Röhrig. An upper bound for searching an ordered list, quant-ph/