Lower Bounds for Local
Search by Quantum
Arguments
2 3
11 4
1 12
10 5
9
14
6
18 17 16 15
13
87
12
2 3 4
87
1
11 10 9 6
5
13
Scott Aaronson
UC Berkeley  IAS
Can quantum ideas help us
prove new classical results?
Quantum Generosity…
Giving back because we
TM
care
Examples:
Kerenidis & de Wolf 2003
Aharonov & Regev 2004
LOCAL SEARCH
Given a graph G=(V,E) and oracle access to a
function f:V{0,1,2,…}, find a local minimum of
f—a vertex v such that f(v)f(w) for all neighbors
w of v. Use as few queries to f as possible
4
4
3
2
5
Results
First quantum lower bound for LOCAL SEARCH:
On Boolean hypercube {0,1}n, any quantum
algorithm needs (2n/4/n) queries to find a local min
Better classical lower bound via a quantum
argument: Any randomized algorithm needs
(2n/2/n2) queries to find a local min on {0,1}n
Previous bound: 2n/2-o(n) (Aldous 1983)
Upper bound: O(2n/2n)
First randomized or quantum lower bounds for
LOCAL SEARCH on constant-dimensional hypercubes
Main Open Problem
Are deterministic, randomized, and
quantum query complexities of LOCAL
SEARCH polynomially related for every
family of graphs?
Motivation
• Why is optimization hard? Are local optima
the only reason?
• Quantum adiabatic algorithm (Farhi et al.
2000): What are its limitations?
• Papadimitriou 2003: Can quantum
computers help solve total function problems?
PPADS
PODN
PPP
PLS
Trivial Observations
Complete Graph on N Vertices
(N) randomized queries
(N) quantum queries
Trivial Observations
Line Graph on N Vertices
O(log N) deterministic queries suffice
So interesting graphs are of intermediate
connectedness…
Boolean Hypercube {0,1}n
Aldous 1983: Any randomized algorithm needs
2n/2-o(n) queries to find local min
Proof uses complicated random walk analysis
How to find a local minimum in O  Nd 
queries (d = maximum degree)
Query Nd vertices
uniformly at random
30
22
17
13
Let v be the queried vertex
for which f(v) is minimal
Follow v to a local minimum
by steepest descent
43
29
1
2
3
9
35
48
4
Quantumly, O(N1/3d1/6) queries suffice
In the above algorithm, find v using Grover search
Ambainis’ Quantum
Adversary Theorem
Given: 0-inputs, 1-inputs, and function R(A,B)0 that
measures the “closeness” of 0-input A to 1-input B
For all 0-inputs A and query locations x, let (A,x) be
probability that A(x)B(x), where B is a 1-input
chosen with probability proportional to R(A,B).
Define (B,x) similarly.
Then the number of quantum queries needed to
separate 0- from 1-inputs w.h.p. is (1/p), where
p
max
A, B , x : R A, B 0, A x  B  x 
  A, x   B, x 
Example: Inverting a Permutation
Decide whether ‘1’ is on left half (0-input) or
right half (1-input)
(,x)=1
4 5 1 7 2 3 8 6
but (,x)=2/N
R(,)=1 if  is obtained from  by a swap,
R(,)=0 otherwise
so (N)
2
quantum queries
max   , x   , x  
N needed
We prove an analogue of the quantum adversary
theorem for classical randomized query complexity
Statement is identical, except
  A, x    B, x 
is replaced by min   A, x  ,  B, x 
1-inputs
Proof Idea: Show that each
query can separate only so
many input pairs
0-inputs
Yields up to quadratically better bound—e.g. (N)
instead of (N) for permutation problem
To apply the lower bound theorems
to LOCAL SEARCH, we use “snakes”
12 11
Known “head”
vertex
13
18 17 16 15
14
Length  N
3
2
b{0,1}
4
1
All vertices of G
not in the snake
just lead to the
head
10
Unique local
minimum of f
9
8
7
6
5
To get a decision problem, we put an
“answer bit” at the local minimum
Given a 0-input f, how do we create a
random 1-input g that’s “close” to f?
Choose a “pivot”
vertex uniformly at
random on the snake
18 17
16 15
12 11
13
14
2 3 4
1
10
9
8
7
6
5
Given a 0-input f, how do we create a
random 1-input g that’s “close” to f?
1 2 3 4
18 17
16 15
14
5
6
13
12
7
11 10 9
Starting from the pivot, generate a
new “tail” using (say) a random walk
8
Handwaving Argument
For all vertices vG, either (f,v) or (g,v) should
be at most ~1/N (as in the permutation problem)
f
(f,v)=1 but (g,v)1/N
g
(g,v)=1 but (f,v)1/N
1
 N
Randomized lower bound:
min   f , v  ,  g , v 
Quantum lower bound:
1
  f , v   g , v 
 N 1/ 4
The Nontrivial Stuff
Need to prevent snake tails from intersecting,
spending too much time in one part of the
graph, …
Solutions:
(1) Generalize quantum adversary method
to work with most inputs instead of all
The Nontrivial Stuff
Need to prevent snake tails from intersecting,
spending too much time in one part of the
graph, …
Solutions:
(2) Use a “coordinate loop”
instead of a random walk.
It mixes faster and has fewer
self-intersections
What We Get
For Boolean hypercube {0,1}n:
2 
  2  randomized,
 n 
n/2
2 

 quantum
 n 
n/4
For d-dimensional cube N1/dN1/d (d3):
N


 randomized,
 log N 
1/ 21/ d
 N 1/ 21/ d

 log N


 quantum


Conclusions
• Local optima aren’t the only reason
optimization is hard
• Total function problems: below NP, but
still too hard for quantum computers?
• “The Unreasonable Effectiveness of
Quantum Lower Bound Methods”