New quantum lower bound

method, with applications to

direct product theorems
Andris Ambainis, U. Waterloo
Robert Spalek, CWI, Amsterdam
Ronald de Wolf, CWI, Amsterdam
Query model
Input x
1
, , x
N
accessed by queries.
Complexity = the number of queries.
0 1 0 0
...
x
1
x
2
x
N
x
3
i
0
i
x
i
Grover's search
Is there i such that x
i
=1?
Queries: ask i, get x
i
.
Classically, N queries required.
Quantum: O(\N) queries [Grover, 1996].
Speeds up any search problem.
0 1 0 0
...
x
1
x
2
x
N
x
3
Quantum counting [Boyer et
al., 1998]
Is the fraction of i:x
i
=1 more than +c or
less than -c ?

Classical: queries.

Quantum: queries.
0 1 0 0
...
x
1
x
2
x
N
x
3
|
.
|

\
|
O
2
1
c
|
.
|

\
|
c
1
O
Element distinctness
Are there i, j such that i=j but x
i
=x
j
?
Classically: N queries.
Quantum: O(N
2/3
).
3 1 17 5
...
x
1
x
2
x
N
x
3
Lower bounds
Search requires O(\N) queries [Bennett
et al., 1997].
Counting: O(1/c) [Nayak, Wu, 1999].
Element distinctness: O (N
2/3
) [Shi,
2002].

Lower bound methods
Adversary: analyze algorithm, prove it is
incorrect on some input.
Polynomials: describe algorithm by low
degree polynomial.
Which method?
Problem Adversary Polynomials
Search Yes Yes
Counting Yes Yes
Element dist. ? Yes
Limits of adversary method
Certificate for f on input (x
1
, x
2
, , x
N
):
set of variables x
i
which determine
f(x
1
, x
2
, , x
N
).
Search: is there i:x
i
=1?

0 1 0 0
...
x
1
x
2
x
N
x
3
Limits of adversary method
Certificate for f on input (x
1
, x
2
, , x
N
):
set of variables x
i
which determine
f(x
1
, x
2
, , x
N
).
Search: is there i:x
i
=1?

0 0 0 0
...
x
1
x
2
x
N
x
3
Certificate complexity
C
x
(f): the size of the smallest certificate
for f on the input x.





) ( max ) (
0 ) ( : 0
f C f C
x x f x =
=
) ( max ) (
1 ) ( : 1
f C f C
x x f x =
=
Search: C
0
=N, C
1
=1.
Limits of adversary method
Theorem [Spalek, Szegedy, 2004]
Any quantum adversary lower bound is
at most

( ) N f C f C O - )) ( ), ( min(
1 0
Example:element distinctness
Are there i, j:x
i
= x
j
?
1-certificate: {i, j}, x
i
= x
j.

Adversary bound:
Actual complexity: O(N
2/3
).

( ) ( ) N O N O = - 2
3 1 17 5
...
x
1
x
2
x
N
x
3
Example: triangle finding
Graph G, specified by N
2
variables x
ij
:
x
ij
=1, if there is edge between i and j.
Does G contain a triangle?
1-certificate:{ij, jk, ik}, x
ij
= x
ik
= x
jk
=1.
Adversary lower bound: at most


The best algorithm: O(N
1.3
) [MSS 03].
( ) ( ) N O N O = -
2
3
Previous adversary method
Quantum query model
Fixed starting state.
U
0
, U
1
, , U
T
independent of x
1
, x
2
,
, x
N
.
Q queries.
Measuring final state gives the result.
U
0
Q Q
start

U
1
U
T

Queries
Basis states for algorithms workspace:
|i, z), ie{1, 2, , N}.
Query transformation:

Example:
|i, z)|i, z), if x
i
=0;
|i, z)-|i, z), if x
i
=1;
z Q i z i Q
i
x
= ,
| )
Adversary framework
Quantum
algorithm A
x
1
x
2
x
N
N x x N
x x x Q x x x
N
... ...
2 1 ... 2 1
1

Two registers: H
A
, H
I
.
Query Q:

