Lower Bounds for Local Search by Quantum Arguments
description
Transcript of Lower Bounds for Local Search by Quantum Arguments
Lower Bounds for Local Search by Quantum
Arguments
Scott Aaronson (UC Berkeley)
http://www.cs.berkeley.edu/~aaronson
August 14, 2003
Quantum Background Needed for This Talk
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)
FNP
TFNP
PLS PPP
FP FBQP
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