1001.0018.txt

arXiv:1001.0018v2  [quant-ph]  28 Jan 2010Nonadaptive quantum query complexity
Ashley Montanaro∗
October 1, 2018
Abstract
We studythe powerofnonadaptivequantum queryalgorithms,whic h arealgorithms
whose queries to the input do not depend on the result of previous q ueries. First, we
show that any bounded-error nonadaptive quantum query algorit hm that computes
some total boolean function depending on nvariables must make Ω( n) queries to the
input in total. Second, we show that, if there exists a quantum algor ithm that uses k
nonadaptive oracle queries to learn which one of a set of mboolean functions it has
been given, there exists a nonadaptive classical algorithm using O(klogm) queries to
solve the same problem. Thus, in the nonadaptive setting, quantum algorithms can
achieve at most a very limited speed-up over classical query algorith ms.
1 Introduction
Many of the best-known results showing that quantum compute rs outperform their classical
counterparts are proven in the query complexity model. This model studies the number of
queries to the input xwhich are required to compute some function f(x). In this work, we
study two broad classes of problem that fit into this model.
In the first class of problems, computational problems, one wishes to compute some
boolean function f(x1,...,x n) using a small number of queries to the bits of the input
x∈ {0,1}n. The query complexity of fis the minimum number of queries required for any
algorithm to compute f, with some requirement on the success probability. The dete rmin-
istic query complexity of f,D(f), is the minimum number of queries that a deterministic
classical algorithm requires to compute fwith certainty. D(f) is also known as the decision
tree complexity of f. Similarly, the randomised query complexity R2(f) is the minimum
number of queries required for a randomised classical algor ithm to compute fwith success
probability at least 2 /3. The choice of 2 /3 is arbitrary; any constant strictly between 1 /2
and 1 would give the same complexity, up to constant factors.
There is a natural generalisation of the query complexity mo del to quantum computa-
tion, which gives rise to the exact and bounded-error quantu m query complexities QE(f),
Q2(f) (respectively). In this generalisation, the quantum algo rithm is given access to the
∗Department of Computer Science, University of Bristol, Woo dland Road, Bristol, BS8 1UB, UK;
montanar@cs.bris.ac.uk .
1inputxthrough a unitary oracle operator Ox. Many of the best-known quantum speed-ups
can be understood in the query complexity model. Indeed, it i s known that, for certain
partial functions f(i.e. functions where there is a promise on the input), Q2(f) may be ex-
ponentially smaller than R2(f)[14]. However, if fis atotal function, D(f) =O(Q2(f)6) [4].
See [6, 10] for good reviews of quantum and classical query co mplexity.
In the second class of problems, learning problems, one is given as an oracle an unknown
functionf?(x1,...,x n), which is picked from a known set Cofmboolean functions f:
{0,1}n→ {0,1}. These functions can be identified with n-bit strings or subsets of [ n], the
integers between 1 and n. The goal is to determine which of the functions in Cthe oraclef?
is, with some requirement on the success probability, using the minimum number of queries
tof?. Note that the success probability required should be stric tly greater than 1 /2 for
this model to make sense.
Borrowing terminology fromthe machinelearning literatur e, each function in Cis known
as aconcept, andCis known as a concept class [13]. We say that an algorithm that can
identify any f∈ Cwith worst-case success probability plearnsCwith success probability
p. This problem is known classically as exact learning from me mbership queries [3, 13],
and also in the literature on quantum computation as the orac le identification problem [2].
Many interesting results in quantum algorithmics fit into th is framework, a straightforward
example being Grover’s quantum search algorithm [9]. It has been shown by Servedio and
Gortler that the speed-up that may be obtained by quantum que ry algorithms in this model
is at most polynomial [13].
1.1 Nonadaptive query algorithms
This paper considers query algorithms of a highly restricti ve form, where oracle queries are
not allowed to depend on previous queries. In other words, th e queries must all be made
at the start of the algorithm. We call such algorithms nonadaptive , but one could also call
themparallel, in contrast to the usual serial model of query complexity, w here one query
follows another. It is easy to see that, classically, a deter ministic nonadaptive algorithm
that computes a function f:{0,1}n→ {0,1}which depends on all ninput variables must
query allnvariables (x1,...,x n). Indeed, for any 1 ≤i≤n, consider an input xfor which
f(x) = 0, butf(x⊕ei) = 1, where eiis the bit string which has a 1 at position i, and is 0
elsewhere. Then, if the i’th variable were not queried, changing the input from xtox⊕ei
would change the output of the function, but the algorithm wo uld not notice.
In the case of learning, the exact number of queries required by a nonadaptive determin-
istic classical algorithm to learn any concept class Ccan also be calculated. Identify each
concept in Cwith ann-bit string, and imagine an algorithm Athat queries some subset
S⊆[n] of the input bits. If there are two or more concepts in Cthat do not differ on any of
the bits inS, thenAcannot distinguish between these two concepts, and so canno t succeed
with certainty. On the other hand, if every concept x∈ Cis unique when restricted to S,
thenxcan be identified exactly by A. Thus the number of queries required is the minimum
size of a subset S⊆[n] such that every pair of concepts in Cdiffers on at least one bit in S.
We will be concerned with the speed-up over classical query a lgorithms that can be
2achieved by nonadaptive quantum query algorithms. Interes tingly, it is known that speed-
ups can indeed be found in this model. In the case of computing partial functions, the
speed-up can be dramatic; Simon’s algorithm for the hidden s ubgroup problem over Zn
2, for
example, is nonadaptive and gives an exponential speed-up o ver the best possible classical
algorithm [14]. Thereare also known speed-upsfor computin g total functions. For example,
the parity of nbits can be computed exactly using only ⌈n/2⌉nonadaptive quantum queries
[8]. More generally, anyfunction of nbits can be computed with bounded error using only
n/2+O(√n)nonadaptivequeries, byaremarkablealgorithmofvanDam[ 7]. Thisalgorithm
in fact retrieves allthe bits of the input xsuccessfully with constant probability, so can also
be seen as an algorithm that learns the concept class consist ing of all boolean functions on
nbits usingn/2+O(√n) nonadaptive queries.
Finally, one of the earliest results in quantum computation can be understood as a
nonadaptive learning algorithm. The quantum algorithm sol ving the Bernstein-Vazirani
parity problem [5] uses one query to learn a concept class of s ize 2n, for which any classical
learning algorithm requires nqueries, showing that there can be an asymptotic quantum-
classical separation for learning problems.
1.2 New results
We show here that these results are essentially the best poss ible. First, any nonadap-
tive quantum query algorithm that computes a total boolean f unction with a constant
probability of success greater than 1 /2 can only obtain a constant factor reduction in the
number of queries used. In particular, if we restrict to nona daptive query algorithms, then
Q2(f) = Θ(D(f)). In the case of exact nonadaptive algorithms, we show that the factor of
2 speed-up obtained for computing parity is tight. More form ally, our result is the following
theorem.
Theorem 1. Letf:{0,1}n→ {0,1}be a total function that depends on all nvariables,
and letAbe a nonadaptive quantum query algorithm that uses kqueries to the input to
computef, and succeeds with probability at least 1−ǫon every input. Then
k≥n
2/parenleftBig
1−2/radicalbig
ǫ(1−ǫ)/parenrightBig
.
In the case of learning, we show that the speed-up obtained by the Bernstein-Vazirani
algorithm [5] is asymptotically tight. That is, the query co mplexities of quantum and
classical nonadaptive learning are equivalent, up to a loga rithmic term. This is formalised
as the following theorem.
Theorem 2. LetCbe a concept class containing mconcepts, and let Abe a nonadaptive
quantum query algorithm that uses kqueries to the input to learn C, and succeeds with
probability at least 1−ǫon every input, for some ǫ <1/2. Then there exists a classical
nonadaptive query algorithm that learns Cwith certainty using at most
4klog2m
1−2/radicalbig
ǫ(1−ǫ)
queries to the input.
31.3 Related work
We note that the question of putting lower bounds on nonadapt ive quantum query algo-
rithms has been studied previously. First, Zalka has obtain ed a tight lower bound on the
nonadaptive quantum query complexity of the unordered sear ch problem, which is a par-
ticular learning problem [15]. Second, in [12], Nishimura a nd Yamakami give lower bounds
on the nonadaptive quantum query complexity of a multiple-b lock variant of the ordered
search problem. Finally, Koiran et al [11] develop the weigh ted adversary argument of Am-
bainis [1] to obtain lower bounds that are specific to the nona daptive setting. Unlike the
situation considered here, their bounds also apply to quant um algorithms for computing
partial functions.
We now turn to proving the new results: nonadaptive computat ion in Section 2, and
nonadaptive learning in Section 3.
2 Nonadaptive quantum query complexity of computation
LetAbe a nonadaptive quantum query algorithm. We will use what is essentially the
standard model of quantum query complexity [10]. Ais given access to the input x=
x1...xnvia an oracle Oxwhich acts on an n+1 dimensional space indexed by basis states
|0/an}brack⌉tri}ht,...,|n/an}brack⌉tri}ht, and performs the operation Ox|i/an}brack⌉tri}ht= (−1)xi|i/an}brack⌉tri}ht. We define Ox|0/an}brack⌉tri}ht=|0/an}brack⌉tri}htfor
technical reasons (otherwise, Acould not distinguish between xand ¯x). Assume that A
makeskqueries toOx. As the queries are nonadaptive, we may assume they are made i n
parallel. Therefore, the existence of a nonadaptive quantu m query algorithm that computes
fand fails with probability ǫis equivalent to the existence of an input state |ψ/an}brack⌉tri}htand a
measurement specified by positive operators {M0,I−M0}, such that /an}brack⌉tl⌉{tψ|O⊗k
xM0O⊗k
x|ψ/an}brack⌉tri}ht ≥
1−ǫfor all inputs xwheref(x) = 0, and /an}brack⌉tl⌉{tψ|O⊗k
xM0O⊗k
x|ψ/an}brack⌉tri}ht ≤ǫfor all inputs xwhere
f(x) = 1.
The intuition behind the proof of Theorem 1 is much the same as that behind “adver-
sary” arguments lower bounding quantum query complexity [1 0]. As in Section 1.1, let ej
denote the n-bit string which contains a single 1, at position j. In order to distinguish two
inputsx,x⊕ejwheref(x)/n⌉}ationslash=f(x⊕ej), the algorithm must invest amplitude of |ψ/an}brack⌉tri}htin
components where the oracle gives information about j. But, unless kis large, it is not
possible to invest in many variables simultaneously.
We will use the following well-known fact from [5].
Fact 3(Bernstein and Vazirani [5]) .Imagine there exists a positive operator M≤Iand
states|ψ1/an}brack⌉tri}ht,|ψ2/an}brack⌉tri}htsuch that /an}brack⌉tl⌉{tψ1|M|ψ1/an}brack⌉tri}ht ≤ǫ, but/an}brack⌉tl⌉{tψ2|M|ψ2/an}brack⌉tri}ht ≥1−ǫ. Then |/an}brack⌉tl⌉{tψ1|ψ2/an}brack⌉tri}ht|2≤
4ǫ(1−ǫ).
We now turn to the proof itself. Write the input state |ψ/an}brack⌉tri}htas
|ψ/an}brack⌉tri}ht=/summationdisplay
i1,...,ikαi1,...,ik|i1,...,ik/an}brack⌉tri}ht,
4where, for each m, 0≤im≤n. It is straightforward to compute that
O⊗k
x|i1,...,ik/an}brack⌉tri}ht= (−1)xi1+···+xik|i1,...,ik/an}brack⌉tri}ht.
Asfdepends on all ninputs, for any j, there exists a bit string xjsuch thatf(xj)/n⌉}ationslash=
f(xj⊕ej). Then
(OxjOxj⊕ej)⊗k|i1,...,ik/an}brack⌉tri}ht= (−1)|{m:im=j}||i1,...,ik/an}brack⌉tri}ht;
in other words ( OxjOxj⊕ej)⊗knegates those basis states that correspond to bit strings
i1,...,ikwherejoccurs an odd number of times in the string. Therefore, we hav e
|/an}brack⌉tl⌉{tψ|(OxjOxj⊕ej)⊗k|ψ/an}brack⌉tri}ht|2=
/summationdisplay
i1,...,ik|αi1,...,ik|2(−1)|{m:im=j}|
2
=
1−2/summationdisplay
i1,...,ik|αi1,...,ik|2[|{m:im=j}|odd]
2
=: (1−2Wj)2.
Now, by Fact 3, (1 −2Wj)2≤4ǫ(1−ǫ) for allj, so
Wj≥1
2/parenleftBig
1−2/radicalbig
ǫ(1−ǫ)/parenrightBig
.
On the other hand,
n/summationdisplay
j=1Wj=n/summationdisplay
j=1/summationdisplay
i1,...,ik|αi1,...,ik|2[|{m:im=j}|odd]
=/summationdisplay
i1,...,ik|αi1,...,ik|2n/summationdisplay
j=1[|{m:im=j}|odd]
≤/summationdisplay
i1,...,ik|αi1,...,ik|2k=k.
Combining these two inequalities, we have
k≥n
2/parenleftBig
1−2/radicalbig
ǫ(1−ǫ)/parenrightBig
.
3 Nonadaptive quantum query complexity of learning
In the case of learning, we use a very similar model to the prev ious section. Let Abe a
nonadaptivequantumqueryalgorithm. Aisgiven access toanoracle Ox, whichcorresponds
toabit-string xpickedfromaconcept class C.Oxactsonann+1dimensionalspaceindexed
by basis states |0/an}brack⌉tri}ht,...,|n/an}brack⌉tri}ht, and performs the operation Ox|i/an}brack⌉tri}ht= (−1)xi|i/an}brack⌉tri}ht, withOx|0/an}brack⌉tri}ht=|0/an}brack⌉tri}ht.
5Assume that Amakeskqueries toOxand outputs xwith probability strictly greater than
1/2 for allx∈ C.
We will prove limitations on nonadaptive quantum algorithm s in this model as follows.
First, we show that a nonadaptive quantum query algorithm th at useskqueries to learn C
is equivalent to an algorithm using one query to learn a relat ed concept class C′. We then
show that existence of a quantum algorithm using one query th at learns C′with constant
success probability greater than 1 /2 implies existence of a deterministic classical algorithm
usingO(log|C′|) queries. Combining these two results gives Theorem 2.
Lemma 4. LetCbe a concept class over n-bit strings, and let C⊗kbe the concept class
defined by
C⊗k={x⊗k:x∈ C},
wherex⊗kdenotes the (n+ 1)k-bit string indexed by 0≤i1,...,ik≤n, withx⊗k
i1,...,ik=
xi1⊕ ··· ⊕xik, and we define x0= 0. Then, if there exists a classical nonadaptive query
algorithm that learns C⊗kwith success probability pand usesqqueries, there exists a classical
nonadaptive query algorithm that learns Cwith success probability pand uses at most kq
queries.
Proof.Given access to x, an algorithm Acan simulate a query of index ( x1,...,x k) ofx⊗k
by using at most kqueries to compute x1⊕··· ⊕xk. Hence, by simulating the algorithm
for learning C⊗k,Acan learn C⊗kwith success probability pusing at most kqnonadaptive
queries. Learning C⊗ksuffices to learn C, because each concept in C⊗kuniquely corresponds
to a concept in C(to see this, note that the first nbits ofx⊗kare equal to x).
Lemma 5. LetCbe a concept class containing mconcepts. Assume that Ccan be learned
using one quantum query by an algorithm that fails with proba bility at most ǫ, for some
ǫ<1/2. Then there exists a classical algorithm that uses at most (4log2m)/(1−2/radicalbig
ǫ(1−ǫ))
queries and learns Cwith certainty.
Proof.Associate each concept with an n-bit string, for some n, and suppose there exists a
quantum algorithm that uses one query to learn Cand fails with probability ǫ<1/2. Then
by Fact 3 there exists an input state |ψ/an}brack⌉tri}ht=/summationtextn
i=0αi|i/an}brack⌉tri}htsuch that, for all x/n⌉}ationslash=y∈ C,
|/an}brack⌉tl⌉{tψ|OxOy|ψ/an}brack⌉tri}ht|2≤4ǫ(1−ǫ),
or in other words/parenleftBiggn/summationdisplay
i=0|αi|2(−1)xi+yi/parenrightBigg2
≤4ǫ(1−ǫ). (1)
We now show that, if this constraint holds, there must exist a subset of the inputs S⊆[n]
such that every pair of concepts in Cdiffers on at least one input in S, and|S|=O(logm).
By the argument of Section 1.1, this implies that there is a no nadaptive classical algorithm
that learns Mwith certainty using O(logm) queries.
We will use the probabilistic method to show the existence of S. For anyk, form a
subsetSof at most kinputs between 1 and nby a process of krandom, independent
6choices of input, where at each stage input iis picked to add to Swith probability |αi|2.
Now consider an arbitrary pair of concepts x/n⌉}ationslash=y, and letS+,S−be the set of inputs on
which the concepts are equal and differ, respectively. By the c onstraint (1), we have
4ǫ(1−ǫ)≥/parenleftBiggn/summationdisplay
i=0|αi|2(−1)xi+yi/parenrightBigg2
=
/summationdisplay
i∈S+|αi|2−/summationdisplay
i∈S−|αi|2
2
=
1−2/summationdisplay
i∈S−|αi|2
2
,
so/summationdisplay
i∈S−|αi|2≥1
2−/radicalbig
ǫ(1−ǫ).
Therefore, at each stage of adding an input to S, the probability that an input in S−is
added is at least1
2−/radicalbig
ǫ(1−ǫ). So, after kstages of doing so, the probability that none
of these inputs has been added is at most/parenleftBig
1
2+/radicalbig
ǫ(1−ǫ)/parenrightBigk
. As there are/parenleftbigm
2/parenrightbig
pairs of
conceptsx/n⌉}ationslash=y, by a union bound the probability that none of the pairs of con cepts differs
on any of the inputs in Sis upper bounded by
/parenleftbiggm
2/parenrightbigg/parenleftbigg1
2+/radicalbig
ǫ(1−ǫ)/parenrightbiggk
≤m2/parenleftbigg1
2+/radicalbig
ǫ(1−ǫ)/parenrightbiggk
.
For anykgreater than
2log2m
log22/(1+2/radicalbig
ǫ(1−ǫ))<4log2m
1−2/radicalbig
ǫ(1−ǫ)
this probability is strictly less than 1, implying that ther e exists some choice of S⊆[n]
with|S| ≤ksuch that every pair of concepts differs on at least one of the in puts inS. This
completes the proof.
We are finally ready to prove Theorem 2, which we restate for cl arity.
Theorem. LetCbe a concept class containing mconcepts, and let Abe a nonadaptive
quantum query algorithm that uses kqueries to the input to learn C, and succeeds with
probability at least 1−ǫon every input, for some ǫ <1/2. Then there exists a classical
nonadaptive query algorithm that learns Cwith certainty using at most
4klog2m
1−2/radicalbig
ǫ(1−ǫ)
queries to the input.
Proof.LetOxbe the oracle operator corresponding to the concept x. Then a nonadaptive
quantum algorithm Athat learns xusingkqueries to Oxis equivalent to a quantum
algorithm that uses one query to O⊗k
xto learnx. It is easy to see that this is equivalent to
Ain fact using one query to learn the concept class C⊗k. By Lemma 5, this implies that
there exists a classical algorithm that uses at most (4 klog2m)/(1−2/radicalbig
ǫ(1−ǫ)) queries
to learn C⊗kwith certainty. Finally, by Lemma 4, this implies in turn tha t there exists a
classical algorithm that uses the same number of queries and learnsCwith certainty.
7Acknowledgements
I would like to thank Aram Harrow and Dan Shepherdfor helpful discussions and comments
on a previous version. This work was supported by the EC-FP6- STREP network QICS and
an EPSRC Postdoctoral Research Fellowship.
References
[1] A. Ambainis. Polynomial degree vs. quantum query comple xity.J. Comput. Syst. Sci. ,
72(2):220–238, 2006. quant-ph/0305028 .
[2] A. Ambainis, K. Iwama, A. Kawachi, H. Masuda, R. Putra, an d S. Yamashita. Quan-
tum identification of Boolean oracles. In Proc. STACS 2004 , pages 93–104. Springer,
2004.quant-ph/0403056 .
[3] D. Angluin. Queries and concept learning. Machine Learning , 2(4):319–342, 1988.
[4] R. Beals, H. Buhrman, R. Cleve, M. Mosca, and R. de Wolf. Qu antum lower bounds
by polynomials. J. ACM, 48(4):778–797, 2001. quant-ph/9802049 .
[5] E. Bernstein and U. Vazirani. Quantum complexity theory .SIAM J. Comput. ,
26(5):1411–1473, 1997.
[6] H. Buhrman and R. de Wolf. Complexity measures and decisi on tree complexity: a
survey.Theoretical Computer Science , 288:21–43, 2002.
[7] W. vanDam. Quantumoracle interrogation: Gettingall in formation foralmost halfthe
price. In Proc. 39thAnnual Symp. Foundations of Computer Science , pages 362–367.
IEEE, 1998. quant-ph/9805006 .
[8] E. Farhi, J. Goldstone, S. Gutmann, and M. Sipser. A limit on the speed of
quantum computation in determining parity. Phys. Rev. Lett. , 81:5442–5444, 1998.
quant-ph/9802045 .
[9] L. Grover. Quantum mechanics helps in searching for a nee dle in a haystack. Phys.
Rev. Lett. , 79(2):325–328, 1997. quant-ph/9706033 .
[10] P. Høyer and R. ˇSpalek. Lower bounds on quantum query complexity. Bulletin
of the European Association for Theoretical Computer Science , 87:78–103, 2005.
quant-ph/0509153 .
[11] P. Koiran, J. Landes, N. Portier, and P. Yao. Adversary l ower bounds for nonadaptive
quantum algorithms. In Proc. WoLLIC 2008: 15th Workshop on Logic, Language,
Information and Computation , pages 226–237. Springer, 2008. arXiv:0804.1440 .
[12] H. Nishimura and T. Yamakami. An algorithmic argument f or nonadaptive query
complexity lower bounds on advised quantum computation. In Proc. 29th Interna-
tional Symposium on Mathematical Foundations of Computer Sc ience, pages 827–838.
Springer, 2004. quant-ph/0312003 .
8[13] R. Servedio and S. Gortler. Quantum versus classical le arnability. In Proc. 16thAnnual
IEEE Conf. Computational Complexity , pages 138–148, 2001. quant-ph/0007036 .
[14] D. R. Simon. Onthepower of quantum computation. SIAM J. Comput. , 26:1474–1483,
1997.
[15] C. Zalka. Grover’s quantum searching algorithm is opti mal.Phys. Rev. A. , 60(4):2746–
2751, 1999. quant-ph/9711070 .
9