Example:Grover search
Start state: |
start
)|
0
),


End state

( ) 1 ... 00 ... 0 ... 01 0 ... 10
1
0
+ + + =
N

( ) 1 ... 00 ... 0 ... 01 2 0 ... 10 1

1
N
N
+ + +
Density matrices
Measure H
A
, look at density matrix of H
I

|
|
|
|
|
|
|
.
|

\
|
=
N
N
N
end
1
0 0
0
1
0
0 0
1

o
|
|
|
|
|
|
|
.
|

\
|
=
N N N
N N N
N N N
start
1 1 1
1 1 1
1 1 1

o
Density matrices
Sum of off-diagonal entries.
N(N-1) entries.
Sum for starting state:
Sum for end state: 0.
Query changes the sym by at most 2\N.
O(\N) queries needed.
1
1
) 1 ( = N
N
N N
Limits of this approach
(o
end
)
x, y
measures the possibility of
distinguishing x from y.
If every (o
end
)
x, y
small, we can, given x,
y: f(x) =f(y), distinguish x from y.
Limits of this approach
It might be that:
Every x can be
distinguished from
every y;
There is no
measurement that
distinguishes all x from
all y.
f(x)=0 f(y)=1
Adversary method fails
quantum algorithm
New method
K-fold search
K items i:x
i
=1, find all of them.
O(\NK) queries: O(\N/K) for each item.
This is optimal.

0 1 0 0
...
x
1
x
2
x
N
x
3
Direct product theorem
Theorem [KSW 04] Solving K-fold
search with success probability c
-K
, c>1
requires c\NK queries.
Easy to prove for success probability c.
Difficult for probability c
-K
.
Why is this useful????
Application:sorting
Theorem [KSW04] A quantum algorithm
for sorting x
1
, x
2
, , x
N
with S qubits of
workspace must use


queries.
|
|
.
|

\
|
O
S
N
5 . 1
Proof
Divide algorithm into stages: first K
items sorted, next K items sorted,
Suffices to show each stage requires
O(\NK) queries.
Each stage reduces to K-fold search.
Proof
At the beginning of i
th
stage, we get S
qubits from the previous stage.
Theorem K-fold search requires O(\NK)
queries, even if we allow K/C qubits of
advice.
Proof
Theorem K-fold search requires O(\NK)
queries, even if we allow K/C qubits of
advice.
Proof Replace advice by completely
mixed state.
Success probability p with advice =>
Success probability p2
-K/C
, no advice.

Direct product theorem
Theorem Solving K-fold search with
success probability c
-K
, c>1 requires
c\NK queries.
[KSW 04]: proof by polynomials
method.
This talk: (new) adversary method.
Proof sketch
Know-0, Know-1, , Know-k
states.
Describe quantum state as

=

K
j
j
j Know p
0
" "
| )
Proof
Adversary framework



Start state for input:

= = K x i
N
i
x x x
| } 1 : { |
2 1

Quantum
algorithm A
x
1
x
2
x
N
Proof
State of H
I
if we know




Subspace T
j
spanned by all

= = =
= =
=
1 ...
| } 1 : { |
2 1 ...
1
1
j
i i
i
j
x x
K x i
N i i
x x x
1 ...
1
= = =
j
i i
x x
j
i i ...
1

Proof
T
0
_T
1
_ _ T
K
.
T
0
starting state.
T
K
entire H
I
.

T
0
T
1
. T
K
T
j
know at-most j subspace
Proof
S
j
=T
j
(T
j-1
)

.
T
0
T
1
T
K
Proof
S
j
=T
j
(T
j-1
)

.
T
0
S
1
S
K
S
j
is know-j subspace.

Proof
|+) - state of algorithm including the
input register |x
1
x
N
).


|+
j
) belongs to H
A
S
j
.
Probability of know-j:





,
0

=
+ = +
K
j
j
2
j j
p + =
Proof
Start state: p
0
=1, p
1
==p
K
=0.
Change in one query:



