Lower Bounds for Local Search by Quantum
Arguments
Scott Aaronson (UC Berkeley)
http://www.cs.berkeley.edu/~aaronson
August 14, 2003
Outline• Problem: Find a local minimum of a
function using as few function evaluations (queries) as possible
• Relational adversary method: A quantum method for proving quantum and classical lower bounds on query complexity (only other example: Kerenidis and de Wolf 2003)
• Applying the method to LOCAL SEARCH
• Open problems
The LOCAL SEARCH Problem• Given: undirected connected graph
G=(V,E) and function• Task: Find a vV such that
for all neighbors w of v
:f V f v f w
33
43
3
3
2
Motivation• Why do local search algorithms work so well in
practice?
• Conventional wisdom: Because finding a local optimum is intrinsically not that hard
• We show this is false—even for quantum computers
• Raises a question: Why do exponentially long chains of descending values, as used for lower bounds, almost never occur in “real-world” problems?
Motivation #2• Quantum adiabatic algorithm (Farhi et al.):
Quantum analogue of simulated annealing
• Can sometimes “tunnel” through barriers to reach global instead of local optima
• Further strange feature: For function f(x)=|x| on Boolean hypercube {0,1}n, finds minimum 0n in O(1) queries, instead of O(n) classically
• We give first example where adiabatic algorithm is provably only polynomially faster than simulated annealing at finding local optima
Motivation #3• Megiddo and Papadimitriou defined a complexity
class TFNP, of NP search problems for which we know a solution exists
• Example: Given a circuit that maps {0,1}n to {0,1}n-1, find two inputs that map to same output
• Papadimitriou: Are TFNP problems good candidates for fast quantum algorithms?
• My answer: Probably not– Collision lower bound (A 2002): PPP FBQP relative
to an oracle (PPP = Polynomial Pigeonhole Principle, FBQP = Function Bounded-Error Quantum Polytime)
– This work: PLS FBQP relative to an oracle (PLS = Polynomial Local Search)
Deterministic Query Complexity of LOCAL SEARCH
• Depends on graph G
• For an N-vertex line, (log N)
5 4 7 96
• Similar for complete binary tree
Deterministic Lower Bound
Oracle returns decreasing values of f(v), until the set of queried vertices cuts G into 2 pieces
Then oracle restricts the problem to largest piece“Cuttability” tightly characterizes query complexity
8
7
5
6
24
3
1
• Llewellyn, Tovey, Trick :(2n/n) for Boolean hypercube {0,1}n
Randomized Query Complexity• for any graph with N vertices and max
degree d• Steepest descent algorithm:
- Choose vertices uniformly and query them- Let v0 be queried vertex with minimum f- Repeatedly let vt+1 be minimum neighbor of vt, until local min is found
• Claim: Local min is found when whp• Proof: At most vertices have smaller f-
value than v0 whp. In that case distance from v0 to local min in “steepest descent tree” is at most
O Nd
Nd
/t O N d
/N d
/N d
Randomized Lower Bound
Random walk mixes in n log n stepsIf you haven’t yet found a v with
f(v)<2n/2, intuitively the best you can do is continue “stabbing in the dark”
Hard to prove!1 2
3
56
8
1213
• Aldous 1983: 2n/2-o(n) for hypercube • Idea: Pick random start vertex, then take random
walk. Label each vertex with 1st hitting time
Quantum Query Complexity• O((Nd)1/3) for any graph with N vertices and max
degree d
• Choose (Nd)2/3 vertices uniformly at random
• Use Grover’s quantum search algorithm to find the
v0 with minimum f-value in time
• As before, follow v0 to local min by steepest descent
2/3 1/3O Nd O Nd
A: Set of 0-inputs B: Set of 1-inputsChoose a function R(f,g)0For all fA, gB, and indices v, let
Ambainis’ Adversary Method“Most General” Version
' : ' ' : '
' '
, ' ',
, , , ., ' ',
g B f v g v f A f v g v
g B f A
R f g R f g
f v g vR f g R f g
, , : , 0,max , , .geom
f A g B v R f g f v g vf v g v
Then quantum query complexity is (1/geom) where
Example: (N) for Inverting a Permutation
3 1 5 6 24
3 4 5 6 21
Let A = set of permutations of {1,…,N} with ‘1’ on left half, B = set with ‘1’ on right half
R(f,g)=1 if g obtained from f by swapping the ‘1’, R(f,g)=0 otherwise
f
g(f,2)=1, but (g,2)=2/N (g,6)=1, but (f,6)=2/N
, , : , 0,
2max , ,geom
f A g B v R f g f v g vf v g v
N
Compare to
Relational Adversary Method
min
, , : , 0,max min , , , .
f A g B v R f g f v g vf v g v
Let A, B, R(f,g), (f,v), (g,v) be as before
Then classical randomized query complexity is (1/min) where
, , : , 0,max , , .geom
f A g B v R f g f v g vf v g v
Example: For inverting a permutation, we get (N) instead of (N)
New Lower Bounds for LOCAL SEARCH
On Boolean hypercube {0,1}n:• quantum queries• randomized queries
On d-dimensional cube of N vertices (d≥3):
• quantum queries
• randomized queries
/ 42n
n
/ 2
2
2n
n
1/ 2 1/
log
dN
N
1/ 2 1/
log
dN
N
Modified Problem
Starting from the head, follow a “snake” of LN descending values to the unique local minimum of f, then return an answer bit found there. Clearly a lower bound for this problem implies an equivalent lower bound for LOCAL SEARCH
65
43
21
7
7
8
8
89
910 11
9
9 1011
1213
10
(Known) Snake Head
Snake Tail (contains binary answer)
10 11
1112
G
Let D be a distribution over snakes (x0,…,xL-1), with xL-1=h and xi+1 adjacent to xi for all i
We say an X drawn from D is -good if the following holds. Choose j uniformly from {0,…,L-1}, and let DX,j be the distribution over snakes Y=(x0,…,xL-1) drawn from D conditioned on xt=yt for all t>j. Then
(1)
(2) For all vertices v of G,
Good Snakes
,,
9Pr min : min :
10X jt t
j Y Dt x v t y v v X Y
,
1,Pr , ,
X jj
j Y Dv y y
Theorem: Suppose there’s a snake distribution D, such that a snake drawn from D is -good with probability at least 9/10. Then the quantum query complexity of LOCAL SEARCH on G is , and the randomized is 1
.
1
4
32
1
56
7
8
9
10
11
jx0
54
3
21
6
7
8
9
10
11
y0
Large (fX,v) but small (fY,v)
Large (fY,v) but small (fX,v)
xL-1=yL-1=h
Sources of Trouble
2
13
45
6
7
8
Bunched-Up Snake
21
Snake Tails Intersect
3
4
3
21
Idea: Just remove inputs that cause trouble!
Lemma: Suppose a graph G has average degree k. Then G has an induced subgraph with minimum degree at least k/2.
Instead of Aldous’ random walk, more convenient to define snake distribution D using a “coordinate loop”
Given v{0,1}n, let v(i) = (v with ith bit flipped)
Let x0 = h, xt+1 = xt with ½ probability,xt+1 = xt
(t mod n) with ½ probability
Mixes completely in n steps
Theorem: A snake drawn from D is n2/2n/2-good with probability at least 9/10
Boolean Hypercube {0,1}n
Drawbacks of random walk become more serious: mixing time is too long, too many self-intersections
Instead define D by “struts” of randomly chosen lengths connected at endpoints
d-dimensional cube (d≥3)
Theorem: A snake drawn from D is (logN)/N1/2-1/d-good with probability at least 9/10
Open Problems• 2n/4 vs. 2n/3 gap for quantum complexity on {0,1}n
• 2n/2/n2 vs. 2n/2n gap for randomized complexity
• 2D square grid
• Conjecture: Deterministic, randomized, and
quantum query complexities are polynomially
related for every family of graphs
• Apply relational adversary method to other problems