Simulating Hamiltonian dynamics on a small quantum computer

Andrew Childs Department of Combinatorics & Optimization

and Institute for Quantum Computing University of Waterloo

based in part on joint work with Dominic Berry, Richard Cleve,

Robin Kothari, and Rolando Somma

“... nature isn’t classical, dammit, and if you want to make a simulation of nature, you’d better make it quantum mechanical, and by golly it’s a wonderful problem, because it doesn’t look so easy.” !Richard Feynman Simulating physics with computers (1981)

Outline• The Hamiltonian simulation problem

• Three approaches to simulation - Product formulas - Quantum walk - Fractional queries

• Comparison of methods for small-scale simulations

Hamiltonian simulation

Applications:

• Simulating physics

• Implementing continuous-time quantum algorithms (quantum walk, adiabatic optimization, linear equations, ...)

* For an efficient simulation, H should be concisely specified.

Problem: Given* a Hamiltonian H, a time t, and an error tolerance ² (say, with respect to trace distance), find a quantum circuit that performs the unitary operation e—iHt (on an unknown quantum state) with error at most ².

More generally, H can be time-dependent.

Local and sparse Hamiltonians

Sparse Hamiltonians [Aharonov, Ta-Shma 03]

At most d nonzero entries per row, d = poly(log N) (where H is N £ N)

In any given row, the location of the jth nonzero entry and its value can be computed efficiently (or is given by a black box)

Note: A k-local Hamiltonian with m terms is d-sparse with d = 2k m

Local Hamiltonians [Lloyd 96]

Hjwhere each acts on k = O(1) qubitsH =Pm

j=1 Hj

What should we simulate?Consider a two-dimensional grid of n qubits, with interactions only between nearest neighbors (at most 2n terms).

• Initialize system in a product state • Evolve for time t • Measure a local observable for each spin

This is probably hard to do with a classical computer for more than about 30 qubits.

Related question: How can we apply quantum simulation to solve computational problems in quantum chemistry, materials science, etc.? (See, e.g., the talks by Alán and Matthias.)

Overview of simulation methods

• Decompose Hamiltonian into a sum of terms and recombine by alternating between them

• With high-order formulas, complexity can be close to linear in t, but with an exponential prefactor

Product formulas

• Implement a unitary operation whose spectrum is related to the Hamiltonian; use phase estimation to adjust the eigenvalues

• Complexity is linear in t with no large prefactor; also improved dependence on sparsity

Quantum walk

• Perform a compressed simulation of a very accurate product formula

• Strictly improves over product formulas, with no large prefactors • Dependence on error is poly(log (1/²)) instead of poly(1/²)

Fractional queries

Product formulas

Simulating a sum of terms

Suppose we want to simulate H =Pm

i=1 Hi

[Lloyd 96]

�e�iAt/re�iBt/r

�r= e�i(A+B)t +O(t2/r)

Combine individual simulations with the Lie product formula:

limr!1

�e�iAt/re�iBt/r

�r= e�i(A+B)t

To ensure error at most ², take r = O�(kHkt)2/✏

�

High-order product formulas

Systematic expansions to arbitrary order are known [Suzuki 92]

With k large, this is only slightly superlinear in t. Sublinear simulation is impossible (“no-fast-forwarding theorem”).

To get a better approximation, use higher-order formulas:

...

[Berry, Ahokas, Cleve, Sanders 07]

Using the kth order expansion, the number of exponentials required for an approximation with error at most ² is at most

52km2kHkt⇣

mkHkt✏

⌘1/2k

�e�iAt/re�iBt/r

�r= e�i(A+B)t +O(t2/r)

�e�iAt/2re�iBt/re�iAt/2r

�r= e�i(A+B)t +O(t3/r2)

High-order product formulas

Choose k to minimize 52km2kHtk✓

mkHkt✏

◆1/2k

This is subpolynomial (but superlogarithmic) in 1/²; closer to polynomial (cf. best known classical factoring algorithms).

givesk ⇡ 1

2

s

log5

✓mkHkt

✏

◆O⇣m2kHkt 52

plog5(mkHkt/✏)

⌘

When does it help to use higher-order formulas?

100 104 106 108 1010 1012x

0.5

1.0

1.5

2.0

12

log5 x

Sparse Hamiltonians and coloring

Strategy [Childs, Cleve, Deotto, Farhi, Gutmann, Spielman 03; Aharonov, Ta-Shma 03]: Color the edges of the graph of H. Then the simulation breaks into small pieces that are easy to handle.

= + +