After c\NK queries, p
K/2+1
, , p
K
are
exponentially small.
Success probability exponentially small.

( )
1 1 1
'
+ + +
+ + s
j j j j
p p
N
K
c p p
Threshold functions
F(x
1
, x
2
, , x
N
)=1 if x
i
=1 for at least t
values ie{1, 2, , N}.
F(x
1
, x
2
, , x
N
)=0 if x
i
=1 for at most t-1
values ie{1, 2, , N}.
Query complexity: O(\Nt).

0 1 0 0
...
x
1
x
2
x
N
x
3
Threshold functions
F(x
1
, x
2
, , x
N
)=1 if x
i
=1 for at least t
values ie{1, 2, , N}.
F(x
1
, x
2
, , x
N
)=0 if x
i
=1 for at most t-1
values ie{1, 2, , N}.
Query complexity: O(\Nt).

0 1 0 0
...
x
1
x
2
x
N
x
3
Threshold functions
K instances of threshold function.
O(K\Nt) queries.
Theorem Solving all K instances with
probability at most c
-K
requires cK\Nt
queries.
Proof
K input registers.
Each input register initially ,
|
0
), |
1
) - uniform over |x
1
x
N
) with
t-1 and t values i:x
i
=1.


1 0
+
Algorithm
1 1
2
1
1 N
x x x
K
N
K K
x x x
2 1

Proof
For each instance, states solved,
know-0, know-1, know-(t-1).
For K instances, vector of K states.
Progress of a state:
solved progress t/2.
know-t/2, know-(t-1) progress t/2.
know-j, j<t/2 progress j.

Proof
If progress of final state less than tK/4, the
probability of getting all K correct answers is
c
-K
.
Decompose current state


Potential function

=
j
j
j progress p " " o
( ) ,

=
j
j
j
q p P o
tN
q
1
1+ =
Proof
Start state: P(o)=1.
For p
j
, j>tK/4 to be more than c
-K
,


One query increases P(o) by at most a
factor of
( )

=
j
j
j
q p P o
( )
K tK K
C q c P > >
4 /
o
|
.
|

\
|
+
tN
O
1
1
Proof
F(x
1
, x
2
, , x
N
)=0, know-j:



F(x
1
, x
2
, , x
N
)=1, know-j:

= = =
= =
=
1 ...
1 | } 1 : { |
2 1
0
1
. . .
1
j
i i
i
j
i i
x x
t x i
N
x x x

= = =
= =
=
1 ...
| } 1 : { |
2 1
1
1
. . .
1
j
i i
i
j
i i
x x
t x i
N
x x x
Proof
Starting state:

Solved:


Know-j


1 0
+
1 0
. . .
1
. . .
1 j
i i
j
i i

1 0
. . .
1
. . .
1 j
i i
j
i i
+
Application: testing linear
inequalities
a
ij
known, x
i
, b
j
accessed by queries.
Which inequalities are true?

> + + +
> + + +
N N NN N N
N N
b x a x a x a
b x a x a x a

2 2 1 1
1 1 2 12 1 11
Our result
Memory limited to S (qu)bits.
Classically: O(N
2
/S) queries.
Quantum: O(N
3/2
t
1/2
/S
1/2
) queries.
Lower bound follows from threshold function
lower bound.

> + + +
> + + +
N N NN N N
N N
b x a x a x a
b x a x a x a

2 2 1 1
1 1 2 12 1 11
Conclusion
New quantum lower bound method, by
eigenspace analysis.
Direct product theorems for K-fold
search and threshold functions.
Consequences for time-space tradeoffs.
More details
A. Ambainis. A new quantum lower
bound method, with application to
direct product theorem for search,
quant-ph/0508200.
A. Ambainis, R. Spalek, R. de Wolf,
Quantum direct product theorems for
symmetric functions and time-space
tradeoffs , quant-ph/0511200.
Open problems
AND-OR tree: best
lower bound O(\N),
N number of
variables.
Algorithm: O(N
.753
).
x
1
x
2
x
3
x
4
AND
OR OR
Adversary lower
bound for element
distinctness?