1. Quantum algorithms for evaluating Boolean formulas
Andris Ambainis
University of Latvia
(joint work with Andrew Childs, Ben Reichardt, Robert Spalek, Shengyu Zhang)

2. AND-OR tree OR
AND
AND OR OR OR OR x1 x2 x5 x6 x3 x4 x7 x8

3. Evaluating AND-OR trees
Variables xi accessed by queries to a black box:
Input i;
Black box outputs xi.
Quantum case:
Evaluate T with the smallest number of queries.
AND OR OR x1 x2 x3 x4

4. Motivation How well can we play chess if we only
Vertices = chess positions;
Leaves = final positions;
xi=1 if the 1st player wins;
At internal vertices, AND/OR evaluates whether the player who makes the move can win. OR x1 x2
How well can we play chess if we only
know the position tree?

5. Results Full binary tree of depth d. N=2d leaves. Deterministic: (N).
Randomized [SW,S]: (N.753…).
Quantum?
Easy q. lower bound: (N).
AND OR OR x1 x2 x3 x4

6. NAND trees ANDs, ORs can be replaced by NANDs x1 x2 x3 x4 AND OR OR x1
NOT
NAND x1 x2 x3 x4
AND OR OR x1 x2 x3 x4
ANDs, ORs can be replaced by NANDs

7. New results:
[Farhi, et al.]:O(N) time algorithm for NAND trees in Hamiltonian query model.

8. [Farhi, Goldstone, Gutmann]:1
Infinite line in two directions …

9. [Farhi, Goldstone, Gutmann]:
Basis states |v, v – vertices of augmented tree.
Hamiltonian H, H-adjacency matrix of augmented tree. … …

10. [Farhi, Goldstone, Gutmann]:
Starting state | on the infinite line left of tree.
Apply Hamiltonian H for O(N) time.
If T=1, the new state is on the right (transmission).
If T=0, the new state is on the left (reflection). … …

11. Improvements to FGG
A. Childs, B. Reichardt, R. Spalek, S. Zhang. arXiv:quant-ph/
A. Ambainis, arXiv:

12. Improvement I Quantum algorithm for unbalanced trees. NAND NAND NANDx1 x2
NAND
NAND x5 x6 x3 x4
Quantum algorithm for unbalanced trees.

13. Improvement II [Farhi, Goldstone, Gutmann]:
O(N) time Hamiltonian quantum algorithm
O(N1/2+o(1)) query quantum algorithm
We will design discrete query algorithm directly.
Why do we need that???

14. Motivation How well can we play chess if we only
Vertices = chess positions;
Leaves = final positions;
xi=1 if the last player loses;
At internal vertices, NAND evaluates whether the player who makes the move can win.
NAND x1 x2
How well can we play chess if we only
know the position tree?

15. Motivation Hamiltonians: Game tree: Inherently discrete time problem
We can perform H for arbitrarily small time >0.
Game tree:
Query = evaluating a final position, phase shift by –1 conditional on the result.
Performing a smaller phase shift is not easier!
Evaluating a position takes the same time.
Inherently discrete time problem

16. Improvement III
FGG algorithm seems very different from the previous algorithms.
We relate it to search, amplitude amplification and quantization of Markov chains.
Better understanding of FGG.

17. [Farhi, Goldstone, Gutmann]:
Infinite line in two directions …

18. The finite tail [Childs et al.]:…
Finite “tail” in one direction

19. Finite tail algorithm Starting state: Hamiltonian H,1 -1
Starting state:
Hamiltonian H,
H – adjacency matrix …

20. What happens? If T=0, the state stays almost unchanged.
If T=1, the state scatters into the tree.

21. More formally…
If T=0, there is a state | with H|=0 and ||start.
If T=1, then for every |, H|=|, either >1/N or ||start.

22. Eigenvalue estimation
Algorithm that, given a state |, H|=|, outputs an estimate of  within  by running H for time O(1/).
In our case = 1/N.
Time O(N) in Hamiltonian model, for the balanced NAND tree (same as [FGG]).
Same result, different intuition

23. The next steps Discrete query algorithm.
Algorithm for computing arbitrary NAND formulas.

24. From Hamiltonians to unitaries
H1 – extra edges for xi=1
H=H0+H1
H0- NAND formula

25. From Hamiltonians to unitaries
Replace H0, H1 by unitary transformations U0, U1.
Instead of estimating the eigenvalue of H=H0+H1, estimate the eigenvalue of U=U1U0.

26. Designing U0 Input-independent part of tree.
Define U0|=| if H0|=0.
Define U0|=-| if H0|=|, 0.
H0- adjacency matrix.
0 queries required.

27. Designing U1 No extra edges.
Define U1|v = -|v if v - leaf with xi=1.
Define U1|v = |v otherwise.
1 query

28. Results (balanced case)
If T=0, there is a state | with U1U0|=| and ||start.
If T=1, then for every |, U1U0|=ei|, either >1/N or ||start.
Eigenvalue estimation,
O(N) repetitions of U1U0
O(N) queries

29. Structure of our algorithm
Transformation U1U0.
U0|=-| if H0|=|, 0.
U1|v = -|v if v - leaf with xi=1.
U0, U1 leave vectors unchanged or map them to their opposites.
U0, U1 - reflections
Same as in Grover’s algorithm

30. Two reflections in 2D
Rotation by 2 
Eigenvalues: ei

31. Our algorithm Eigenvalues: ei, >1/N
The entire state space can be decomposed into two dimensional subspaces.
Need to prove: if T=1, the angle between the two bases is >1/N in each subspace.
Eigenvalues: ei, >1/N

32. Our algorithm
Angle => length of projection.
sin  

33. Our algorithm Need to prove: if T=0, there exists |, H|=0,
S – subspace spanned by |v, xi=1.

34. Our algorithm Need to prove: if T=1, then, for any |, H|=0,
S – subspace spanned by |v, xi=1.

35. Computing arbitrary NAND formulas

36. Arbitrary NAND formulas
H0- weighted adjacency matrix:
1s are replaced by positive weights that depend on tree structure.
Define U0|=-| if H0|=|, 0.

37. Results (general trees)
Similar but more complicated analysis.
O(Nd) query algorithm.
What if d is large??

38. [Bshouty, Cleve, Eberly, 91]
Theorem Let F be a formula of size S, depth d. There is a formula F’, F=F’,
Size(F’)=O(S1+), Depth(F’)=O(log S).
Size(F’)= , Depth(F’)=
O(N1/2+) quantum algorithm for any
formula F

39. Summary O(N) query quantum algorithm for balanced NAND trees.
O(Nd) query quantum algorithm for any depth-d NAND tree.
query quantum algorithm
for any NAND tree.

40. Implications for Boolean formulas
Any Boolean formula of size S can be evaluated with queries.

41. [Lee et al., 2005]:
If “quantum adversary” method shows that a Boolean function requires S queries in quantum query model, the classical formula size is S2.
Not a coincidence: smaller formula can be converted into a quantum algorithm with less than S queries!

42. Two reflections strike again
[Aharonov, 98]: Analysis of Grover’s algorithm;
Other applications:
Amplitude amplification.
Quantization of Markov chains.
Now: NAND formulas.