Quantum Property Testing

13 Pages·0.2 MB·

by  H. Buhrman

Quantum Property Testing
‡
Harry Buhrman§ Lance Fortnow¶ Ilan Newmank Hein R¨ohrig§
November 12, 2001
2
0 Abstract
0
A language L has a property tester if there exists a probabilistic algorithm that given an input
2
xonlyasksasmallnumberofbitsofxanddistinguishesthecasesastowhetherxisinLandxhas
n
large Hamming distance from all y in L. We define a similar notion of quantum property testing
a
J and show that there exist languages with quantum property testers but no good classical testers.
5 We also show there exist languages which require a large number of queries even for quantumly
2 testing.

1
v 1 Introduction
7
1
1 Suppose we have a large data set, for example, a large chunk of the world-wide web or a genomic
1 sequence. We would like to test whether the data has a certain property, but we may not have the
0
time to even look at the entire data set or even a large portion of it.
2
0 To handle these types of problems, Rubinfeld and Sudan [RS96] and Goldreich, Goldwasser and
/ Ron [GGR98] have developed the notion of property testing. Testable properties come in many
h
p varieties including graph properties (e.g., [GGR98, AFKS99, Fis01a, Fis01b, Alo01, GT01]), algebraic
- properties of functions [BLR93, RS96, EKK+00] and regular languages [ANKS99]. Ron [Ron00] gives
t
n
a nice survey of this area.
a
u In this model, the property tester has random access to the n input bits similar to the black-box
q oracle model. The tester can query only a small, usually some fixed constant, probabilistically-chosen
:
v set of bits of the input. Clearly we cannot determine from these small number of bits whether the
i
X input sits in some language L. However, for many languages we can distinguish the cases that the
r input is in L from whether the input differs from all inputs in L of the same length by some constant
a
fraction of input bits.
Sincewehaveseenmanyexampleswherequantumcomputationgivesusanadvantageoverclassical
computation[BV97,Sim97,Sho97,Gro96]onemaynaturallyaskwhetherusingquantumcomputation
may lead to better property testers. By using the quantum oracle-query model developed by Beals,
Buhrman,Cleve,MoscaanddeWolf[BBC+98],wecaneasilyextendthedefinitionsofpropertytesting
to the quantum setting.
Beals, et. al. [BBC+98] have shown that for all total functions we have a polynomial relationship
between the number of queries required by quantum machine and that needed by a deterministic
machine. For greater separations oneneeds to requirea promisein theinputandthe known examples,
such as those due to Simon [Sim97] and Bernstein-Vazirani [BV97], require considerable structure in
the promise. In property testing there is a natural promise of either being in the language or far from
‡Research donewhile all authors were visiting theNEC Research Institute.
§CWI and Universityof Amsterdam; partially supported by the EU fifth framework project QAIP,IST-1999-11234.
¶NEC Research Institute
kHaifa University and NEC Research Institute
1
any input in the language. This promise would seem to have too little structure to give a separation
but in fact we can prove that quantum property testing can greatly improve on classical testing.
We show that any subset of Hadamard codes has a quantum property tester and most subsets
would require Θ(logn) queries to test with a probabilistic tester. This shows that indeed quantum
property testers are more powerful than classical testers. Moreover, we also give an example of a
language where the quantum tester is exponentially more efficient.
Beals, et. al. [BBC+98] observed that any k-query quantum algorithm gives rise to a degree-2k
polynomial in theinputbits, which gives theacceptance probability of thealgorithm; thus, a quantum
property tester for P gives rise to a polynomial that is on all binary inputs between 0 and 1, that is
at least 2/3 on inputs with the property P and at most 1/3 on inputs far from having the property
P. Szegedy [Sze99] suggested to algebraically characterize the complexity of classical testing by the
minimumdegree of such polynomials; however, our separation results implythat therearefor example
properties, for which such polynomials have constant degree, but for which the best classical tester
needs Ω(logn) queries.
Perhaps every language has a quantum property tester with a small number of queries. We show
that this is not the case. We prove that for most properties of a certain size, any quantum algorithm
requiresΩ(n)queries. Wethenshowthatanaturalproperty,namely,therangeofad-wiseindependent
pseudorandom generator cannot be quantumly tested with less than (d + 1)/2 queries for any odd
d n/logn 1.
≤ −
2 Preliminaries
Property testing was first developed by Rubinfeld and Sudan [RS96] and Goldreich, Goldwasser and
Ron [GGR98]. We will use the following formal definition of property testing from Goldreich [Gol98].
Definition 2.1 Let S be a finite set, and P a subset of functions mapping S to 0,1 . A property
{ }
tester for P is a probabilistic oracle machine M, which given a distance parameter ǫ > 0 and oracle
access to an arbitrary function f : S 0,1 , satisfies the following conditions:
→ { }
1. the tester accepts f if it is in P:
2
if f P then Pr(Mf(ǫ) = 1)
∈ ≥ 3
2. the tester rejects f if it is far from P:
1
if x S : f(x)= g(x) > ǫ S , for every g P, then Pr(Mf(ǫ) = 1)
|{ ∈ 6 }| ·| | ∈ ≤ 3
Definition 2.2 The complexity of the tester is the number of oracle queries it makes: A property P
has a (ǫ,q)-tester if there is a tester for P that makes at most q oracle queries for distance parameter
ǫ.
Weoftenconsider alanguage L 0,1 ∗ asthe familyof properties P with P the characteristic
n n
⊆ { } { }
functions of the length-n strings from L, and analyze the query complexity q = q(ǫ,n) asymptotically
for large n.
To define quantum property testing we simply modify Definition 2.1 by allowing M to be a quantum
oracle machine. We need to be careful to make sure our oracle queries are unitary operations. If
f(x) = g(y) for all x,y S and f,g P, we use the oracle-query model by Beals, Buhrman,
| | | | ∈ ∈
2
Cleve, Mosca and de Wolf [BBC+98]: we define the unitary transformation O that maps the ba-
f
sis state x,y,z to x,y f(x),z where x = log S , y = f(x) and denotes bitwise exclu-
| i | ⊕ i | | ⌈ | |⌉ | | | | ⊕
sive or. In case there are x,y,f,g so that f(x) = g(y), we define O as mapping x,l,y,z to
f
| | 6 | | | i
x,l+ f(x) mod k,y 0k−|f(x)|f(x),z where k = max f(x) : f P and x S , x = log S ,
| | | ⊕ i {| | ∈ ∈ } | | ⌈ | |⌉
l = logk , and y = k.
| | ⌈ ⌉ | |
We recommend the book of Nielsen and Chuang [NC00] for background information on quantum
computingandthesurveysofRon[Ron00]andGoldreich[Gol98]forabackgroundonpropertytesting.
3 Separating Quantum and Classical Property Testing
We show that there exist languages with (ǫ,O(1)) quantum property testers that do not have (ǫ,O(1))
classical testers.
Theorem 3.1 There is a languages L that is ǫ-testable by a quantum test with O(1/ǫ) number of
queries but for which any probabilistic 1/3-test requires Ω(logn) queries.
We use Hadamard codes to provide examples for Theorem 3.1:
Definition 3.2 The Hadamard code of y 0,1 logn is x= h(y) 0,1 n such that x = y i where
i
∈ { } ∈ { } ·
y i denotes the inner product of two vectors y,i Flogn.
· ∈ 2
Note: the Hadamard mapping h : 0,1 logn 0,1 n is one-to-one. Bernstein and Vazirani [BV97]
{ } → { }
showed that a quantum computer can extract y with one query to an oracle for (the bits of) x,
whereas a classical probabilistic procedure needs Ω(logn) queries. Based on this separation for a
decision problem we construct for A 0,1 logn the property P 0,1 n,
A
⊆ { } ⊆ { }
P := x : y A s.t. x= h(y) .
A
{ ∃ ∈ }
Theorem 3.1 follows from the following two lemmas.
Lemma 3.3 For everyA, P can be (ǫ,O(1/ǫ))-quantumly tested. Furthermore, the test hasone-sided
A
error.
Lemma 3.4 For most A of size A = n/2, P requires Ω(logn) queries for a probabilistic 1/3-test
A
| |
(even for testers with two-sided error.)
Before we prove Lemma 3.3 we note that for any A, P can be tested by an (even nonadaptive)
A
one-sided algorithm with O(1/ǫ+logn); hence, the result of Lemma 3.4 is tight. An O(1/ǫlogn)-test
follows from Observation 3.5 below. The slightly more efficient test is the following: First we query
x , i = 0,... ,logn. Note that if x = h(y) then y = x for i = 0,... ,logn. Thus a candidate y for
2i i 2i
x = h(y) is found. If y / A then x is rejected. Then for k = O(1/ǫ) times independently a random
∈
index i 1,... ,n is chosen and if x = y i, for the candidate y that was found before, then x is
i
∈ { } 6 ·
rejected. Otherwise, x is accepted. Clearly if x is rejected then x / P . It is easily verified that if x
A
∈
has Hamming distance more than ǫn from every z in P then with constant probability x is rejected.
A
Proof of Lemma 3.3. P can be checked with O(1/ǫ) queries on a quantum computer: The test is
A
similar to the test above except that y can be found in O(1) queries: k times query for random i, j
values x , x , and x . If x x = x reject. k = O(1/ǫ) is sufficient to detect an input x that
i j i⊕j i j i⊕j
⊕ 6
is ǫn-far from being a Hadamard codeword with high probability. Now run the Bernstein-Vazirani
algorithm to obtain y. Accept if and only if y A. Obviously, if x P , the given procedure accepts,
A
∈ ∈
and if x is far from any x′ P , then it is either far from being a Hadamard codeword (which is
A
∈
3
detected in the first step) or it is close to a Hadamard codeword h(y′) for an y′ A; note that in this
6∈
case x is far from any h(y), y A as two distinct Hadamard codewords are of Hamming distance n/2.
∈
Thus, in this case the second part of the tester succeeds with high probability in findingy′ and rejects
because y′ A. We note also that this algorithm has one-sided error. 2
6∈
Proof of Lemma 3.4. Thelower boundmakesuseoftheYaoprinciple[Yao77]: letD beanarbitrary
probability distributionon positiveand negative inputs(i.e., inputsthateither belongto P or areǫn-
A
farfromP ). Thenifeverydeterministicalgorithm thatmakes atmostq queries,errswithprobability
A
at least 1/8 (with respect to input chosen according to D,) then q is a lower bound on the number of
queries of any randomized algorithm for testing P with error probability bounded by 1/8.
A
D will be the uniform distribution over Hadamard codewords of length n, namely, generated by
choosing y 0,1 logn uniformly at random and setting x = h(y). Note that for any A 0,1 logn,
∈ { } ⊂ { }
D is concentrated on positive and negative inputs as required, as two Hadamard codewords are of
Hamming distance n/2 apart.
The lower bound will be established by a counting argument. We show that for a fixed tester that
makes q (logn)/2 queries, the probability (over random choices of A) that the the algorithm errs
≤
on at most a 1/8-fraction of the inputs is bounded from above by 1/(10T) where T is the number of
such algorithms. By the union bound it follows that for most properties there is no such algorithm.
Indeed, let A 0,1 logn be chosen by picking independently each i 0,1 logn to be in A with
⊆ { } ∈ { }
probability 1/2; this will not necessarily result in a set A of size n/2 butwe can condition on the event
that A = n/2 and will not loose much. Let be any fixed deterministic decision tree performing
| | T
at most q queries in every branch. Then let c( ) := y (h(y)) = accept and let µ( ) := c( )/n,
T { |T } T | T |
i.e., µ( ) is the fraction of inputs that accepts. Assume first that µ( ) 1/2. Since for a
T T T ≤
random y we have Pr [ (h(y)) = accept] = µ( ) 1/2, it follows by a Chernoff-type bound that
y
T T ≤
Pr [A c( ) 3/4A] 2−n/8. However, if A c( ) < 3/4A then will be wrong on at least
A
| ∩ T | ≥ | | ≤ | ∩ T | | | T
1/4 of the positive inputs which is at least n/8 of all inputs. Hence with probability at most 2−n/8,
will be correct on at least 7/8 of the inputs. If µ( ) > 1/2 the same reasoning shows that with
T T
probability of at most 1 2−n/8 it will err on at least an 1/4-fraction of the negative inputs. Hence in
−
total, for every fixed , Pr [ is correct on at least 7/8 of the inputs] 2−n/8.
A
T T ≤
Now, let us bound from above the number of algorithms that make at most q queries. As an
algorithm may be adaptive, it can be defined by 2q 1 query positions (all queries for all branches)
−
and a Boolean function f : 0,1 q accept,reject of the decision made by the algorithm for the
possibleanswers. Hence, the{rear}ea→tm{ostT (2n)2q}suchalgorithms. However, forq < (logn)/2, we
≤
have T 2−n/8 =o(1), which shows that for most A as above, any ǫ-test that queries at most (logn)/2
·
many queries has error probability of at least 1/8. Standard amplification techniques then imply that
any algorithm that queries clogn many queries (for some constant c) has error at least 1/3. 2
Observation 3.5 Let P 0,1 n be a property with P = s then P can be ǫ-tested by a one-sided
⊆ { } | |
algorithm using O((logs)/ǫ) many queries.
We omit the proof from this draft.
4 An Exponential Separation
Inthissection, weshowthataquantumcomputercanbeexponentially moreefficientintestingcertain
properties than a classical computer.
Theorem 4.1 There is a languages L that is (ǫ,lognloglogn)-quantumly testable for any ǫ = Ω(1).
However, any probabilistic 1/8-test for L requires nΩ(1) queries.
4
The language that we provide is inspired by Simon’s problem [Sim97] and our quantum testing algo-
rithm makes use of Brassard and Høyer’s algorithm for Simon’s problem [BH97]. Simon’s problem
is to find s 0,1 n 0n from an function-query oracle for some f : 0,1 n 0,1 n, such that
∈ { } \{ } { } → { }
f(x) = f(y) x = y s. Simon proved that classically, Ω(2n/2) queries are required on average to
⇔ ⊕
find s, and gave a quantum algorithm for determining s with an expected number of queries that is
polynomial in n; Brassard and Høyer improved the algorithm to worst-case polynomial time. Their
algorithm produces in each run a z with z s = 0 that is linearly independent to all previously com-
·
putedsuchzs. Essentially, ourquantumtester usesthissubroutinetotrytoextractinformation about
s until it fails repeatedly. Recently Høyer [Høy01] analyzed this approach in group-theoretic terms,
obtaining an alternative proof to Theorem 4.3.
In the following, let N = 2n denote the length of the binary string encoding a function f :
0,1 n 0,1 . For x 0,1 n let x[j] be the jth bit of x, i.e., x = x[1]...x[n]; the inner product
o{f x,}y →0{,1 n}as vecto∈rs{in F}n is x y = n x[j]y[j] mod 2. We define
∈ { } 2 · j=1
P
L := f 0,1 N : s 0,1 n 0n x 0,1 n f(x)= f(x s)
{ ∈ { } ∃ ∈ { } \{ } ∀ ∈ { } ⊕ }
Theorem 4.1 follows from the following two theorems.
Theorem 4.2 Any classical 1/8-tester for L must make Ω(√N) queries (even when allowing two-
sided error.)
Theorem 4.3 There isa quantum property tester for L making O(logN loglogN)queries. Moreover,
this quantum property tester makes all its queries nonadaptively.
Proof of Theorem 4.2. We again apply the Yao principle [Yao77] as in the proof of Lemma 3.4: we
construct two distributions, P and U, on positive and negative (at least N/8-far) inputs, respectively,
such that any deterministic (adaptive) decision tree has error 1/2 o(1) when trying to distinguish
T −
whether an input is chosen from U or P. Indeed, we will show a stronger statement: Let be any
T
deterministic decision tree. Let v be a vertex of . Let Pr (v) and Pr (v) be the probability the
P U
T
an input chosen according to P and U, respectively, is consistent with v. We will show that for any
vertex v of Pr (v) Pr (v) = o(1); hence, has error 1/2 o(1).
P U
T | − | T −
The distribution P is defined as follows: We first chose s 0,1 n at random. This defines a
∈ { }
matching M of 0,1 n by matching x with x s. Now a function f is defined by choosing for each
s s
{ } ⊕
matched pair independently f (x) = f (x s) = 1 with probability 1/2 and f (x) = f (x s) = 0
s s s s
⊕ ⊕
with probability 1/2. Clearly, this defines a distribution that is concentrated on positive inputs. Note
that it might be that by choosing different s’s we end up choosing the same function, however, this
will be considered different events in the probability space. Namely, the atomic events in P really are
the pairs (s,f ) as described above.
s
NowletU betheuniformdistributionoverallfunctions,namely, weselectthefunctionbychoosing
foreachxindependentlyf(x)= 1withprobability1/2and0withprobability1/2. Sinceeveryfunction
has a non zero probability, U is not supported exclusively on the negative instances. However, as we
proceed to show, a function chosen according to U is N/8-far from having the property with very high
probability, and hence U will be a good approximation to the desired distribution:
Definition 4.4 For f : 0,1 n 0,1 and s 0,1 n we define n := x : f(x)= f(x s) .
s
{ } → { } ∈ { } |{ ⊕ }|
Lemma 4.5 Let f be chosen according to U. Then Pr [ s 0,1 n :n N/8] exp( Ω(N)).
U s
∃ ∈ { } ≥ ≤ −
Proof. Let f be chosen according to U and s 0,1 n. By a Chernoff bound we obtain Pr [n
U s
∈ { } ≥
N/8] exp( Ω(N)). Together with the union bound over all s’s this yields Pr [ s 0,1 n : n
U s
≤ − ∃ ∈ { } ≥
N/8] 2n exp( Ω(N)) exp( Ω(N)). 2
≤ · − ≤ −
5
In particular, a direct consequence of Lemma 4.5 is that with probability 1 exp( Ω(N)) an input
− −
chosen according to U will be N/8-far from having the property.
From the definition of U, we immediately obtain the following:
Lemma 4.6 Let be any fixed deterministic decision tree and let v be a vertex of depth d in . Then
T T
Pr [f is consistent with the path to v]= 2−d.
U
We now want to derive a similar bound as in the last lemma for functions chosen according to P. For
this we need the following definition for the event that after d queries, nothing has been learned about
the hidden s:
Definition 4.7 Let be a deterministic decision tree and u a vertex in at depth d. We denote the
T T
path from the root of to u by path(u). Any vertex v in defines a query position x 0,1 n. For
v
T T ∈ { }
f = f chosen according to P, we denote by B the event B := (s,f ) : s = x x for all v,w
s u u s v w
{ 6 ⊕ ∈
path(u) .
}
Lemma 4.8 Let v be a vertex of depth d in a decision tree . Then Pr [B ] 1 d−1 /N
T P v ≥ − 2
(cid:0) (cid:1)
Proof. B does not occur if for some v,w on the path to v we have s = x x . As there are d 1
v v w
⊕ −
such vertices, there are at most d−1 pairs. Each of these pair excludes exactly one s and there are
2
N possible s’s. (cid:0) (cid:1) 2
Lemma 4.9 Let v be a vertex of depth d in a decision tree and let f be chosen according to P.
T
Then Pr [f is consistent with v B ]= 2−d.
P v
|
Proof. By the definition of P, f gets independently random values on vertices that are not matched.
But if B occurs, then no two vertices along the path to v are matched and hence the claim follows.
v
2
Now we can complete the proof of the theorem: assume that is a deterministic decision tree
T
of depth d = o(√N) and let v be any leaf of . Then by Lemmas 4.8 and 4.9, we get that
T
Pr [f is consistent with v] =(1 o(1))2−d. On the other hand, let U′ be the distribution on negative
P
−
inputs defined by U conditioned on the event that the input is at least N/8-far from the property.
Then by Lemmas 4.5 and 4.6 we get that Pr [f is consistent with v]= (1 o(1))2−d and hence has
U′
− T
only o(1) bias of being right on every leaf which directly imply that its error probability is 1/2 o(1).
−
2
Proof of Theorem 4.3. We give a quantum algorithm making O(logN loglogN) queries to the
quantum oracle for input f 0,1 N. We will show that it accepts with probability 1 if f L and
∈ { } ∈
rejects with high probability if the Hamming distance between f and every g L is at least ǫN.
∈
Our algorithm, given in Figure 1, consists of a classical main program and a quantum subroutine Q
adapted from Brassard and Høyer’s algorithm for Simon’s problem [BH97, Section 4]. The quantum
1 1
gates used are the 2n-dimensional Hadamard transform H , which applies /√2 individually
2n (cid:18)1 1(cid:19)
−
to each of n qubits, the quantum oracle query O , and classical reversible operations run in quantum
f
superposition.
The following technical lemma captures the operation of the quantum subroutine Q. Essential
proofs to this and later lemmas are included in the appendix.
6
Main Program Subroutine Q
for k = 0 to n 1 do input: z ,... ,z 0,1 n
1 k
− ∈ { }
l 0 output: z 0,1 n
← ∈ { }
repeat quantum workspace:
X ⊗Y ⊗Z
z Q(z ,... ,z ) (where isnqubits = , = C2,
1 k 1 n i
← X X X ⊗···⊗X X
l l+1 = C2 is one qubit, and
← Y
until z = 0 or l > 2(logn)/ǫ2 is k qubits = , = C2)
1 k j
6 Z Z Z ⊗···⊗Z Z
if z = 0 then initialize the workspace to 0n 0 0k
| i| i| i
accept apply H to
2n
X
else apply O to
f
X ⊗Y
z z apply H to
k+1 2n
← X
reject for j = 1 to k do
i min i : z [i] = 1
j
← { }
apply CNOT with control and target
i j
X Z
apply x x z to conditional on
j j
| i 7→ | ⊕ i X Z
apply H to
2 j
Z
return measurement of
X
Figure 1: The Quantum Property Tester
Lemma 4.10 When Q is passed k linearly independent vectors z ,... ,z so that all i := min i :
1 k j
{
z [i] = 1 are distinct for 1 j k, then the state before the measurement is
j
} ≤ ≤
√2k
ψ := ( 1)x·y y f(x) x z x z .
1 k
| i N − | i| i| · i···| · i
x∈X{0,1}n y∈X{0,1}n
y[ij]=0∀j≤k
As an immediate consequence, we can establish the invariant that in the main program z ,... ,z
1 k
{ }
always is linearly independent with i = min i : z [i] = 1 distinct for 1 j k; moreover, if f L,
j j
{ } ≤ ≤ ∈
then just as in Simon’s algorithm, a nonzero z is orthogonal to the hidden s:
Lemma 4.11 If measuring the first register, , yields a nonzero value z, then
X
1. z ,... ,z ,z is linearly independent,
1 k
{ }
2. min i : z[i] = 1 is distinct from i for 1 j k, and
j
{ } ≤ ≤
3. if f L, then z s = 0 for any s such that f(x)= f(x s) for all x.
∈ · ⊕
Next, we want to assess the probability of obtaining z = 0 in the main loop. We let P denote the
0
projection operator mapping 0 y z 0 y z and x y z 0 for x = 0; hence, P ψ 2 is the
0
| i| i| i 7→ | i| i| i | i| i| i 7→ 6 k | ik
probability of obtaining 0 when measuring subspace of the quantum register in state ψ . We can
X | i
characterize the probability for outcome z = 0 in terms of the following definition and lemma:
Definition 4.12 For c 0,1 k and z , ... , z 0,1 n we define D := x 0,1 n : x z =
1 k c 1
∈ { } ∈ { } { ∈ { } ·
c[1],... ,x z = c[k] .
k
· }
Lemma 4.13 Let ψ be the state before the measurement in Q, when Q is passed k linearly indepen-
| i
dent vectors z ,... ,z so that all i := min i : z [i] = 1 are distinct for 1 j k.
1 k j j
{ } ≤ ≤
1. P ψ 2 = 1 if and only if for every c 0,1 k, f is constant when restricted to D .
0 c
k | ik ∈ { }
7
2. If P ψ 2 1 ǫ2/2, then f differs in at most ǫN points from some function g that is constant
0
k | ik ≥ −
when restricted to D for every c 0,1 k.
c
∈ { }
We need to relate these two cases to membership in L and bound the number of repetitions needed
to distinguish between the two cases. This is achieved by the following two lemmas.
Lemma 4.14 Let k be the minimum number of linearly independent vectors z , ... , z so that for
1 k
each c 0,1 k, f is constant when restricted to D . Then f L if and only if k < n.
c
∈ { } ∈
Lemma 4.15 Let 0 < q < 1, and φ , ... , φ be quantum states satisfying P φ 2 < 1 δ for
1 m 0 j
| i | i k | ik −
1 j m. If m = logq/log(1 δ) = Θ( logq/δ), then with probability at most q measuring the
≤ ≤ − − X
register of φ , ... , φ will yield m times outcome 0.
1 m
| i | i
Proof. Pr m times 0 j : P φ 2 < 1 δ < (1 δ)m = (1 δ)logq/log(1−δ) = q. 2
0 j
∀ k | ik − − −
(cid:2) (cid:12) (cid:3)
Now all the ingredient(cid:12)s for wrapping up the argument are at hand; first consider f L. Let S :=
∈
s : f(x) = f(x s) x be the set of all “Simon promises” of f, and S⊥ := z : z s = 0 s S
{ ⊕ ∀ } { · ∀ ∈ }
the vectors that are orthogonal to all such promises. By Lemma 4.11 the nonzero z computed by the
algorithm lie in S⊥ and are linearly independent, therefore after dimS⊥ rounds of the main loop, we
measure z = 0 with certainty. Since f L, dimS > 0 and thus dimS⊥ < n.
∈
If f is ǫn-far from being in L, then by Lemma 4.14 f is ǫn-far from being close to a function
for which a k < n and z , ... , z exist so that f is constant when restricted to D for any of the
1 k c
c 0,1 k. Therefore, by Lemma 4.13 case 2, for all k < n, P ψ 2 < 1 ǫ2/2. Thus, Lemma 4.15
0
∈ { } k | ik −
guarantees that we accept with probability at most 1/3 if we let q = 1/(3n) and thus m 2(logn)/ǫ2.
≤ 2
5 Quantum Lower Bounds
In this section we prove that not every language has a quantum property tester.
Theorem 5.1 Most properties containing 2n/20 elements of 0,1 n require quantum property testers
{ }
using Ω(n) queries.
Proof. Fix n, a small ǫ, and a quantum algorithm A making q := n/400 queries. Pick a property
P as a random subset of 0,1 n of size 2n/20. Let P := y : d(x,y) < ǫn for some x P ; using
ǫ
ǫn n 2H(ǫ)n whereH{(ǫ)}= ǫlogǫ (1 ǫ)log(1 ǫ),w{eobtain P 2(1/20+H(ǫ))n.∈Ino}rderfor
k=0 k ≤ − − − − | ǫ|≤
PA to te(cid:0)st(cid:1)properties of size 2n/20, it needs to reject with high probability on at least 2n 2(1/20+H(ǫ))n
−
inputs; but then, the probability that A accepts with high probability on a random x 0,1 n is
∈ { }
bounded by 2(1/20+H(ǫ))n/2n and therefore the probability that A accepts with high probability on P
| |
random inputs is bounded by 2−(1−1/20−H(ǫ))n|P| = 2−2n/20+Θ(logn).
We would like to sum this success probability over all algorithms using the union bound to argue
thatformostpropertiesnoalgorithmcansucceed. However,thereisanuncountablenumberofpossible
quantum algorithms with arbitrary quantum transitions. But by Beals, Buhrman, Cleve, Mosca, and
deWolf[BBC+98],theacceptanceprobabilityofAcanbewrittenasamultilinearpolynomialofdegree
atmost2q wherethenvariablesarethebitsoftheinput;usingresultsofBennett,Bernstein,Brassard,
and Vazirani [BBBV97] and Solovay and Yao [SY96], any quantum algorithm can be approximated by
anotheralgorithm suchthatthecoefficients ofthepolynomialsdescribingtheacceptingprobabilityare
integers of absolute value less than 2nO(1) over some fixed denominator. There are less than 2nH(2q/n)
degree 2q polynomials in n variables, thus we can limit ourselves to 2nO(1)2nH(2q/n) 22n/20·91/100+Θ(logn)
≤
algorithms.
Thus, by the union bound, for most properties of size 2n/20, no quantum algorithm with q queries
will be a tester for it. 2
8
We also give an explicit natural property that requires a large number of quantum queries to test.
Theorem 5.2 The range of a d-wise independent pseudorandom generator requires (d+1)/2 quantum
queries to test for any odd d n/logn 1.
≤ −
We will make use of the following lemma:
Lemma 5.3 (see [ABI86]) Suppose n = 2k 1 and d = 2t+1 n. Then there exists a uniform
− ≤
probability space Ω of size 2(n+1)t and d-wise independent random variables ξ , ... , ξ over Ω each
1 n
of which takes the values 0 and 1 with probability 1/2.
The proof of Lemma 5.3 is constructive and the construction uniform in n; for given n and d, consider
thelanguageP ofbitstringsξ(z) := ξ (z)...ξ (z)foralleventsz Ω = 1,... ,2(n+1)t . Classically,
1 n
∈ { }
deciding membership in P takes more than d queries: for all d positions i , ... , i and all strings
1 d
v ...v 0,1 d there is an z such that ξ (z)...ξ (z) = v ...v . On the other hand, log Ω +1=
1 d ∈ { } i1 id 1 d ⌊ | |⌋
O(dlogn) queries are always sufficient.
Proof of Theorem 5.2. A quantum computer deciding membership for x 0,1 n in P := ξ(z) :
∈ { } {
z Ω with T queries gives rise to a degree 2T approximating (multilinear n-variable) polynomial
∈ }
p(x) = p(x ,... ,x ) (see [BBC+98].) We show that there must be high-degree monomials in p by
1 n
comparing the expectation of p(x) for randomly chosen x 0,1 n with the expectation of p(x) for
∈ { }
randomly chosen x P.
∈
For uniformly distributed x 0,1 n, we have E[p(x)x P] 2/3 and E[p(x)x / P] 1/3.
∈ { } | ∈ ≥ | ∈ ≤
Since of P = o(2n), E[p(x)] 1/3 + o(1) and thus ∆ := E[p(x)x P] E[p(x)] 1/3 o(1).
| | ≤ | ∈ − ≥ −
Considering p(x) = α m (x) as a linear combination of n-variable multilinear monomials m , we
i i i i
have by the linearityPof expectation E[p(x1,... ,xn)] = iαiE[mi(x1,... ,xn)]. Because of the d-wise
independenceofthebitsofanyx P,foranymi ofdegrPeeatmostdholdsE[mi(x)] = E[mi(x)x P].
∈ | ∈
Since ∆ >0, p must comprise monomials of degree greater than d. Hence, the number of queries T is
greater than d/2.
This proof extends in a straightforward manner to the case of testing the property P: let again
P := y : d(x,y) < ǫn for some x P . Then P 2H(ǫ)n P = O(2H(ǫ)n+dlogn), so E[p(x)] =
ǫ ǫ
{ ∈ } | | ≤ | |
P /2nE[p(x)x P ]+(1 P )/2nE[p(x)x / P ] 1/3+o(1) for any d = n/logn ω(1/logn)
ǫ ǫ ǫ ǫ
| | | ∈ −| | | ∈ ≤ −
and any ǫ with H(ǫ) = 1 ω(1/n). 2
−
6 Further Research
Our paper opens the door to the world of quantum property testing. Several interesting problems
remain including
Can one get the greatest possible separation of quantum and classical property testing, i.e., is
•
there a language that requires Ω(n) classical queries but only O(1) quantum queries to test?
Are there other natural problems that do not have quantum property testers? We conjecture
•
for instance that the language uuvv :u,v Σ∗ does not have a quantum property tester.
{ ∈ }
Beals, et. al. [BBC+98] observed that any k-query quantum algorithm gives rise to a degree-2k
•
polynomial in the input bits, which gives the acceptance probability of the algorithm; thus, a
quantum property tester for P gives rise to a polynomial that is on all binary inputs between 0
and 1, that is at least 2/3 on inputs with the property P and at most 1/3 on inputs far from
having thepropertyP. Szegedy [Sze99] suggested to algebraically characterize thecomplexity of
classical testing by the minimum degree of such polynomials; as mentioned in the introduction,
ourresultsimplythatthiscannotbethecaseforclassicaltesters. However, itisanopenquestion
whether quantum property testing can be algebraically characterized in this way.
9
We hope that further research will lead to a greater understanding of what can and cannot be tested
with quantum property testers.
Acknowledgments
We thank Ronitt Rubinfeld for discussions and pointers on property testing.
References
[ABI86] N. Alon, L. Babai, and A. Itai. A fast and simple randomized parallel algorithm for the
maximal independent set problem. Journal of Algorithms, 7:567–583, 1986.
[AFKS99] N. Alon, E. Fischer, M. Krivelevich, and M. Szegedy. Efficient testing of large graphs.
In Proceedings of the 40th IEEE Symposium on Foundations of Computer Science, pages
656–666. IEEE, 1999.
[Alo01] N. Alon. Testing subgraphs in large graphs. In Proceedings of the 42th IEEE Symposium
on Foundations of Computer Science, pages 434–441. IEEE, 2001.
[ANKS99] N. Alon, I. Newman, M. Krivelevich, and M. Szegedy. Regular languages are testable with
a constant number of queries. In Proceedings of the 40th IEEE Symposium on Foundations
of Computer Science, pages 645–655, New York, 1999. IEEE.
[BBBV97] C. Bennett, E. Bernstein, G. Brassard, and U. Vazirani. Strengths and weaknesses of
quantum computing. SIAM Journal on Computing, 26(5):1510–1523, 1997.
[BBC+98] R. Beals, H. Buhrman, R. Cleve, M. Mosca, and R. de Wolf. Quantum lower bounds by
polynomials. In Proceedings of the 39th IEEE Symposium on Foundations of Computer
Science, pages 352–361. IEEE, New York, 1998.
[BH97] G. Brassard and P. Høyer. An exact quantum polynomial-time algorithm for Simon’s
problem. InProceedings of the 5th Israeli Symposium on Theory of Computing and Systems
(ISTCS’97), pages 12–23, 1997.
[BLR93] M. Blum, M. Luby, and R. Rubinfeld. Self-testing and self-correcting programs, with
applications to numerical programs. Journal of Computer and System Sciences, 47:549–
595, 1993.
[BV97] E. Bernstein and U. Vazirani. Quantum complexity theory. SIAM Journal on Computing,
26(5):1411–1473, 1997.
[EKK+00] F. Ergu¨n, S. Kannan, S. Kumar, R. Rubinfeld, and M. Vishwanathan. Spot-checkers.
Journal of Computer and System Sciences, 60(3):717–751, 2000.
[Fis01a] E. Fischer. Testing graphs for colorability properties,. In Proceedings of the 12th ACM-
SIAM SODA, pages 873–882. ACM, 2001.
[Fis01b] E. Fischer. Testing of matrix properties,. In Proceedings of the 33rd ACM STOC, pages
286–295. ACM, 2001.
[GGR98] O. Goldreich, S. Goldwasser, and D. Ron. Property testing and its connection to learning
and approximation. Journal of the ACM, 45(4):653–750, 1998.
[Gol98] O. Goldreich. Combinatorial property testing (a survey), 1998. Manuscript.
10