A sparse graph can be efficiently colored using only local information [Linial 87], so this gives efficient simulations.

Can produce a d2-coloring locally ) overhead of d4

Star decompositions

= +

Tradeoff vs. edge coloring: • Decomposition has fewer terms • Each term is harder to simulate (2nd neighbors)

= + +

[Childs, Kothari 10]

Strategy: Color the edges so that each color forms a “galaxy” (every component is a star graph). Simulate each galaxy by brute force and recombine.

Total overhead is d3

Quantum walk

[Berry and Childs, arXiv:0910.4157 ][Childs, arXiv:0810.0312]

Hamiltonian simulation by quantum walk

[Childs 10]

Expand space from to . CN CN+1 ⌦ CN+1

Walk operator is the product of two reflections:

• Swap: S |j, k i = |k, j ispan{| 1i, . . . , | N i}• Reflect about , where

| ji := |ji ⌦

1pkHk1

NX

k=1

qH⇤

jk |ki+ ⌫j |N + 1i!

kHk1 := maxjPN

k=1 |Hjk|

i.e., where2TT † � T |ji = | ji

Another way to simulate an Hamiltonian H is to implement a related discrete-time (Szegedy) quantum walk.

N ⇥N

Hamiltonian simulation by quantum walk

1. Apply T to the input state |Ãi.To simulate H for time t:

3. Use the estimate of arcsin ¸ to estimate ¸, and apply the phase e—i¸t.

4. Uncompute the phase estimation and T, giving an approximation of e—iHt|Ãi.

[Childs 10]

Theorem: steps of this walk suffice to simulate H for time t with error at most ² (in trace distance).

O(kHtk1/✏)

2. Perform phase estimation with , estimating a phase for the component of corresponding to an eigenvector of H with eigenvalue ¸.

U = iS(2TT † � )±e±i arcsin� T | i

Faster simulation of sparse Hamiltonians

[Berry, Childs 12]

This is exactly linear in t; also scales better in d, but worse in ².

Perform quantum walk steps by brute force (query all d neighbors):

Resulting complexity:

O

✓kHktp

✏+ dkHk

max

t

◆ O

✓dkHk

max

tp✏

◆

Improved alternative: using only two queries, prepare

| 0ji := |ji ⌦ 1p

d

NX

k=1

0

@s

H⇤jk

kHkmax

|k, 0i+

s

1� |Hjk|kHk

max

|k, 1i

1

A

kHkmax

:= maxj,k |Hjk|

O(dkHk1

t/✏) O(d3/2kHkt/✏) O(d2kHkmax

t/✏)

Fractional queries

[Berry, Childs, Cleve, Kothari, and Somma, arXiv:1312.1414]

Fractional- and continuous-query models

U0 Q|0i|0i|0i|0i|0i|0i|0i|0i

U1 Q

U0|0i|0i|0i|0i|0i|0i|0i|0i

U1Q1/2 U2Q1/2 U3Q1/2 Q1/2

U0

|0i|0i|0i|0i|0i|0i|0i|0i

U1

1/4

Q U2

1/4

Q1/4

Q U3 U4

1/4

Q U5

1/4

Q1/4

Q U6 U7

1/4

Q1/4

Q

|0i|0i|0i|0i|0i|0i|0i|0i

e�i⇡(HQ+HD)t

Useful for designing algorithms [Farhi, Goldstone, Gutmann 07]

Quantum query: Q|i, bi = (�1)bxi |i, biBlack box hides a string x 2 {0, 1}n

More powerful than the discrete query model?

No: Can simulate a t-query fractional-query algorithm with discrete queries [Cleve, Gottesman, Mosca, Somma, Yonge-Mallo 09]

O(t log tlog log t )

Simulating fractional queries

R↵ =1pc+ s

✓pc

psp

s �pc

◆c = cos

⇡↵2

s = sin

⇡↵2

P =

✓1 00 i

◆

Fractional-query gadget: |0i R↵ • P R↵ 0

Q| i ...... Q↵| i

“Segment” implementing :UmQ↵mUm�1 · · ·U1Q↵1U0

|0i R↵1 • · · · R↵1P

.... . .

...

|0i R↵m · · · • R↵mP

U0 Q U1

· · ·

Um�1 Q Um| i ...

. . .

· · ·

Behavior of a segment

By rearranging the circuit, k queries suffice

But this still only succeeds with constant probability

Truncating the ancillas to Hamming weight introduces error at most ²

k = O( log(1/✏)log log(1/✏) )

“Segment” implementing :UmQ↵mUm�1 · · ·U1Q↵1U0

