12 3

45 6

7

8

910

111213

1415161718

1 2 3 45

6

78

9101112

1314

15161718

Lower Bounds for Local Search by Quantum Arguments

Scott Aaronson

UC Berkeley IAS

Quantum Generosity…

Giving back because we careTM

Can quantum ideas help us prove new classical results?

Examples:Kerenidis & de Wolf 2003Aharonov & Regev 2004

LOCAL SEARCHGiven 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

5

4

4

3

2

ResultsFirst 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/2n)

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?

Santha & Szegedy, this STOC

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

So interesting graphs are of intermediate connectedness…

Line Graph on N VerticesO(log N) deterministic queries suffice

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 queries (d = maximum degree)

O Nd

Query vertices uniformly at random

Nd

Quantumly, O(N1/3d1/6) queries suffice

In the above algorithm, find v using Grover search

43

35

29

13

48

17

4

22

9

30

32

1

Let v be the queried vertex for which f(v) is minimal

Follow v to a local minimum by steepest descent

Ambainis’ Quantum Adversary Theorem

Then the number of quantum queries needed to separate 0- from 1-inputs w.h.p. is (1/p), where

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.

, , : , 0,max , ,

A B x R A B A x B xp A x B x

Example: Inverting a Permutation

R(,)=1 if is obtained from by a swap, R(,)=0 otherwise

4 5 1 7 2 3 8 6but (,x)=2/N

Decide whether ‘1’ is on left half (0-input) or right half (1-input)

2max , ,x x

N

so (N) quantum queries needed

(,x)=1

Statement is identical, except

is replaced by

Proof Idea: Show that each query can separate only so many input pairs

We prove an analogue of the quantum adversary theorem for classical randomized query complexity

min , , ,A x B x , ,A x B x

Yields up to quadratically better bound—e.g. (N) instead of (N) for permutation problem

0-in

pu

ts

1-inp

uts

To apply the lower bound theorems to LOCAL SEARCH, we use “snakes”

12 3

45 6

7

8

910

111213

1415161718

Known “head” vertex

Unique local minimum of fAll vertices of G

not in the snake just lead to the

head To get a decision problem, we put an “answer bit” at the local minimum

b{0,1}

Length N

12 3

45 6

7

8

910

111213

15161718

Given a 0-input f, how do we create a random 1-input g that’s “close” to f?

14

Choose a “pivot” vertex uniformly at random on the snake

Given a 0-input f, how do we create a random 1-input g that’s “close” to f?

1 2 3 45

6

78

9101112

1314

15161718

Starting from the pivot, generate a new “tail” using (say) a random walk

Handwaving ArgumentFor all vertices vG, either (f,v) or (g,v) should be at most ~1/N (as in the permutation problem)

Quantum lower bound:

Randomized lower bound: 1

min , , ,N

f v g v

1/ 41

, ,N

f v g v

f

g

(f,v)=1 but (g,v)1/N

(g,v)=1 but (f,v)1/N

The Nontrivial Stuff

Need to prevent snake tails from intersecting, spending too much time in one part of the graph, …

(1) Generalize quantum adversary method to work with most inputs instead of all

Solutions:

The Nontrivial Stuff

Need to prevent snake tails from intersecting, spending too much time in one part of the graph, …

(2) Use a “coordinate loop” instead of a random walk.It mixes faster and has fewer self-intersections

Solutions:

What We Get

For Boolean hypercube {0,1}n:

For d-dimensional cube N1/dN1/d (d3):

/ 2

2

2n

n

/ 42n

n

randomized, quantum

1/ 2 1/

log

dN

N

1/ 2 1/

log

dN

N

randomized, 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”