Lower Bounds for Local Search by Quantum Arguments Scott Aaronson (UC Berkeley) aaronson August 14, 2003.

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