Lower Bounds for Local Search by Quantum Arguments

1. Lower Bounds for Local Search by Quantum Arguments Scott Aaronson (UC Berkeley) http://www.cs.berkeley.edu/~aaronson August 14, 2003

2. Quantum Background Needed for This Talk

3. 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

4. The LOCAL SEARCH Problem • Given: undirected connected graph G=(V,E) and function • Task: Find a vV such thatfor all neighbors w of v 3 2 3 3 3 3 4

5. 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?

6. 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

7. 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)

8. FNP TFNP PLS PPP FP FBQP

9. 5 4 6 7 9 Deterministic Query Complexity of LOCAL SEARCH • Depends on graph G • For an N-vertex line, (log N) • Similar for complete binary tree

10. 4 2 5 3 1 6 Deterministic Lower Bound • Llewellyn, Tovey, Trick :(2n/n) for Boolean hypercube {0,1}n 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 7 8

11. 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

12. Randomized Lower Bound • Aldous 1983: 2n/2-o(n) for hypercube • Idea: Pick random start vertex, then take random walk. Label each vertex with 1st hitting time Random walk mixes in n log n steps If 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! 8 3 13 12 1 2 6 5

13. 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

14. Ambainis’ Adversary Method“Most General” Version A: Set of 0-inputs B: Set of 1-inputs Choose a function R(f,g)0 For all fA, gB, and indices v, let Then quantum query complexity is (1/geom) where

15. 3 1 5 6 2 4 3 4 5 6 2 1 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 Example: (N) for Inverting a Permutation f g (f,2)=1, but (g,2)=2/N (g,6)=1, but (f,6)=2/N

16. Relational Adversary Method Let A, B, R(f,g), (f,v), (g,v) be as before Then classical randomized query complexity is (1/min) where Compare to Example: For inverting a permutation, we get (N) instead of (N)

17. On Boolean hypercube {0,1}n: • quantum queries • randomized queries • On d-dimensional cube of N vertices (d≥3): • quantum queries • randomized queries New Lower Bounds forLOCAL SEARCH

18. 9 10 G 8 11 3 7 9 (Known) Snake Head 4 12 8 6 11 2 10 13 5 7 9 11 1 10 8 12 Snake Tail (contains binary answer) 9 11 10 Modified Problem Starting from the head, follow a “snake” of LN 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

19. Good Snakes 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,

20. 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

21. Large (fX,v) but small (fY,v) j 9 7 6 8 1 2 3 4 5 3 4 5 2 7 8 9 1 6 Large (fY,v) but small (fX,v) 10 11 y0 x0 Sensitivity 10 11 xL-1=yL-1=h

22. 8 1 2 4 7 6 3 4 3 1 2 5 Bunched-Up Snake Snake Tails Intersect 1 3 2 Sources of Trouble 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.

23. Boolean Hypercube {0,1}n 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

24. d-dimensional cube (d≥3) 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 Theorem: A snake drawn from D is (logN)/N1/2-1/d-good with probability at least 9/10

25. Open Problems • 2n/4 vs. 2n/3 gap for quantum complexity on {0,1}n • 2n/2/n2 vs. 2n/2n 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