|0i R↵1 • · · · R↵1P

.... . .

...

|0i R↵m · · · • R↵mP

U0 Q U1

· · ·

Um�1 Q Um| i ...

. . .

· · ·

Correcting faults

Rube Goldberg, Professor Butts and the Self-Operating Napkin

[Cleve, Gottesman, Mosca, Somma, Yonge-Mallo 09]

segment 1!

undo!

¾ !

¼!

undo!

¾ !

¼!

undo!

¾ !

¼!

¾ !

¼!

success!

fault!

segment 2!

undo!

¾ !

¼!

undo!

¾ !

¼!

undo!

¾ !

¼!

¾ !

¼!

…! ¾ !segment t

Oblivious amplitude amplification

To perform V with amplitude close to 1: use amplitude amplification?

Suppose U implements V with amplitude sin µ:

U |0i| i = sin ✓ |0iV | i+ cos ✓ |1i|�i

segment (without final measurement)

ideal evolution

With this oblivious amplitude amplification, we can perform the ideal evolution exactly with only three segments (one backward).

12

Using ideas from [Marriott, Watrous 05], we can show that a -independent reflection suffices to do effective amplitude amplification.

| i

But the input state is unknown!

Hamiltonian simulation using fractional queriesWe reduce Hamiltonian simulation to fractional-query simulation.

Suppose H = H1 + H2 where H1, H2 have eigenvalues 0 and ¼.Write for very large r (increasing r does not affect the query complexity, and only weakly affects the gate complexity).

e�i(H1+H2)t ⇡ (e�iH1t/re�iH2t/r)r

This is a fractional-query algorithm with oracles and .e�iH1 e�iH2

Package them as a single oracle .Q = |1ih1|⌦ e�iH1 + |2ih2|⌦ e�iH2

This may not be diagonal in the standard basis, but the fractional-query simulation doesn’t require that.

To give a complete simulation, we decompose the Hamiltonian into a sum of terms, each with eigenvalues 0 and ¼ (up to an overall shift and rescaling). (Start by coloring the edges to make the Hamiltonian 1-sparse and then further refine the decomposition.)

Query and gate complexityQuery complexity of this approach: O

�⌧ log(⌧/✏)log log(⌧/✏)

�

⌧ := d2kHkmax

twhere

Gate complexity is not much larger: O�⌧ log(⌧/✏)log log(⌧/✏) (log(⌧/✏) + n)

�

where H acts on n qubits

Local HamiltoniansRecall: A k-local Hamiltonian with m terms is d-sparse with d = 2k m.

We can reduce the overhead below d2 given a nice decomposition. Using the decomposition into m terms, each k-local (and hence 2k-sparse), we can replace ¿ by .⌧ := 2kmkHk

max

t

Lower boundsNo-fast-forwarding theorem [BACS 07]: ⌦(t)

Main idea: • Query complexity of computing the parity of n bits is . • There is a Hamiltonian that can compute parity by running for

time O(n).

⌦(n)

New lower bound: ⌦( log(1/✏)log log(1/✏) )

Main idea: • Query complexity of parity is even for unbounded error. • The same Hamiltonian as above computes parity with unbounded

error by running for any positive time. Running for constant time gives the parity with probability £(1/n!).

⌦(n)

Comparison of sparse Hamiltonian simulations

Product formulas Quantum walk Fractional queries

Query complexity

Best known scaling with evolution time t

and sparsity d✓

Best known scaling with error ² ✓

Handles time-dependent

Hamiltonians✓ ✓

O

✓dkHk

max

tp✏

◆d3kHkt

⇣dkHkt

✏

⌘o(1) O�⌧ log(⌧/✏)log log(⌧/✏)

�

⌧ := d2kHkmax

t

How should we simulate small systems?Consider a sum of m 2-local terms of constant norm acting on n qubits.

Product formulas

gate complexity O(m5/2t3/2/p✏)

should use next-lowest order (k = 1)

Fractional queries

O�mt log(mt/✏)

log log(mt/✏) (log(mt/✏) + n)�

gate complexity

Quantum walk

gate complexity O(mnt/p✏)

with m = O(n)

O(n5/2t3/2/p✏)

O(n2t)

O(n2t/p✏)

Open questions• Improvements to methods; (optimal?) tradeoffs between evolution

time, error, and locality/sparsity

• Careful estimates of gate complexity for small systems: what approach is best for particular simulations of interest?

• Investigate parallel algorithms

• Improved simulation of specific kinds of Hamiltonians

• Better understanding of applications to problems in quantum chemistry, etc.

• Real implementations!