HAMILTONIAN SIMULATION IN THE INTERACTION PICTURE

Abstract

In this disclosure, quantum algorithms are presented for simulating Hamiltonian time-evolution e−i(A+B)t in the interaction picture of quantum mechanics on a quantum computer. The interaction picture is a known analytical tool for separating dynamical effects due to trivial free-evolution A from those due to interactions B. This is especially useful when the energy-scale of the trivial component is dominant, but of little interest. Whereas state-of-art simulation algorithms scale with the energy ∥A+B∥≤∥A∥+∥B∥ of the full Hamiltonian, embodiments of the disclosed approach generally scale linearly with the sum of the Hamiltonian coefficients from the low-energy component B and poly-logarithmically with those from A.

Description

SUMMARY

In this disclosure, quantum algorithms are presented for simulating Hamiltonian time-evolution e^−i(A+B)t in the interaction picture of quantum mechanics on a quantum computer. The interaction picture is a known analytical tool for separating dynamical effects due to trivial free-evolution A from those due to interactions B. This is especially useful when the energy-scale of the trivial component is dominant, but of little interest. Whereas state-of-art simulation algorithms scale with the energy ∥A∥+∥B∥ of the full Hamiltonian, embodiments of the disclosed approach generally scale with only the low-energy component ∥B∥. Applied to simulating a periodic N-site Hubbard model with arbitrary long-ranged density-density interactions, the disclosed gate complexity (N²t) is a quadratic improvement in N over prior art for electronic structure simulation in the plane-wave basis. More generally in the abstract query model, diagonally-dominant Hamiltonians with sparsity d can be simulated with cost independent of the diagonal component. The various contributions disclosed herein include a rigorous analysis of a low-space overhead simulation algorithm based on the Dyson series for general time-dependent Hamiltonians, which also enables a quadratic improvement in sparsity for time-dependent simulation with (td) queries.

In some embodiments of the disclosed technology, a quantum computer is configured to simulate a quantum system, and a Hamiltonian in the simulation is represented in the interaction picture. The simulation of the quantum system is then performed using the quantum computer. In certain implementations, the simulation of the quantum system is a subroutine that is repeated two or more times. In some implementations, the simulation is performed using linear combinations of unitaries. For instance, in some cases, the simulation uses linear combinations of unitaries performed on a diagonally dominant matrix (e.g., using linear combinations of unitaries performed on the diagonally dominant components of the diagonally dominant matrix). In certain implementations, the quantum system is modelled by a Hubbard model. In particular implementations, the quantum system describes a physical chemical system or molecule. In some implementations, the Hamiltonian is sparse and the simulation uses the a state of an auxiliary qubit to encode the matrix elements of the Hamiltonian instead of using graph decomposition techniques. In certain implementations, the simulation is performed by compressing ancillas for quantum simulation of a time-dependent Hamiltonian.

In further embodiments, a quantum algorithm is implemented on a quantum computer for simulating a general sparse time-dependent quantum system. In this embodiment, the quantum algorithm does not use graph decomposition techniques. In certain implementations, a quantum Hamiltonian used in the simulation is represented in the interaction picture. In some implementations, the simulation uses linear combinations of unitaries performed on a diagonally dominant matrix. In particular implementations, an interaction Hamiltonian is chosen to be a diagonal matrix. In certain implementations, the quantum system is modelled by a Hubbard model, a physical chemical system, or a molecule. In further implementations, the simulation includes compressing ancillas use to index the time for the simulation.

The foregoing and other objects, features, and advantages of the disclosed technology will become more apparent from the following detailed description, which proceeds with reference to the accompanying figures.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a schematic block diagram showing a circuit that implements HAM with normalization constant α=Σ_j=1^l α_j using example unitary oracles.

FIG. 2 shows a quantum circuit representations of the components implementing the truncated Dyson series algorithm TDS.

FIG. 3 is a quantum circuit representations of the gadget V for applying a sequence of probabilistic operators H_k . . . H₂H₁, encoded in (0|_α⊗I_s)U_k(|0_α⊗I_s)=H_k, controlled on number state |k_b, k∈{0,1, . . . , K}.

FIG. 4 depicts the quantum circuit representation of an example implementation of HAM_K from Eq. (75) using K queries to controlled-HAM, a single step of the truncated Taylor series algorithm before oblivious amplitude amplification, and a single step of time-evolution by the truncated Taylor series algorithm from Eq. (78).

FIG. 5 is a schematic block diagram showing quantum circuit representations of the unitary DYS_K that encodes time-ordered products of Hamiltonians, using fewer ancilla than the construction in FIG. 2 by applying the compression gadget of FIG. 4.

FIG. 6 is an example method for a time-dependent simulation algorithm as disclosed herein.

FIG. 7 is an example method for an example interaction picture simulation method as disclosed herein.

FIG. 8 is an example method simulating chemistry and Hubbard models as disclosed herein.

FIG. 9 is an example method of a compression method as disclosed herein.

FIG. 10 illustrates a generalized example of a suitable classical computing environment in which aspects of the described embodiments can be implemented.

FIG. 11 illustrates an example of a possible network topology (e.g., a client-server network) for implementing a system according to the disclosed technology.

FIG. 12 illustrates another example of a possible network topology (e.g., a distributed computing environment) for implementing a system according to the disclosed technology.

FIG. 13 illustrates an exemplary system for implementing the disclosed technology.

FIG. 14 illustrates an example method for performing a quantum simulation in accordance with an embodiment of the disclosed technology.

FIG. 15 illustrates a further example method for performing a quantum simulation in accordance with an embodiment of the disclosed technology.

DETAILED DESCRIPTION

I. General Considerations

As used in this application, the singular forms “a,” “an,” and “the” include the plural forms unless the context clearly dictates otherwise. Additionally, the term “includes” means “comprises.” Further, the term “coupled” does not exclude the presence of intermediate elements between the coupled items. Further, as used herein, the term “and/or” means any one item or combination of any items in the phrase.

Although the operations of some of the disclosed methods are described in a particular, sequential order for convenient presentation, it should be understood that this manner of description encompasses rearrangement, unless a particular ordering is required by specific language set forth below. For example, operations described sequentially may in some cases be rearranged or performed concurrently. Moreover, for the sake of simplicity, the attached figures may not show the various ways in which the disclosed systems, methods, and apparatus can be used in conjunction with other systems, methods, and apparatus. Additionally, the description sometimes uses terms like “produce” and “provide” to describe the disclosed methods. These terms are high-level abstractions of the actual operations that are performed. The actual operations that correspond to these terms will vary depending on the particular implementation and are readily discernible by one of ordinary skill in the art.

II. Introduction

Many-body dynamics are often described by a Hamiltonian H=A+B with two non-commuting parts: a well-understood but trivial free-particle theory A, and a more interesting component B describing interactions. One often finds a large separation of energy scales ∥A∥»∥B∥ in nature. For instance, the ultra-violet cutoff of a free scalar field is usually assumed to be significantly higher than the energy scale of its interactions. In practical applications, the energy contribution of electron-electron correlations in molecules and materials are typically larger than chemical accuracy, at 4 kJ mol⁻¹, but still much smaller than the Hartree-Fock component.

Dynamical effects arising from the interaction are often the subject of interest. Whereas the quantum state-vector |φ_I(t) evolves under the full Hamiltonian by the Schrödinger equation i∂_t|φ(t)=(A+B)|φ(t), the interaction picture moves to the rotating frame of the trivial dynamics. This frame allows one to focus on effects of the interaction, and is particularly fruitful when interactions are perturbative corrections to the free-theory. For instance, an analytic evaluation of the time-ordered propagator of the interaction picture Hamiltonian H_I(t)=e^iAtBe^−iAt is possible by perturbative expansions based on Green's functions and Feynman diagrams. However, such techniques fail for interactions that are non-perturbative, even if they are weak relative to the free theory. In such situations, one resorts to numerical simulations.

Numerical simulations of quantum dynamics scale exponentially with particle number, so the interaction picture provides little advantage here. One then relies on non-perturbative numerical approximations such as density-functional theory or Monte Carlo path-integral evaluation. Though highly successful in elucidating qualitative behavior, obtaining accurate quantitative predictions to high precision is difficult. For instance, achieving chemical accuracy in ab-initio quantum chemistry calculations of reaction rates often only possible by exact diagonalization of the Hamiltonian. This has an exponentially growing cost ⁽ⁿ⁾ with the system size n. (The standard big- notation defines f(n)=(g(n)) for positive functions f(n),g(n)>0 as the existence of absolute constants α>0,b>0 such that for any n>α, f(n)≤bg(n). One can also use f(n)=(g(n)) when f(n)≤bg(n) polylog(g(n)), and f(n)=Ω(g(n)) when f(n)≥bg(n), and f(n)=⊖(g(n)) when both f(n)=(g(n)) and f(n)=Ω(g(n)) are true.)

One approach that is tractable and non-perturbative is simulating quantum dynamics on a quantum computer. Given a (poly(n))-sized description of a time-independent Hamiltonian H, one devises a sequence of (poly(n)) primitive quantum gates that approximates the unitary time-evolution operator e^−iHt with error ϵ. (Primitive gate costs are defined as the number N of arbitrary single- and two-qubit gates. In fault-tolerant architectures, one multiples by an additional overhead (log (N/ϵ)) for approximating N such gates to total error ϵ using a universal discrete gate set, e.g. CLIFFORD+T.) This is then applied to the system state |φ(0) encoded in (poly(n)) logical quantum bits to obtain the time-evolved state |φ(t)=e^−iHt|φ(0). Algorithms for Hamiltonian simulation have progressed rapidly culminating recently in schemes with optimal query complexity (nt+log (1/ϵ)) with respect to all parameters for generic sparse Hamiltonians, and algorithms for geometrically-local exponentially-decaying interactions, with gate complexity (nt polylog(nt/ϵ)) that is optimal up to poly-logarithmic factors.

It would be desirable if the cost of simulating time-evolution scaled with energy of the smaller interaction term, say (t∥B∥). As the interaction picture Hamiltonian has norm ∥H_I(t)∥=∥B∥, this possibility is highly suggestive. Nevertheless, state-of-art performs simulation in the Schrödinger picture, where the gate cost of simulating e^−iHt generally scales at least like Ω(t(∥A∥+∥B∥)log(1/ϵ)), even if the trivial dynamics e^−iAt of term A may be evaluated in closed-form. Even with specialized techniques that scale with a geometric mean (^(k)t∥A∥(t∥B∥/ϵ)^1/k), ∀k∈2⁺. the uninteresting component (t∥A∥) is the dominant pre-factor.

Unfortunately, simulation in the interaction picture is difficult. There, evolution by a time-independent Hamiltonian H is transformed in the rotating frame |φ_I(t)=e^iAt|φ(t) to evolution by a time-dependent Hamiltonian H_I(t)=e^iAtBe^−iAt. This follows from an elementary manipulation of the Schrödinger equation:

i∂ _t|φ(t)=(A+B)|φ(t)→i∂_t|φ_I(t)=e^iAtBe^−iAt|φ_I(t).  (1)

Implementing the time-ordered propagator [exp(−i∫₀^tH(s)ds)] that solves Eq. (1) on a quantum computer requires time-dependent simulation algorithms. These are generally more complicated than time-independent algorithms, and exhibit different cost trade-offs that do not appear favorable. For instance, an order-k time-dependent Trotter-Suzuki product formula has a cost that scales with the rate of change of H(t) like (^(k)(t∧)^1+1/(2k)), where ∧=max_s∥{dot over (H)}(s)∥^1/2=(∥[A,B]∥^1/2). More advanced techniques based on compressed fractional queries appear to scale better like ˜

$tB\frac{\log \left(\Lambda t/ϵ\right)}{\log \log \left(\Lambda t/ϵ\right)}$

but in terms of queries to a unitary oracle that obscures the gate complexity as it expresses Hamiltonian matrix elements at different times in binary, and may be difficult to implement in practice. One proposed technique directly implements a truncated Dyson series of a the time-ordered propagator and argues, though without proof, a similar scaling in terms of queries to a different type of oracle.

Here, it is shown that simulation in the interaction picture can substantially improve the efficiency of simulation. In Section III, the general time-dependent simulation algorithm is completed by a truncated Dyson series by providing a rigorous analysis of the approximation and explicit circuit constructions, with improvements in gate and space complexity over previously expected costs. In Section IV, situations are identified where the gate complexity of implementing these queries scale with the interaction strength (∥B∥), and not the larger uninteresting component (∥A∥). Such are the cases where simulation in the interaction picture is advantageous. In Section V, the potential of interaction-picture simulation by an electronic structure application in the plane-wave basis is discussed. Further, the cost of simulating the time-evolution of N spin-orbitals subject to long-range electron-electron interactions to (N²t) gates is discussed, which is close to a quadratic improvement over prior art of (N^11/3t). In Section VI, a complexity theoretic perspective of the disclosure is provided by considering the abstract problem of simulating time-dependent sparse Hamiltonians in the standard query model. A quadratic improvement in sparsity scaling is shown, and optimized algorithms for simulating diagonally dominant Hamiltonians are provided. A more detailed summary of main results in each section is as follows.

In Section III (“Time-dependent Hamiltonian simulation by a truncated Dyson series”), an example algorithm for a general time-dependent simulation algorithm Theorem 1 is provided. The example algorithm is based on approximating a truncation and discretization of the Dyson series for general time-dependent Hamiltonians H(t) characterized by spectral-norm α≥max_t∥H(t)∥ and average rate-of-change

$〈\stackrel{.}{H}〉=\frac{1}{t}{\int }_0^t\stackrel{.}{H}\left(s\right)\mathrm{ds}.$

A rigorous analysis of its performance is provided in together with explicit circuit constructions. Bounds on the approximation error is evaluated in Section III A, which is used to obtain the cost of simulating the time-ordered evolution operator. This cost is found to be

$\left(\alpha t\frac{\log \left(\alpha t/ϵ\right)}{\log \log \left(\alpha t/\varepsilon \right)}\right)$

queries to a certain unitary oracle HAM-T that encodes H(t) evaluated

$M=\left(\frac{1}{ϵ}\frac{〈\stackrel{.}{H}〉}{{\alpha }^3}\right)$

points. Example implementations as disclosed in Section III B, characterized by Theorem 2, completes the scheme proposed by D. W. Berry, A. M, Childs, and R. Kothari, “Hamiltonian simulation with nearly optimal dependence on all parameters,” in Proceedings of the 56th Annual IEEE Symposium on Foundations of Computer Science (FOCS), pages 792-809 (October 2015), with some improvements in gate complexity. One obtains scaling with the average rate-of-change (log(∥H∥)), instead of the worst case (log(max_t∥H(t)∥)). This allows one to simulate Hamiltonians with arbitrary elementwise slew-rates, so long as ∥H(t)∥ remains bounded. One can then devise a compression gadget in Section III C that reduces the qubit overhead complexity of this implementation to (log(M)), compared to

$\left(\log \left(M\right)\frac{\log \left(\alpha t/ϵ\right)}{\log \log \left(\alpha t/ϵ\right)}\right)$

of the original. This gadget is of independent interest and also applicable to the time-independent truncated Taylor series algorithm, discussed in Section XA for completeness.

In Section IV (“Accelerated interaction picture simulation”), one can apply this truncated Dyson series algorithm to simulate time-evolution by e^−i(A+B)t in the interaction picture. One can evaluate the gate complexity in Section IV A for one possible construction of these queries HAM-T for the interaction picture Hamiltonian H_I(t)=e^iAtBe^−iAt. This leads to the simulation algorithm Theorem 3 for time-evolution by e^−i(A+B)t with gate complexity

((C_B+C_eiA/αB)α_Btpolylog(∥A∥,α_B,t,ϵ)),  (2)

where C_B is the gate complexity a unitary oracle O_B such that

$(〈0{|}_a\otimes I_s)O_B\left({0〉}_a\otimes I_s\right)=\frac{B}{{\alpha }_B},$

and C_eiA/αB is the cost of simulating time-evolution by A for time (α_B⁻¹). This may be compared to state-of-art Schrödinger picture simulation algorithms for time-independent Hamiltonians, which have gate complexity

((C_B+C_A)(α_B+α_A)tpolylog(∥A∥,∥B∥,t,ϵ)),  (3)

where C_A is analogous to C_B but for the Hamiltonian term A. The disclosed result Eq. (2) is then advantageous in cases where ∥A∥»∥B∥ and C_eiA/α=(C_B). There, the gate complexity scales with the interaction strength ∥B∥, and not the larger uninteresting component ∥A∥, up to polylogarithmic factors.

In Section V (“Application to the Hubbard model with long-ranged interactions”),

One can demonstrate a concrete advantage for Hamiltonian simulation in the interaction picture over time-independent simulation algorithms. One can consider a general Hubbard periodic model on N lattice sites in an arbitrary number of dimensions, which has Hamiltonian

$\begin{array}{cc}H=\sum _{\overrightarrow{x},\overrightarrow{y},\sigma }T\left(\overrightarrow{x}-\overrightarrow{y}\right)a_{\overrightarrow{x}\sigma }^{†}a_{\overrightarrow{y},\sigma }+\sum _{\overrightarrow{x},\sigma }U\left(\overrightarrow{x},\sigma \right)n_{\overrightarrow{x}\sigma }+\sum _{\left(\overrightarrow{x},\sigma \right)\ne \left(\overrightarrow{y},{\sigma }^{\prime }\right)}V\left(\overrightarrow{x}-\overrightarrow{y}\right)n_{\overrightarrow{x}\sigma }n_{\overrightarrow{y}{\sigma }^{\prime }},& \left(4\right)\end{array}$

where α_{{right arrow over (x)}σ}^†, α_{{right arrow over (x)}σ} are Fermionic creation and annihilation operators indexed by lattice position {right arrow over (x)} and spin σ, and n_{{right arrow over (x)}σ} is a number operator. Note that one can allow for arbitrary translationally invariant kinetic T(⋅) hopping terms and long-range density-density V(⋅) interactions, subject to arbitrary local disorder U(⋅). Provided that the kinetic term is extensive, embodiments of the disclosed interaction-picture algorithm have gate complexity (N²t), independent of U and V up to poly-logarithmic factors. This model generalizes electronic structure simulations in the plane-wave basis, considered in Section V A, where one obtains almost a quadratic improvement over the prior art of (N^11/3t) gates for this special case. This is complementary to recent work by Jeongwan Haah, Matthew B Hastings, Robin Kothari, and Guang Hao Low, Quan- tum algorithm for simulating real time evolution of lattice Hamiltonians. arXiv preprint arXiv:1801.03922, 2018, which achieves (Nt) scaling, but under the assumption of short-range exponentially decaying coefficients.

In Section VI (“Application to sparse Hamiltonian simulation”), the application to the Hubbard model with long-ranged interactions is explained.

Consider next a complexity-theoretic generalization of the technology that has been developed for time-dependent simulation and simulation in the interaction picture. The standard query model for black-box d-sparse Hamiltonian simulation assumes access to a unitary oracle that provides the positions and values of non-zero entries of the Hamiltonian. Each row has at most d non-zero entries, and the maximum absolute value of any entry is ∥H∥_max. This infortmation is also provided as a function of a time index for time-dependent Hamiltonians, In Section VI A, one considers this time-dependent case and show with Theorem 4 that the time-ordered evolution operator may be simulated using

$\left(\mathrm{td}{H}_{\max }\frac{\log \left(\mathrm{td}{H}_{\max }/ϵ\right)}{\log \log \left(\mathrm{td}{H}_{\max }/ϵ\right)}\right)$

queries. Though linear scaling with respect to d is well-known in the time-independent case, this is a quadratic improvement in sparsity scaling over prior art for the time-dependent case. An analogous treatment for simulating sparse time-independent Hamiltonian in the interaction picture in Section VI B, Theorem 5 has query complexity that scales only with ∥H_od∥_max, which is the maximum absolute value of any off-diagonal entry. This improved cost

$\left(\mathrm{td}{H_{\mathrm{od}}}_{\max }\frac{\log \left(\mathrm{td}{H_{\mathrm{od}}}_{\max }/ϵ\right)}{\log \log \left(\mathrm{td}{H_{\mathrm{od}}}_{\max }/ϵ\right)}\right),$

is particularly advantageous for the common situation of diagonally dominant Hamiltonians.

III Time-Dependent Hamiltonian Simulation by A Truncated Dyson Series

The time-dependent simulation technique applied throughout this work is motivated by the Dyson series which solves the time-dependent Schrödinger equation. The Dyson series is a power-series expansion of the unitary propagator that involves integrals of products of H(t) at different times. The technique implements a truncation of this power-series, where integrals in each term is discretized in time.

This technology is presented with a rigorous analysis of the truncation and discretization error in Section III A, followed by an explicit circuit construction that is in the spirit of earlier work in Section III B. Two improvements are of note. First, the gate complexity of the algorithm scales with the average rate-of-change (log(∥H∥)), instead of the worst case (log (max_t∥H(t)∥). This allows one to simulate Hamiltonians with arbitrary element-wise slew-rates, so long as ∥H(t)∥ remains bounded. Second, in Section III C, an alternate implementation of the technique is introduced that reduces the space overhead of the original proposal substantially, and has the same query and gate complexity.

The complexity of any simulation algorithm depends on assumptions made about how information on the time-dependent Hamiltonian H(t) is accessed by the quantum computer. This section begins by defining an input model for the unitary quantum oracle HAM-T that encodes H(t). The complexity of time-dependent simulation is then expressed in terms of queries to HAM-T (It is assumed that the query complexity to a controlled-unitary black-box is the same as that to the original black-box. In general, this will not affect the gate complexity. Though there are often cleverer ways to implement an arbitrary controlled-unitary, in the worst-case, all quantum gates may be replaced by their controlled versions with constant overhead.), any additional primitive gates required beyond HAM-T, and the total number of qubits required including that for HAM-T. In later sections where the time-dependent simulation algorithm is applied to the interaction picture, this oracle is “opened up” and and the gate complexity of its implementation is discussed.

A common assumption in the time-independent situation is that H=Σ_j=1^lα_jH_j is a sum of l local Hermitian terms with positive coefficients α_j, and that each term e^−iHjt may be implemented with (l) quantum gates for any t. In abstract models for sparse Hamiltonians, a binary representation of matrix entries H_jk and positions are returned in superposition by querying a certain unitary quantum oracle that is a natural generalization of classical Boolean circuits, Here, Hamiltonians H is considered encoded in a so-called standard-form. For any time-independent Hamiltonian H, it is assumed that there exists a unitary oracle HAM such that

(0|_a⊗I_s)HAM(|0_a⊗I_s)=H/α,  (5)

where HAM acts jointly on registers α, s consisting of n_α, n_s qubits respectively, and α≥∥H∥ is a normalization constant that should be made small for best performance. In other words, post-selected on the n_α-qubit measurement outcome |0_α the Hamiltonian H is applied on any arbitrary state in the system register s. Use of this is justified as it generalizes a variety of different input models. Thus any simulation algorithm that queries Eq. (5) for this general case readily specializes to more structured inputs. As an example, H=Σ_j=1^2nαα_jU_j could be a linear combination of l=2^nα unitaries. Then the circuit depicted in FIG. 1 implements HAM with normalization constant α=Σ_j=1^l α_j using the unitary oracles

$\begin{array}{cc}\mathrm{HAM}=\left({\mathrm{PREP}}^{†}\otimes I_s\right)·\mathrm{SEL}·\left(\mathrm{PREP}\otimes I_s\right),\mathrm{PREP}{0〉}_a=\sum _{j=1}^i\sqrt{\frac{a_j}{\alpha }}{j〉}_a,\mathrm{SEL}=\sum _{j=1}^ij〉{〈j}_a\otimes U_j.& \left(6\right)\end{array}$

These unitaries each cost (l) gates—PREP is implemented by arbitrary quantum state preparation on l dimensions, and SEL is implemented by binary-tree control logic for l different inputs. Typically, the number of terms in the Hamiltonian scales like l=(poly(n_s)), so n_α=(log(l)). However, the number of ancilla qubits can also be polynomial in n_s, such as in the simulation of sparse Hamiltonians where n_α≥n_s+2, or where a space-time complexity trade-off is possible.

FIG. 1 shows a quantum circuit representation of (left) an oracle HAM from Eq. (5) encoding a time-independent Hamiltonian, (center) an oracle HAM-T from Eq. (7) encoding a time-dependent Hamiltonian, and (right) an example implementation of HAM from with a linear-combination of unitaries from Eq. (6). Bold horizontal lines depict registers that in general comprise of multiple qubits. Vertical lines connecting boxes depict unitaries that act jointly on all registers covered by the boxes. A small square box marked by T indicates control by a time index.

A number of techniques may be applied to approximate the unitary time-evolution operator e^−iHt to error ϵ by querying HAM. The combined Qubitization and quantum signal processing approach is one such algorithm with query complexity (αt+log(1/ϵ)) that is optimal for sparse Hamiltonians. Alternatively, one could apply a truncated Taylor series of e^−iHt, which has a slightly worse query and space complexity, but benefits from being conceptually simpler. As the Dyson series algorithm is time-dependent generalization of the truncated Taylor series algorithm, a review and some useful background is provided before in Section X A for completeness.

A natural time-dependent generalization of Eq. (6) is the unitary oracle HAM-T encoding the Hamiltonian H(s) defined over time s ∈[0,t], with t>0. The continuous parameter s is discretized into an integer number of M>0 time bins which are indexed by m ∈ {0, 1, . . . , M−1}. Here, it is assumed that H(s) is encoded in an analogous format

$\begin{array}{cc}\left({〈0}_a\otimes I_s\right)\mathrm{HAM}\text{-}T\left({0〉}_a\otimes I_s\right)=\sum _{m=0}^{M-1}m〉{〈m}_d\otimes \frac{H\left(m\Delta \right)}{\alpha }.& \left(7\right)\end{array}$

Given black-box access to HAM-T, details of a quantum algorithm that approximates the Dyson series Eq. (8) are provided. The overall algorithm is efficient so long as HAM-T has an efficient implementation in terms of primitive quantum gates. More formally, the performance of the algorithm is captured by the following theorem, proven in the remainder of this section.

Theorem 1 (Hamiltonian simulation by a truncated Dyson series). Let a time-dependent Hamiltonian H(s) be characterized by spectral norm α≥max_s ∥H(s)∥, and average rate-of-change

$〈\stackrel{.}{H}〉=\frac{1}{t}{\int }_o^t\frac{\mathrm{dH}\left(s\right)}{\mathrm{ds}}$

ds. This Hamiltonian is defined for s∈[0, t], where |αt|≤½, and is encoded in an oracle HAM-T acting on n_s+n_α+n_d qubits, as per Eq. (7), evaluated at

$M=\left(\frac{t^2}{ϵ}\left(\frac{〈\stackrel{.}{H}〉}{\alpha }+\frac{{\max }_s{H\left(s\right)}^2}{{\alpha }^2}\right)\right)$

points, where n_d=(log (M)). Then the time-ordered evolution operator [exp(−i∫₀^tH(s)ds)] may be approximated to error ϵ with the following cost.

$1.\mathrm{Queries}\mathrm{to}\mathrm{HAM}\text{-}T\text{:}\left(\frac{\log \left(t/ϵ\right)}{\log \log \left(t/ϵ\right)}\right).2.\mathrm{Qubits}\text{:}n_s+\left(n_a+\log \left(M\right)\right).3.\mathrm{Primitive}\mathrm{gates}\text{:}\left(\left(n_a+\log \left(M\right)\right)\frac{\log \left(1/ϵ\right)}{\log \log \left(1/ϵ\right)}\right).$

Note that, this algorithm performs time-evolution for a relatively short duration of t≤α⁻¹. Time-evolution for longer durations is simulated by breaking the time-ordered evolution operator [exp(−i∫₀^tH(s)ds)] into L=(αt) time-steps 0=t₀<t₁ . . . <t_L=t of size (α⁻¹), and each step is implemented by the quantum circuit underlying Theorem 1 that queries a different HAM-T now defined for a Hamiltonian H(s) for s∈[t_j,t_j−1]. As the final error is Lϵ by a simple triangle inequality, one can rescale ϵ→ϵ/L. Thus simulation for the full duration to error ϵ has query complexity

$\left(\alpha t\frac{\log \left(\alpha t/ϵ\right)}{\log \log \left(\alpha t/ϵ\right)}\right).$

A. Dyson Series Truncation Error

The choice of parameters in Theorem 1 depends on the scaling of error from a finite and discrete approximation of the Dyson series. Consider a unitary propagator U(t) defined to solve the time-dependent Schrödinger equation i∂_t|φ(t)=H(t)|φ(t) by providing the state |φ(t)=U(t)|φ(0) given the initial state |φ(0) at time t=0. For any t>0 and bounded ∥H(t)∥, U(t) has an absolutely convergent infinite expansion known as the Dyson series

U(t)=I−i∫₀^tH(t₁)dt₁−∫_t2^t∫₀^t2H(t₂)H(t₁)dt₁dt₂+i∫_t3^t∫_t2^t3∫₀^t2H(t₃)H(t₂)H(t₁)dt₁dt₂dt₃+ . . . .  (8)

This may be compactly represented using the time-ordering operator z,99 which sorts any sequence of k operators according to the times t_j of their evaluation, that is, [H(t_k) . . . H(t₂)H(t₁)]=H(t_σ(k)) . . . H(t_σ(2))H(t_σ(1)), where σ is a permutation such that t_σ(1)≤t_σ(2)≤ . . . ≤t_σ(k). For instance, [H(t₂)H(t₁)]=θ(t₂−t₁)H(t₂)H(t₁)+θ(t₁−t₂)H(t₁)H(t₂) using the Heaviside step function θ. With this notation, the propagator is commonly expressed as a time-ordered evolution operator U(t)=[e^{−i∫0tH(s)ds}], and Eq. (8) is written as

$\begin{array}{cc}\left[e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}\right]=\sum _{k=0}^{\infty }{\left(-i\right)}^kD_k,D_k=\frac{1}{k!}{\int }_0^t\dots {\int }_0^t\left[H\left(t_k\right)\dots H\left(t_1\right)\right]d^kt.& \left(9\right)\end{array}$

The Dyson series of Eq. (9) may be approximated on a computer by truncating the infinite expansion at some finite order k=K≥0, and evaluating H(t_j) at some finite number of M time-steps of size Δ=t/M. Thus, one has the approximation

$\begin{array}{cc}\left[e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}\right]\approx \sum _{k=0}^K{\left(-i\right)}^kD_k\approx \sum _{k=0}^{\infty }\frac{{\left(-\mathrm{it}\right)}^k}{k!M^k}{\tilde{B}}_k,{\tilde{B}}_k=\sum _{m_1,\dots ,m_k=0}^{M-1}\left[H\left(m_k\Delta \right)\dots H\left(m_1\Delta \right)\right],& \left(10\right)\end{array}$

which converges to U(t) in the limit K, M→∞ if H(t) is Riemann integrable. One can obtain some intuition on how the error of this approximation depends on choices of K, M, H(t). As ∥H(t)∥ is bounded,

$D_k\le \frac{t^k}{k!}{\max }_s{H\left(s\right)}^k.$

Using Taylor's remainder theorem for the exponential function, the error of truncation for |t| max_s ∥H(s)∥=(1) is at most ϵ=(1/K!). Thus the order of truncation is at most

$K=\left(\frac{\log \left(1/ϵ\right)}{\log \log \left(1/ϵ\right)}\right).$

As {tilde over (B)}_k is a left Riemann sum of D_k, one expects that the error of discretization should scale like

$ϵ=\left(\frac{1}{M}\right).$

These two errors may then be added by a triangle inequality to obtain the overall error from approximating [e^{−i∫0tH(s)ds}] with

$\sum _{k=0}^K\frac{{\left(-\mathrm{it}\right)}^k}{M^k}B_k.$

The explicit time-ordering in {tilde over (B)}_k may be removed with a slightly different approximation

$\begin{array}{cc}{\tilde{B}}_k=k!B_k+C_k,B_k=\sum _{0\le m_1<\dots <m_k<M}H\left(m_k\Delta \right)\dots H\left(m_1\Delta \right),& \left(11\right)\end{array}$

where C_k captures terms where at least one pair of indices m_j=m_k collide for j≠k. A rigorous statement of this intuition is given by the following Lemma 1, with a detailed proof in Section XI.

Lemma 1 (Error from truncating and discretizing the Dyson series). Let H(s): →^N×N be differentiable on the domain [0, t], and let

$〈\stackrel{.}{H}〉\text{:}=\frac{1}{t}{\int }_0^t\frac{\mathrm{dH}\left(s\right)}{\mathrm{ds}}\mathrm{ds}.$

For any ϵ∈[0, 2^1-e], an approximation to the time ordered operator exponential of −iH(s) can be constructed such that

$\left[e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}\right]-\sum _{k=0}^K{\left(-\mathrm{it}/M\right)}^kB_k\le ϵ$

if one takes all the following are true.

$1.{\max }_sH\left(s\right)t\le \ln 2.$ $2.K=\lceil -1+\frac{2\ln \left(2/ϵ\right)}{\ln \ln \left(2/ϵ\right)+1}\rceil .3.M\ge \max \left\{\frac{16t^2}{ϵ}\left(〈\stackrel{.}{H}〉+{\max }_s{H\left(s\right)}^2\right),K^2\right\}.$

On a quantum computer, it becomes possible to compute the B_k exactly and efficiently even it they sum over exponentially many points M. In contrast, computing these Riemann sums on classical computer would be prohibitive, even by approximate Monte-Carlo sampling, which is exacerbated by the sign problem. However, this efficient quantum computation crucially assumes that information on terms of the Hamiltonian are made accessible in a certain coherent manner. In the case discussed here, this is information is accessed by querying the black-box unitary oracle HAM-T in Eq. (7).

B. Algorithm by Duplicating Control Registers

A quantum algorithm is presented that applies the ϵ-approximation

$\tilde{U}=\sum _{k=0}^{\infty }\frac{{\left(-\mathrm{it}\right)}^k}{M^k}B_k$

to the time-ordered evolution operator [e^{−i∫0tH(s)ds}], where the truncation order K and the number of discretization points M are given by Lemma 1. This version is the prelude to Theorem 1 and has worse space complexity. The algorithm proceeds in two steps: First, one synthesizes a unitary quantum circuit DYS_K that applies Ũ with success probability ½ on any input state to the s register. As B_K contains K a product of K Hamiltonian, this step requires (K) queries to HAM-T. Second, since Ũ is ϵ-close to unitary, one applies one round of oblivious amplitude amplification to boost this probability to 1−(ϵ). Among the contributions here are rigorous bounds on K and M, and the implementation of a step not discussed previously—the efficient preparation of a particular quantuni state that correctly selects a desired linear combination of time-ordered products of Hamiltonians. This step is non-obvious as the state has (M!) different amplitudes, and in the worst-case would take (M!) gates to create by arbitrary state preparation techniques. The cost of this implementation is captured by the following theorem.

Theorem 2 (Hamiltonian simulation by a truncated Dyson series with duplicated registers). Let a time-dependent Hamiltonian H(s) be characterized by spectral norm α≥max_s ∥H(s)∥, and average rate-of-change

$〈\stackrel{.}{H}〉=\frac{1}{t}{\int }_0^t\frac{\mathrm{dH}\left(s\right)}{\mathrm{ds}}\mathrm{ds}.$

This Hamiltonian is defined for s ∈ [0,t], where |αt|≤½, and is encoded in an oracle HAM-T acting on n_s+n_α+n_d qubits, as per Eq. (7), evaluated at

$M=\left(\frac{t^2}{ϵ}\left(\frac{〈\stackrel{.}{H}〉}{\alpha }+\frac{{\max }_s{H\left(s\right)}^2}{{\alpha }^2}\right)\right)$

points, where n_d=(log (M)). Then the time-ordered evolution operator [exp (−i∫₀^tH(s)ds)] may be approximated to error ϵ with the following cost.

$1.\mathrm{Queries}\mathrm{to}\mathrm{HAM}\text{-}T\text{:}\left(\frac{\log \left(t/ϵ\right)}{\log \log \left(t/ϵ\right)}\right).2.\mathrm{Qubits}\text{:}n_s+\left(n_a+\log \left(M\right)\frac{\log \left(t/ϵ\right)}{\log \log \left(t/ϵ\right)}\right).3.\mathrm{Primitive}\mathrm{gates}\text{:}\left(\left(n_a+\log \left(M\right)\right)\frac{\log \left(1/ϵ\right)}{\log \log \left(1/ϵ\right)}\right).$

Proof Let HAM-T_K be a unitary that acts jointly on registers s, {right arrow over (α)}, {right arrow over (b)}, c, {right arrow over (d)}. This unitary is depicted in FIG. 2 and is defined to apply products of Hamiltonians

$\begin{array}{cc}\left(〈0{|}_{\stackrel{->}{a}e}\otimes I_s)\mathrm{HAM}\text{-}{T_K(|0〉}_{\stackrel{->}{a}e}\otimes I_s\right)\text{:}=\hspace{1em}(\sum _{k=0}^Kk〉{〈k}_{\stackrel{->}{b}}\otimes \left(\sum _{\stackrel{->}{m}\in {\left[M\right]}^k}\stackrel{->}{m}〉{〈\stackrel{->}{m}}_{d_1\dots d_k}\otimes I_{d_{k+1}\dots d_K}\otimes \left(\prod _{j=1}^kH\left(m_j\Delta \right)\right)\right)+\dots )\otimes {\mathrm{SWAP}}_c,& \left(12\right)\end{array}$

were SWAP_c swaps the two qubits of register c. Note that the action of HAM-T_K is only defined for input states to register {right arrow over (b)} that are spanned by basis states of the unary encoding |k_{{right arrow over (b)}}=|0^⊗k|1^⊗K-k, which determines the number of terms in the product. As seen in the figure, HAM-T_K makes K queries to HAM-T and copies the α, b, and d registers K times.

FIG. 2 shows a quantum circuit representations of the components implementing the truncated Dyson series algorithm TDS.

Now, consider a state |s_{k{right arrow over (d)}}, which is a uniform superposition of time-index states under the dimension-k unit simplex

$\begin{array}{cc}{{|s_k〉}_{\overrightarrow{d}}\text{:}=\sqrt{\frac{k!\left(M-k\right)!}{M!}}{(\sum _{0\le m_1<m_2<\dots <m_k<M}|\overrightarrow{m}〉}_{d_1\dots d_k})|0〉}_{d_{k+1}\dots d_K}.& \left(13\right)\end{array}$

This state is easy to prepare when k=1—there, it is simply a uniform superposition over M number states, and costs (log M) gates. Otherwise, naive methods based on rejection sampling have some success probability |γk|² that decreases exponentially with large k. Let PREP_K be one such unitary that prepares |s_{k{right arrow over (d)}} on measurement outcome |00_c.

PREP_K|k_{{right arrow over (b)}}|0_{c{right arrow over (d)}}:=|k_{{right arrow over (b)}}(γk|00_c|s_{k{right arrow over (d)}}+√{square root over (1−|γk|²)}|01_c . . . ).  (14)

For each order k, the Riemann sum B_k may be implemented by DYS_K:=(PREP_K^†⊗I_αs). HAM-T_K·(PREP_K⊗I_αs), as depicted in FIG. 2. The unitary DYS_K encodes precisely terms B_k of the Dyson series as follows

$\begin{array}{cc}\left(〈0{|}_{\overrightarrow{a}c\overrightarrow{d}}\otimes I_{\overrightarrow{b}s}){{\mathrm{DYS}}_K(|0〉}_{\overrightarrow{a}c\overrightarrow{d}}\otimes I_{\overrightarrow{b}s}\right)=\sum _{k=0}^Kk〉{〈k}_{\overrightarrow{b}}\otimes \frac{{{\gamma }_k}^2k!\left(M-k\right)!}{M!}B_k.& \left(15\right)\end{array}$

Now, a linear combination of Dyson series terms is implemented by preparing a state with the appropriate amplitudes in the basis |k_{{right arrow over (b)}}. The required state preparation operators are

$\begin{array}{cc}{{{{{\mathrm{COEF}}_K|0〉}_{\overrightarrow{b}}\text{:}=\frac{1}{\sqrt{\beta }}\sum _{k=0}^K\sqrt{\frac{M!{\left(-\mathrm{it}\right)}^k}{M^k{{\gamma }_k}^2k!\left(M-k\right)!}}|k〉}_{\stackrel{->}{b}},\beta =\sum _{k=0}^K\frac{M!t^k}{M^k{{\gamma }_k}^2k!\left(M-k\right)!},{\mathrm{COEF}}_K^{\prime }|0〉}_{\stackrel{->}{b}}\text{:}=\frac{1}{\sqrt{\beta }}\sum _{k=0}^K\sqrt{\frac{M!t^k}{M^k{{\gamma }_k}^2k!\left(M-k\right)!}}|k〉}_{\stackrel{->}{b}},& \left(16\right)\end{array}$

and may be implemented using (K) primitive gates. Up to a proportionality factor β, one can obtain the desired linear combination for simulating time-evohnion.

$\begin{array}{cc}{{\mathrm{TDS}}_{\beta }:=\left({\mathrm{COEF}}_K^{\mathrm{\prime †}}\otimes I_{\overrightarrow{a}c\overrightarrow{d}s}\right)·{\mathrm{DYS}}_K·\left({\mathrm{COEF}}_K\otimes I_{\overrightarrow{a}c\overrightarrow{d}s}\right)\left({〈0}_{\overrightarrow{a}\overrightarrow{b}c\overrightarrow{d}}\otimes I_s\right){\mathrm{TDS}}_{\beta }(0〉}_{\overrightarrow{a}\overrightarrow{b}c\overrightarrow{d}}\otimes I_s)=\frac{{\sum }_{k=0}^K{\left(-\mathrm{it}\right)}^kB_k}{M^k\beta }\approx \frac{e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}}{\beta }.& \left(17\right)\end{array}$

If one chooses t to be sufficiently small such that β=2, one can then obtain a single time-step of the truncated Dyson series algorithm TDS in FIG. 2. All that remains is to find an implementation of PREP_K that prepares |s_{k{right arrow over (d)}} with an amplitude that |γk| that is sufficiently large so that t=⊖(1).

The state |s_{k{right arrow over (b)}c{right arrow over (d)}} can be prepared in a number of ways. The most straightforward approach creates a uniform superposition of states over the dimension-k hypercube using n_d×k Hadamard gates HAD, then uses k reversible adders to flag states |{right arrow over (m)}_{d1 . . . dk} with the correct ordering. This circuit produces |s_{k{right arrow over (d)}} with amplitude

${\gamma }_k=\sqrt{\frac{M!}{M^kk!\left(M-k\right)!}}.{\mathrm{PREP}}_K$

is then obtained by controlling on input state |k_{{right arrow over (b)}}. Thus

$\begin{array}{cc}\beta =\sum _{k=0}^Kt^k\le \sum _{k=0}^{\infty }t^k=\frac{1}{1-t}.& \left(18\right)\end{array}$

Thus by choosing t=⊖(1)≈½, s=2 and a single round of oblivious amplitude amplification suffices. Notably, even though the success probability of naive state preparation |γk|² decays rapidly, this only amounts to a constant factor slowdown compared to more sophisticated techniques that effectively prepare |s_{k{right arrow over (d)}} with success probability≈1. For example, rather than rejection sampling, one may perform a reversible sort on on uniform superposition of states

$\begin{array}{c}\frac{1}{\sqrt{M^k}}{\sum }_{\overrightarrow{m}}{\overrightarrow{m}〉}_{d_1\dots d_k}{0〉}_{\mathrm{garbage}}\to \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\frac{1}{\sqrt{M^k}}{\sum }_{\overrightarrow{m}}{\left[m_{d_1}\dots m_{d_k}\right]〉}_{d_1{\mathrm{\dots d}}_k}\\ {\overrightarrow{m}〉}_{\mathrm{garbage}},\end{array}$

such as with the quanthm bitonic sorting network. This effectively increases γ_k² by a factor of k!, and uses significantly more ancilla qubits, but ultimately allows us to implement time steps t≈ln2≈0.693 larger by a constant factor. □

C. Compression of Control Registers

The dominant contribution to the space overhead of the truncated Dyson series algorithm in Section III B is the K-fold duplication of registers {right arrow over (α)}, {right arrow over (d)} in the oracle DYS_K. A general technique is now presented that when applied to DYS_K avoids this duplication and completes the proof of Theorem 1. Suppose one has a sequence of K unitary oracles U₁, U₂, . . . , U_K, defined as

(0|_α⊗I_s)U_k(|0_α⊗I_s)=H_k,  (19)

where H_j is some arbitrary matrix with bounded spectral norm ∥H_j∥≤1. In the general problem, one can construct a quantum circuit V that when controlled on index k in register b, applies the sequence U_k . . . U₂U₁, that is

$\begin{array}{cc}{\left({〈0}_{\mathrm{ac}}\otimes I_s\right)V(0〉}_{\mathrm{ac}}\otimes I_s)=0〉{〈0}_b\otimes I_s=\sum _{k=1}^Kk〉{〈k}_b\otimes \left(\prod _{j=1}^kH_j\right).& \left(20\right)\end{array}$

Though binary control logic for this sequence is trivial when H_k is unitary, the complication here is that H_k is in general non-unitary and so the probability of successfully measuring |0_α is less than one. Any other measurement outcome corresponds failure as it applies on register α an operator that is not H_k. This complication is overcome by introducing two more registers b, c of size (log(K)) gubits that count the number of successful measurements.

Lemma 2 (Compression gadget). Let {U_k,k∈[K]} be a set of K unitaries that encode matrices H_k as defined in Eq. (19). Then there exists a quantum circuit V satisfying Eq. (20) such that the number of qubits n_b=(log (K)), n_c=(log (K)). The cost of V is one query to each of controlled-controlled-U_k, and (K (n_α+log(K))) additional primitive quantum gates.

Proof. Let b, c be counter registers. Using notation where commas in the subscript indicates respective assignments, these represent an n_b,c-bit integer l_b,c=Σ_r=0^nb,c−12^rq_r in the number state |l_b,cb,c:=|q₀q₁ . . . q_nb,c . . . 1_b,c, where q_r ∈{0, 1}. The size of these integers are determined by n_b=n_c+1=┌log₂(K+1)┐+1. The unitaries U_j will be applied conditional on the trailing bit q₀=0 in the c register, and the leading bit q_nb−1=0 in the b register, that is

CC−U _k :=I ^{⊗n b n c −2}⊗(|00|_bnb−1⊗|00|_c0⊗U_k+ . . . ).  (21)

Consider the circuit in FIG. 3. There, one can apply CC-U_k, then increment k by one, increment l_c by one conditional on the α register not being in the |0_α state, and decrement l_b by one conditional on the α register being in the |0_α state. This is accomplished by multiply-controlled modular addition

$\begin{array}{cc}{\mathrm{ADD}}_{\mathrm{ca}}={\mathrm{ADD}}_b^{†}\otimes I_c\otimes 0〉{〈0}_a+I_b\otimes {\mathrm{ADD}}_c\otimes \sum _{l=1}^{2^{n_a}-1}l〉{〈l}_a,{\mathrm{ADD}}_{b,c}=\sum _{l=0}^{2^{n_{b,c}}-1}l+1\mathrm{mod}2^{n_{b,c}}〉{〈l}_{b,c}.& \left(22\right)\end{array}$

As one adds integers of size (K), each application of modular addition costs (log(K)) primitive gates and requires (log(K)) qubits. Implementing the multiple controls costs (n_α) primitive gates and up to n_α extra qubits. FIG. 3 is a quantum circuit representations of the gadget V for applying a sequence of probabilistic operators H_k . . . H₂H₁, encoded in (0|_α⊗I_s)U_k(|0_α⊗I_s)=H_k, controlled on number state |k_b, k∈{0,1, . . . , K}.

Restricted to input states |0_α|l_b|0_c, where l ∈{2^nb−1,0,1,2,3, . . . , K−1}, this implements V. For example, consider the evolution of an input state |0_α|2_b|0_c|φ_s for K=3.

$\begin{array}{cc}{{{{0〉}_a1〉}_b{0〉}_c\psi 〉}_s\underset{\mathrm{CC}-U_1}{\to }{0〉}_a{1〉}_b0〉}_cH_1{\psi 〉}_s+{0^{\perp \mathrm{.1}}〉}_a{2〉}_b{0〉}_c\dots \underset{{\mathrm{ADD}}_{\mathrm{ca}}}{\to }{\hspace{1em}{0〉}_a{0〉}_b|0〉}_cH_1{\psi 〉}_s+{0^{\perp \mathrm{.1}}〉}_a{2〉}_b{1〉}_c\dots \underset{\mathrm{CC}-U_2}{\to }|{0〉}_a{0〉}_b{0〉}_cH_2H_1{\psi 〉}_s+{0^{\perp \mathrm{.2}}〉}_a{1〉}_b{0〉}_c\dots +{0^{\perp \mathrm{.1}}〉}_a{2〉}_b{1〉}_c\dots \underset{{\mathrm{ADD}}_{\mathrm{ca}}}{\to }{0〉}_a{-1〉}_b{0〉}_cH_2H_1{\psi 〉}_s+{0^{\perp \mathrm{.2}}〉}_a{1〉}_b{1〉}_c\dots +{0^{\perp \mathrm{.1}}〉}_a2_b{2〉}_c\dots \underset{\mathrm{CC}-U_3}{\to }{0〉}_a{-1〉}_b{0〉}_cH_2H_1{\psi 〉}_s+{0^{\perp \mathrm{.2}}〉}_a{1〉}_b{1〉}_c\dots +{0^{\perp \mathrm{.1}}〉}_a{2〉}_b{2〉}_c\dots \underset{{\mathrm{ADD}}_{\mathrm{ca}}}{\to }{0〉}_a{-2〉}_b{0〉}_cH_2H_1{\psi 〉}_s+{0^{\perp \mathrm{.2}}〉}_a{1〉}_b{2〉}_c\dots +{0^{\perp \mathrm{.1}}〉}_a{2〉}_b{3〉}_c\dots & \left(23\right)\end{array}$

In the above, negative integers correspond to the trailing bit q_nb−1=1 so U_k in Eq. (21) is not applied. Note that Eq. (20) applies H_k . . . H₁ controlled on |k_b, so one can simply relabel k=l_b+1 mod 2^nb.

Proof of Theorem 1. Thus DYS_K may be implemented with reduced ancilla overhead through Lemma 2 provided that one finds a sequence {U_k} such that H_k . . . H₂H₁∝B_k—in other words,

$\begin{array}{cc}{\left({〈0}_{\mathrm{ac},\mathrm{others}}\otimes I_{\mathrm{bs}}\right){\mathrm{DYS}}_K(0〉}_{\mathrm{ac},\mathrm{others}}\otimes I_{\mathrm{bs}})=\sum _{k=0}^Kk〉{〈k}_b\otimes {\gamma }_kB_k,& \left(24\right)\end{array}$

where ‘others’ represent registers with size independent of K, and γ_k is a scaling factor depends on the choice of U_k. This sequence is obtained by combining three matrices. First, a unitary matrix U that prepares a uniform superposition

${{U|0〉}_d={\sum }_{m=0}^{M-1}\frac{1}{\sqrt{M}}m〉}_d.$

Second, the block-diagonal matrix D=Σ_m=0^M−1|mm|⊗H(Δm) implemented by HAM-T. Third, a strictly upper-triangular matrix G ∈^M×M with elements

$\begin{array}{cc}{G}_{\mathrm{ij}}=\{\begin{array}{cc}\frac{1}{M},& i<j,\\ 0& \mathrm{otherwise},\end{array}G=\frac{1}{M}\sum _{i=0}^{M-1}\sum _{j=i+1}^{M-1}i〉〈j.& \left(25\right)\end{array}$

The non-unitary triangular operator G is implemented by using an integer comparator COMP acting on registers d, e, f consisting of n_d=n_e and n_f=1 qubits. For any input number state index |j_d, let one compare j with a uniform superposition state

${{\sum }_{i=0}^{M-1}\frac{1}{\sqrt{M}}i〉}_e.$

Conditional on i≥j, perform a NOT gate on register f. One can then swap registers d,e, and unprepare the uniform superposition. On input |j_d|0_e|0_f, this implements the sequence.

$\begin{array}{cc}{{{{{j〉}_d0〉}_e0〉}_f\underset{U\mathrm{on}e}{\to }\frac{{j〉}_d}{\sqrt{M}}\sum _{i=0}^{M-1}{i〉}_e0〉}_f\underset{\mathrm{COMP}}{\to }\frac{{|j〉}_d}{\sqrt{M}}\sum _{i=0}^{M-1}|i〉}_e|i\ge {\hspace{1em}j〉}_f\underset{{\mathrm{SWAP}}_{d\in }}{\to }& \left(26\right)\\ {{{{{\frac{{|j〉}_e}{\sqrt{M}}\sum _{i=0}^{M-1}|i〉}_d|i\ge j〉}_f\underset{{U^{†}}_{\mathrm{on}e}}{\to }\frac{1}{M}\sum _{i=0}^{M-1}|i〉}_d|0〉}_e|i\ge j〉}_f+\dots ,& \end{array}$

where |i≥j_f=|1_f if i≥j and is |0_f if i<j. This defines the following circuit that encodes G.

$\begin{array}{cc}\mathrm{LT}=\left(I_f\otimes U\otimes I_d\right)·\mathrm{COMP}·\left(I_f\otimes {\mathrm{SWAP}}_{\mathrm{de}}\right)·\left(I_f\otimes U^{†}\otimes I_d\right),{\hspace{1em}\left({〈0}_{\mathrm{ef}}\otimes I_d\right)\mathrm{LT}(0〉}_{\mathrm{ef}}\otimes I_d)=\frac{1}{M}\sum _{i=0}^{M-1}\sum _{j=i+1}^{M-1}i〉{〈j}_d.& \left(27\right)\end{array}$

The gate complexity of G is dominated by the comparator COMP, which costs (n_d) primitive quantum gates.

FIG. 5 is a schematic block diagram showing quantmn circuit representations of the unitary DYS_K that encodes time-ordered products of Hamiltonians, using fewer ancilla than the construction in FIG. 2 by applying the compression gadget in FIG. 4.

One may then verify that the terms B_k are generated by the following sequence

$\begin{array}{cc}{〈0{}_dU^{†}·D·U0〉}_d=\frac{B_1}{M}=\frac{1}{M}\sum _{m_1=0}^{M-1}H\left(\Delta m\right),& \left(28\right)\\ {〈0{}_dU^{†}·\left(D·G\right)·D·U0〉}_d=\frac{B_2}{M^2}=\frac{1}{M^2}\sum _{0\le m_1<m_2<M}^{}H\left(\Delta m_2\right)H\left(\Delta m_1\right),& \\ ⋮& \\ {〈0{}_dU^{†}·{\left(D·G\right)}^{k-1}·D·U0〉}_d=\frac{B_k}{M^k}=& \\ \frac{1}{M^k}\sum _{0\le m_1<m_2<\dots m_j<M}^{}H\left(\Delta m_j\right)\dots H\left(\Delta m_2\right)\dots H\left(\Delta m_1\right).& \end{array}$

Thus one can make the choice

$\begin{array}{cc}{U}_k:=\{\begin{array}{cc}\left(U^{†}\otimes I_{\mathrm{aefs}}\right)·\left(\mathrm{HAM}\text{-}T\otimes I_{\mathrm{ef}}\right)·\left(U\otimes I_{\mathrm{aefs}}\right),& k=1,\\ \left(U^{†}\otimes I_{\mathrm{aefs}}\right)·\left(\mathrm{HAM}\text{-}T\otimes I_{\mathrm{ef}}\right)·\left(\mathrm{LT}\otimes I_{\mathrm{as}}\right)·\left(U\otimes I_{\mathrm{aefs}}\right),& k>1.\end{array}& \left(29\right)\end{array}$

Combined with Lemma 2, this leads to the circuit of FIG. 5, which implements DYS_K in Eq. (24) by identifying ‘others’ with the e and f registers, and scaling factor

${\gamma }_k=\frac{1}{M^k}.$

$\begin{array}{cc}\left({〈0}_{\mathrm{acef}}\otimes I_{\mathrm{bs}}\right){\mathrm{DYS}}_K\left({0〉}_{\mathrm{acef}}\otimes I_{\mathrm{bs}}\right)=\sum _{k=0}^Kk〉{〈k}_b\otimes \frac{B_k}{M^k},& \left(30\right)\end{array}$

One can then select the desired linear combination of different orders in the Dyson series with the state

$\begin{array}{cc}{\mathrm{COEF}}_K{0〉}_b=\frac{1}{\sqrt{\beta }}\sum _{k=0}^K\sqrt{{\left(-\mathrm{it}\right)}^k}{k〉}_b,& \left(31\right)\\ {\mathrm{COEF}}_K^{\prime }{0〉}_b=\frac{1}{\sqrt{\beta }}\sum _{k=0}^K\sqrt{t^k}{k〉}_b,\beta =\sum _{j=0}^Kt^k\le \sum _{k=0}^{\infty }t^k=\frac{1}{1-t}.& \left(32\right)\end{array}$

where one assumes that t<1 for convergence. Thus by choosing t=⊖(1)≈½, the success probability of approximating e^{−1∫0tH(s)ds} may be boosted from β²=4to 1−(ϵ) using a single round of oblivious amplitude amplification. □

IV. Accelerated Interaction Picture Simulation

Time-independent Hamiltonians H become time-dependent H_I(t) in the interaction picture. This requires the use of time-dependent Hamiltonian simulation algorithm, which scale with parameters of H_I(t) that differ from those for the time-independent case. For certain broad classes of Hamiltonian identified in Section IV A, these different dependencies allow us to improve the gate complexity of approximating the time-evolution operator e^−iHt by instead performing simulation in the interaction picture using the truncated Dyson series algorithm Theorem 1.

The interaction picture can be viewed as an intermediate between the Schrödinger and Heisenberg pictures wherein some of the dynamics is absorbed into the state and the remainder is absorbed into the dynamics of the operators. If the Hamiltonian in the Schrödinger picture is H=A+B and |φ(t)=e^−iHt|φ(0) then the Hamiltonian in the interaction picture is H_I(t)=e^iAtBe^−iAt and i∂_t|φ_I(t)=H_I(t)|φ_I(t) with |φ_I(t)=e^iAt|φ(t) for all t. These relations can easily be seen by substituting into the Schrödinger equation:

$\begin{array}{cc}i{\partial }_t{\psi }_I\left(t\right)〉=i{\partial }_t\left(e^{\mathrm{iAt}}\psi \left(t\right)〉\right)=e^{\mathrm{iAt}}\left(-A+H\right)\psi \left(t\right)〉=e^{\mathrm{iAt}}{\mathrm{Be}}^{-\mathrm{iAt}}e^{\mathrm{iAt}}\psi \left(t\right)〉=H_I\left(t\right){\psi }_I\left(t\right)〉.& \left(33\right)\end{array}$

Note that if one started with time-dependent B(t), that is H(t)=A+B(t), the interaction picture Hamiltonian is H_I(t)=e^iAtB(t)e^−iAt. The following results generalize easily to this situation, and so one can consider time-independent B for simplicity.

The advantage of this representation is a Hanmiltonian with a smaller norm ∥H(t)∥=∥B∥≤∥A∥+∥B∥, but at the price of introducing time-dependence. In general, one cannot write a closed form expression for the time-evolution operator. The following notation is commonly used to express the time evolution operator [e^{−i∫0tH(s)ds}]=lim_r→∞II_j=1^re^{−iH(jt/r)t/r} where this product is implicitly defined to be time ordered. Given an initial state |φ(0), the state after evolution for t>0 may thus be written as

$\begin{array}{cc}\psi \left(t\right)〉=e^{-\mathrm{iAt}}{\psi }_I\left(t\right)〉=e^{-\mathrm{iAt}}\left[e^{-i{\int }_0^tH_I\left(s\right)\mathrm{ds}}\right]{\psi }_I\left(0\right)〉=e^{-\mathrm{iAt}}\left[e^{-i{\int }_0^tH_I\left(s\right)\mathrm{ds}}\right]\psi \left(0\right)〉={\left(e^{-\mathrm{iAt}}\left[e^{-i{\int }_0^tH_I\left(s\right)\mathrm{ds}}\right]\right)}^L\psi \left(0\right)〉,& \left(34\right)\end{array}$

and evolution by the full duration is decomposed into evolution by L shorter segments of duration .

Using the simulation algorithm Theorem 1 to simulate each segment in Eq (34) leads to the following result

Lemma 3 (Query complexity of Hamiltonian simulation in the interaction picture). For any Hamiltonian H=A+B, let HAM-T be a unitary oracle that encodes H_I(t)=e^iAtBe^−iAt at

$M=\left(\frac{t}{ϵ}\frac{A}{{\alpha }_B}\right)$

uniformly spaced values of t ∈[0,=(α_B⁻¹)].

$\begin{array}{cc}\left({〈0}_a\otimes I_s\right)\mathrm{HAM}\text{-}T\left({0〉}_a\otimes I_s\right)=\sum _{m=0}^{M-1}m〉{〈m}_b\otimes \frac{e^{\mathrm{iA\tau m}/M}{\mathrm{Be}}^{-\mathrm{iA\tau m}/M}}{{\alpha }_B},{\alpha }_B\ge B.& \left(35\right)\end{array}$

Then e^−iHt may be approximated to error ϵ using

$1.\mathrm{Queries}\mathrm{to}\mathrm{HAM}\text{-}T\text{:}\left({\alpha }_Bt\frac{\log \left({\alpha }_Bt/ϵ\right)}{\log \log \left({\alpha }_Bt/ϵ\right)}\right).2.\mathrm{Queries}\mathrm{to}e^{-\mathrm{iA}\tau }\text{:}\left({\alpha }_Bt\right).3.\mathrm{Qubits}\text{:}n_s+\left(n_a+\log \left(M\right)\right).4.\mathrm{Primitive}\mathrm{gates}\text{:}\left(\left(n_a+\log \left(M\right)\right){\alpha }_Bt\frac{\log \left({\alpha }_Bt/ϵ\right)}{\log \log \left({\alpha }_Bt/ϵ\right)}\right).$

Proof. The number of segments L=(α_Bt) in Eq. (34) is determined by a normalization constant α_B≥max_t∥H_I(t)|=∥B∥, and so each segment is of size =(α_B⁻¹). After rescaling ϵ→ϵ/L by the number of segments, the total query complexity is obtained from the truncated Dyson series algorithm Theorem 1. Using the facts max_s ∥H_I(s)∥≤∥B∥, ∥H∥=∥[A,B]∥≤2∥A∥∥B∥, and =(α_B⁻¹), it suffices to choose

$\begin{array}{cc}M=\left(\frac{{\alpha }_Bt{\tau }^2}{ϵ}\left(\frac{〈\stackrel{.}{H}〉}{{\alpha }_B}+\frac{{\max }_s{H\left(s\right)}^2}{{\alpha }_B^2}\right)\right)=\left(\frac{t}{ϵ}\frac{A}{{\alpha }_B}\right).& \left(36\right)\end{array}$

Each segment is simulated

$\left(\frac{\log \left({\alpha }_Bt/ϵ\right)}{\log \log \left({\alpha }_Bt/ϵ\right)}\right)$

queries to HAM-T, thus simulation for the full duration has query complexity

$\left({\alpha }_Bt\frac{\log \left({\alpha }_Bt/ϵ\right)}{\log \log \left({\alpha }_Bt/ϵ\right)}\right).$

A. Comparison with Simulation of Time-Independent Hamiltonians in the Schrödinger Picture

The cost of simulation in the interaction picture using the truncated Dyson series is now compared with state-of-art simulation in the Schrödinger picture with time-independent Hamiltonians using the truncated Taylor series approach outlined in section X A. Up to logarithmic factors, this comparison is valid as the truncated Taylor series algorithm cost differs from optimal algorithms by only logarithmic factors.

For any Hamiltonian H=A+B, let us assume access to the oracles

$\begin{array}{cc}\left({〈0}_a\otimes I_s\right)O_A\left({0〉}_a\otimes I_s\right)=\frac{A}{{\alpha }_A},\left({〈0}_a\otimes I_s\right)O_B\left({0〉}_a\otimes I_s\right)=\frac{B}{{\alpha }_B},& \left(37\right)\end{array}$

which have gate complexity C_A,C_B respectively. The gate complexity of time-independent simulation e^−i(A+B)t is then

$\begin{array}{cc}\begin{array}{c}{C}_{\mathrm{TTS}}=\left(\left(C_A+C_B+n_a\right)\left({\alpha }_A+{\alpha }_B\right)t\frac{\log \left(\left({\alpha }_A+{\alpha }_B\right)t/ϵ\right)}{\log \log \left(\left({\alpha }_A+{\alpha }_B\right)t/ϵ\right)}\right)\\ =\left(\left(C_A+C_B+n_a\right)\left({\alpha }_A+{\alpha }_B\right)\mathrm{tpoly}\log \left({\alpha }_A,{\alpha }_B,t,ϵ\right)\right).\end{array}& \left(38\right)\end{array}$

In the interaction-picture, one can prove the following theorem

Theorem 3 (Gate complexity of Hamiltonian simulation in the interaction picture). For any Hamiltonian H=A+B, let

• • 1. C_B be the gate cost of implementing the oracle

$\left({〈0}_a\otimes I_s\right)O_B\left({0〉}_a\otimes I_s\right)=\frac{B}{{\alpha }_B}.$

• • 2. C_e−iAt[ϵ]=(|t|polylog(t,ϵ)) be the gate cost of approximating e^−iAt to error ϵ.Then the total gate complexity of simulating e^−iHt is

C _TDS=((C_B+C_eiAt[ϵ]+n_α)α_Btpolylog(∥A∥,α_B,t,ϵ)).  (39)

Proof. let C_HAM-T|ϵ| be the gate complexity of approximating HAM-T in Eq. (35) to error ϵ. Then from Lemma 3, the total gate complexity of simulating e^−iHt=(e^−iAt[e^{−i∫0tHI(s)ds}])^t/T, T=(α_B⁻¹), is

$\begin{array}{cc}\left(\left(C_{\mathrm{HAM}\text{-}T}\left[\frac{{\alpha }_Bt}{ϵ}\right]+n_a+\log \left(\frac{At}{{\mathrm{ϵ\alpha }}_B}\right)\right)\left({\alpha }_Bt\frac{\log \left({\alpha }_Bt/ϵ\right)}{\log \log \left({\alpha }_Bt/ϵ\right)}\right)\right).& \left(40\right)\end{array}$

One possible decomposition of HAM-T is

$\begin{array}{cc}\mathrm{HAM}\text{-}T=& \left(41\right)\\ \left(\sum _{m=0}^{M-1}m〉{〈m}_d\otimes I_a\otimes e^{\mathrm{iA}\tau m/M}\right)·\left(I_d\otimes O_B\right)·\left(\sum _{m=0}^{M-1}m〉{〈m}_d\otimes I_a\otimes e^{-\mathrm{iA}\tau m/M}\right).& \left(42\right)\end{array}$

Using C_e−iAt[ϵ]=(|t| polylog(t, ϵ)), synthesis of Σ_m=0^M−1|mm|_d⊗e^iArm/M by exponentiated power of controlled-e^iAt/M,e^iA2t/M,e^iA4t/M, . . . , e^{iA2└log2(M)┘T/M}, has cost C_eiAt2j/M[ϵ/log (M)]=(C_eiAt[ϵ/log (M)]). Thus C_HAM-T[ϵ]=(C_B+C_eiAt[ϵ/log (M))]). □

From comparing Eqs. (38) and (39), one may iminediately state sufficient criteria for when simulation in the interaction picture is advantageous over simulation in the Schrödinger picture.

• • 1. The upper bound on the spectral norms α_A≥∥A∥, α_B≥∥A∥ of the encoding in Eq. (37) satisfy α_A»α_B. Generally speaking, this is correlated with term A representing fast dynamics ∥A∥»∥B∥.
  • 2. The gate complexity of time-evolution by A alone for time =(α_B⁻¹) is comparable to that of synthesizing the oracle O_B, that is C_eiAαB−1=(C_B).Note that satisfying condition (2) depends strongly on the structure of A, B. For instance, a simulation of A for time =(α_B⁻¹) using generic time-independent techniques has gate complexity (C_AαA/α_B). As the interest is in the case ∥A∥/∥B∥»1, this quantity could be large and scale poorly with the problem size. One sufficient possibility is the very strong assumption that e^−iAt is cheap and can be fast-forwarded., such that the gate complexity C_e−iAt[ϵ]=(polylog(t,ϵ)) is constant up to logarithmic factor. This turns out to be a reasonable assumption in the application to next consider.

V. Application to the Hubbard Model with Long-Ranged Interactions

One can now apply the technology developed in Section III and Section IV for Hamiltonian simulation in the interaction picture to physical problems of practical interest. Here, the focus is on the Hubbbard model in d-dimensions with N lattice sites subject to local disorder and translational-invariant two-body couplings that may be long-ranged in general. One can perform a gate complexity comparison with simulation by time-independent techniques, and later in Section V A, this model is specialized to that of quantum chemistry simulations in the plane-wave and dual basis.

The Hubbard Hamiltonian considered has the form H=T+U+V, where T is the kinetic energy hopping operator, U is the local single-site potential, and V is a symmetric translationally-invariant two-body density coupling term between opposite spins. In the dual basis, H is expressed in terms of single-site Fermionic creation and annihilation operators {α_{{right arrow over (x)}σ}, α_{{right arrow over (y)}σ′}}={α_{{right arrow over (x)}σ}⁵⁵⁴ , α_{{right arrow over (y)}σ′}⁵⁵⁴ }=0, {α_{{right arrow over (x)}σ}, α_{{right arrow over (y)}σ′}⁵⁵⁴ }=δ_{{right arrow over (x)}{right arrow over (y)}}δ_σσ′, and the number operator n_{{right arrow over (x)}σ}=α_{{right arrow over (x)}σ}⁵⁵⁴ α_{{right arrow over (x)}σ}. The subscript {right arrow over (x)} ∈ [−N^1/d,N^1/d]^d indexes one of N lattice sites in d dimensions, and σ ∈ {−1,1} is a spin-½ index. Explicitly,

$\begin{array}{cc}H=\sum _{\overrightarrow{x},\overrightarrow{y},\sigma }T\left(\overrightarrow{x}-\overrightarrow{y}\right)a_{\overrightarrow{x}\sigma }^{†}a_{\overrightarrow{y}\sigma }+\sum _{\overrightarrow{x},\sigma }U\left(\overrightarrow{x},\sigma \right)n_{\overrightarrow{x}\sigma }+\sum _{\left(\overrightarrow{x},\sigma \right)\ne \left(\overrightarrow{y},{\sigma }^{\prime }\right)}V\left(\overrightarrow{x}-\overrightarrow{y}\right)n_{\overrightarrow{x}\sigma }n_{\overrightarrow{y}{\sigma }^{\prime }},& \left(43\right)\end{array}$

where the coefficients T({right arrow over (s)}), U({right arrow over (s)},σ), V({right arrow over (s)}) are real functions of the lattice index {right arrow over (s)} ∈ [−N^1/d,N^1/d]^d.

Further simplification of Eq. (43) is possible as the kinetic energy operator is diagonal in the plane-wave basis. This basis related to the dual basis by a unitary rotation FFFT, an acronym for ‘Fast-Fermionic-Fourier-Transform’ that implements a Fourier transform over the lattice site indices, resulting in Fermionic creation and annihilation operators c_{{right arrow over (p)}σ}⁵⁵⁴ , c_{{right arrow over (p)}σ}.

$\begin{array}{cc}{c}_{\overrightarrow{p}\sigma }=\frac{1}{\sqrt{N}}\sum _{\overrightarrow{x}}a_{\overrightarrow{x}\sigma }e^{i2\pi \overrightarrow{p}·\overrightarrow{x}/N^{1/d}}={\mathrm{FFFT}}^{†}a_{\overrightarrow{p}\sigma }\mathrm{FFFT},& \left(44\right)\\ c_{\overrightarrow{p}\sigma }^{†}=\frac{1}{\sqrt{N}}\sum _{\overrightarrow{x}}a_{\overrightarrow{x}\sigma }^{†}e^{-i2\pi \overrightarrow{p}·\overrightarrow{x}/N^{1/d}}={\mathrm{FFFT}}^{†}a_{\overrightarrow{p}\sigma }^{†}\mathrm{FFFT},& \left(45\right)\end{array}$

By substituting the Fourier transform of the kinetic term

$T\left(\overrightarrow{s}\right)=\frac{1}{N}{\sum }_{\overrightarrow{p}}\tilde{T}\left(\overrightarrow{p}\right)e^{-i2\pi \overrightarrow{p}·\overrightarrow{s}/N^{1/d}},$

an equivalent expression for the Hubbard Hamiltonian is

$\begin{array}{cc}H={\mathrm{FFFT}}^{†}·\left(\sum _{\overrightarrow{x},\sigma }\tilde{T}\left(\overrightarrow{x}\right)n_{\overrightarrow{x}\sigma }\right)·\mathrm{FFFT}+\sum _{\overrightarrow{x},\sigma }U\left(\overrightarrow{x},\sigma \right)n_{\overrightarrow{x}\sigma }+\sum _{\left(\overrightarrow{x},\sigma \right)\ne \left(\overrightarrow{y},{\sigma }^{\prime }\right)}V\left(\overrightarrow{x}-\overrightarrow{y}\right)n_{\overrightarrow{x}\sigma }n_{\overrightarrow{y}{\sigma }^{\prime }},& \left(46\right)\end{array}$

where each term is now diagonal in their respective bases.

A simulation of this Hamiltonian on a qubit quantum computer requires a map from its Fermionic operators to spin operators. One possibility is the Jordan-Wigner transformation, which requires some map from Fermionic indices to spin indices, such as

$f\left(\overrightarrow{x},\sigma \right)=N\frac{1-\sigma }{2}+\left({\sum }_{j=0}^{d-1}{\overrightarrow{x}}_jN^{j/d}\right).$

Subsequently, one can replace

$\begin{array}{cc}{a}_{\overrightarrow{x}\sigma }^{†}->\frac{1}{2}\left(X_{f\left(\overrightarrow{x},\sigma \right)}-{\mathrm{iY}}_{f\left(\overrightarrow{x},\sigma \right)}\right)\underset{j=0}{\stackrel{f\left(\overrightarrow{x},\sigma \right)-1}{\otimes }}Z_j,a_{\overrightarrow{x}\sigma }->\frac{1}{2}\left(X_{f\left(\overrightarrow{x},\sigma \right)}+{\mathrm{iY}}_{f\left(\overrightarrow{x},\sigma \right)}\right)\underset{j=0}{\stackrel{f\left(\overrightarrow{x},\sigma \right)-1}{\otimes }}Z_j.& \left(47\right)\end{array}$

Note the very useful property where number operators map to single-site spin operators n_{{right arrow over (x)}σ}→½(I−Z_{∫({right arrow over (x)},σ)}) (under this encoding. Moreover, FFFT, can be implemented using (N log (N)) primitive quantum gates in the Jordan-Wigner representation.

Now evaluate the worst-case gate-complexity for time-evolution by H in the Schrödinger picture. As an example of state-of-art using the truncated Taylor series approach in Section X A, e^−i(T+U+V)t may be simulated using ((α_T+α_U+α_V)t log (1/ϵ)) queries to oracles that encode T, U, and V.

$\begin{array}{cc}{(〈0}_a\otimes I_s)O_T\left({0〉}_a\otimes I_s\right)=\frac{T}{{\alpha }_T},{(〈0}_a\otimes I_s)O_U\left({0〉}_a\otimes I_s\right)=\frac{U}{{\alpha }_U},{(〈0}_a\otimes I_s)O_V\left({0〉}_a\otimes I_s\right)=\frac{V}{{\alpha }_V}.& \left(48\right)\end{array}$

The cost of simulation depends strongly on the coefficients {tilde over (T)} ({right arrow over (p)}), U ({right arrow over (x)}), V ({right arrow over (x)}). The most straightforward approach synthesizes these oracles using the linear-combination of unitaries outline in Eq. (6). For instance, O_T=(PREP_T^†⊗FFFT^†)·SEL_T·(PREP_T⊗FFFT), where

$\begin{array}{cc}{\mathrm{PREP}}_T{0〉}_a=\sum _{\overrightarrow{p},\sigma }\sqrt{\frac{\tilde{T}\left(\overrightarrow{p}\right)}{{\alpha }_T}}{\overrightarrow{p},\sigma 〉}_a,{\mathrm{SEL}}_T=\sum _{\overrightarrow{p},\sigma }\overrightarrow{p},\sigma 〉{〈\overrightarrow{p},\sigma }_a\otimes n_{\overrightarrow{p}\sigma },{\alpha }_T=\sum _{\overrightarrow{p},\sigma }\tilde{T}\left(\overrightarrow{p}\right).& \left(49\right)\end{array}$

and similarly for U and V. As there are (N) distinct coefficients in the worst-case, each of PREP_T,U,V costs (N). As V has (N²) terms, SEL_V has the largest cost of (N²). Thus overall gate complexity is (N²(α_T+α_U+α_V)t log (1/ϵ)). As there are (N²) coefficients, max{α_T, α_U, α_V}=(α_T+N²), and so the cost of simulation is

(N²(α_T+N²)t log (1/ϵ)).  (50)

The worst-case gate-complexity may be substantially improved by instead simulating H in the interaction picture using the truncated Dyson series algorithm in Section III. The key idea is to simulate in the rotating frame of the interactions e^−i(U+V)t, where the Hamiltonian becomes a time-dependent H_I(t)=e^i(U+V)t_Te^−i(U+V)t. Using the same oracle O_T in Eq. (48) for the kinetic term, the cost of time-evolution e^−i(T+U+V)t by this technique is given by Eq. (39):

$\begin{array}{cc}\begin{array}{c}{C}_{\mathrm{TDS}}=(\left(C_T+C_{e^{i\left(U+V\right)/{\alpha }_{T+n_a}}}\left[ϵ\right]\right)\\ {\alpha }_T\mathrm{tpoly}\log \left(U+V,{\alpha }_T,t,ϵ\right))\\ =(\left(N+C_{e^{i\left(U+V\right)/{\alpha }_T}}\left[ϵ\right]\right)\\ {\alpha }_T\mathrm{tpoly}\log \left(N,U,V,{\alpha }_T,t,ϵ\right)).\end{array}& \left(51\right)\end{array}$

All that remains is to bound the cost of time-evolution by the term C_ei(U+V)/αT[ϵ]. Using the fact that this is diagonal in the Pauli Z basis, the Hamiltonian may be fast-forwarded and so has cost that is independent of the evolution time. Thus the most straightforward approach decomposes

$\begin{array}{cc}{e}^{i\left(U+V\right)t}=\left(\prod _{\overrightarrow{x},\sigma }e^{-\mathrm{iU}\left(\overrightarrow{x},\sigma \right)n_{\overrightarrow{x}\sigma }t}\right)\left(\prod _{\left(\overrightarrow{x},\sigma \right)\ne \left(\overrightarrow{y},\sigma \right)}e^{-\mathrm{iV}\left(\overrightarrow{x}-\overrightarrow{y}\right)n_{\overrightarrow{x}\sigma }n_{\overrightarrow{y}{\sigma }^{\prime }}t}\right).& \left(52\right)\end{array}$

There are (N²) exponentials, and so C_ei(U+V)t[ϵ]=(N²). Compared to Eq. (50), one can already see an improvement by a factor (N) in cases where the kinetic energy is extensive, that is α_T=(N), so C_TDS=(N²α_Ttpolylog(N, α_T, t, ϵ)).

A further improvement to

C _TDS=(Nα_Ttpolylog(N, α_T, t, ϵ))  (53)

is possible by a more creative evaluation of the gate complexity of e^i(U+V)t to reduce its cost from (N²) to (N log (N)). Clearly, C_eiUt=(N) with N commuting terms poses no problem. The difficulty lies in constructing time-evolution by the two-body term e^iVt such that C_eiVt=(N log N). As V is a sum of (N²) commuting terms, a gate cost (N²) appear unavoidable. However, this may be reduced by exploiting the translation symmetry of its coefficients with a discrete Fourier transform. As V({right arrow over (x)})=V(−{right arrow over (x)}) is real and symmetric, its discrete Fourier transform {tilde over (V)}({right arrow over (k)})=Σ_{{right arrow over (x)}}V({right arrow over (x)})e^{i2π{right arrow over (x)}·{right arrow over (k)}/N1/d} only has real coefficients. Let one re-write V from Eq. (43) as

$\begin{array}{cc}V=\sum _{\left(\overrightarrow{x},\sigma \right)\ne \left(\overrightarrow{y},\sigma \right)}V\left(\overrightarrow{x}-\overrightarrow{y}\right)n_{\overrightarrow{x}\sigma }n_{\overrightarrow{y}{\sigma }^{\prime }}=\sum _{\left(\overrightarrow{x},\sigma \right)\ne \left(\overrightarrow{y},\sigma \right)}\frac{1}{N}\sum _{\overrightarrow{k}}\tilde{V}\left(\overrightarrow{k}\right)e^{{}^{-i2\pi \left(\overrightarrow{x}-\overrightarrow{y}\right)·\overrightarrow{k}/N}}n_{\overrightarrow{x}\sigma }n_{\overrightarrow{y}{\sigma }^{\prime }}=\sum _{\overrightarrow{k}}\frac{\tilde{V}\left(\overrightarrow{k}\right)}{N}\left(\sum _{\left(\overrightarrow{x},\sigma \right),\left(\overrightarrow{y},{\sigma }^{\prime }\right)}e^{{}^{-i2\pi \left(\overrightarrow{x}-\overrightarrow{y}\right)·\overrightarrow{k}/N}}n_{\overrightarrow{x},\sigma }n_{\overrightarrow{y},{\sigma }^{\prime }}-\sum _{\overrightarrow{x},\sigma }n_{\overrightarrow{x}\sigma }\right)=\sum _{\overrightarrow{k}}\tilde{V}\left(\overrightarrow{k}\right)\underset{{\tilde{\chi }}_k}{\underset{}{\left(\frac{1}{\sqrt{N}}\sum _{\overrightarrow{x}}e^{{}^{-i2\pi \overrightarrow{x}·\overrightarrow{k}/N}}\sum _{\sigma }n_{\overrightarrow{x},\sigma }\right)}}\underset{{\tilde{\chi }}_k^{†}}{\underset{}{\left(\frac{1}{\sqrt{N}}\sum _{\overrightarrow{y}}e^{{}^{i2\pi \overrightarrow{y}·\overrightarrow{k}/N}}\sum _{{\sigma }^{\prime }}n_{\overrightarrow{y},{\sigma }^{\prime }}\right)}}-\sum _{\overrightarrow{p},\sigma }\left(\sum _{\overrightarrow{k}}\tilde{V}\left(\tilde{k}\right)\right)n_{\overrightarrow{p},\sigma }.& \left(54\right)\end{array}$

The strategy for implementing e^−iVt is based on the following observation: Suppose one had a unitary oracle O_{{right arrow over (A)}}|j|0_o|0_garb=|j|A_jo|g(j)_garbage that on input |j ∈^{dim[{right arrow over (A)}]}, outputs on the l quoit o register, the value of the j^th element of some complex vector {right arrow over (A)}, together with some garbage state |g(j)_garb of lesser interest required to make the operation reversible. One may then perform a phase rotation that depends on A_j as follows:

$\begin{array}{cc}j〉{0〉}_o{0〉}_{\mathrm{garb}}0〉\underset{O_{\overrightarrow{A}}}{\to }j〉{A_j〉}_o{g\left(j\right)〉}_{\mathrm{garb}}0〉\underset{\mathrm{PHASE}}{\to }e^{-{\mathrm{iA}}_jt}j〉{A_j〉}_o{g\left(j\right)〉}_{\mathrm{garb}}0〉\underset{O_{\overrightarrow{A}}^{†}}{\to }e^{-{\mathrm{iA}}_jt}j〉{0〉}_o{0〉}_{\mathrm{garb}}0〉.& \left(55\right)\end{array}$

If A_j were represented in binary, say, A_j=Σ_k=0^l−1q_k2^−k, PHASE could be implemented using (l) controlled-phase |00|⊗I+|11|⊗e^−it2−kZ rotations.

Thus, one can construct a unitary O_V,binary with the property that

$\begin{array}{cc}{O}_{V,\mathrm{binary}}\left(\underset{\overrightarrow{x},\sigma }{\otimes }n_{\overrightarrow{x},\sigma }〉\right)0〉{0〉}_{\mathrm{garb}}=\left(\underset{\overrightarrow{x},\sigma }{\otimes }n_{\overrightarrow{x},\sigma }〉\right)f\left(\overrightarrow{n}\right)〉{g\left(\overrightarrow{n}\right)〉}_{\mathrm{garb}},f\left(\overrightarrow{n}\right)=\sum _{\left(\overrightarrow{x},\sigma \right)\ne \left(\overrightarrow{y},{\sigma }^{\prime }\right)}V\left(\overrightarrow{x}-\overrightarrow{y}\right)n_{\overrightarrow{p}\sigma }n_{\overrightarrow{q}{\sigma }^{\prime }},& \left(56\right)\end{array}$

where the value ƒ({right arrow over (n)}) is encoded in l=(log(1/ϵ)) bits. This is implemented by the following sequence, where one has omitted the garbage register for clarity.

$\begin{array}{cc}\left(\underset{\overrightarrow{x},\sigma }{\otimes }n_{\overrightarrow{x},\sigma }〉\right)0〉\underset{\mathrm{ADD}}{\to }\underset{\overrightarrow{x}}{\otimes }\sum _{\sigma }n_{\overrightarrow{x},\sigma }〉\underset{\mathrm{FFT}}{\to }\underset{\overrightarrow{k}}{\otimes }{\tilde{\chi }}_{\overrightarrow{k}}〉\underset{{·}^2}{\to }\underset{\overrightarrow{k}}{\otimes }{{\tilde{\chi }}_{\overrightarrow{k}}}^2〉\underset{\times V_k}{\to }\underset{\overrightarrow{k}}{\otimes }V\left(\overrightarrow{k}\right){{\tilde{\chi }}_{\overrightarrow{k}}}^2〉,& \left(57\right)\end{array}$

The cost of O_V,binary may be expressed in term of the four standard reversible arithmetical operations, addition, subtraction, division, and multiplication, which each cost (poly(l)) primitive gates. The first steps ADD adds (N) pairs of two bits n_{{right arrow over (x)},σ=1} +n_{{right arrow over (x)},σ=1} and costs (N) arithmetic operations. The second step FFT is a d-dimensional Fast-Fourier-Transform on (N) binary numbers and requires (N log (N)) arithmetic operations. The third step computes the absolute-value-squared of (N) binary numbers, and uses (N) arithmetic operations. The last step multiplies each |{tilde over (x)}_k|² with the corresponding V_k, and costs (N) arithmetic operations. This last step may actually be avoided by rescaling the time parameter e^−iAjt→e^−iAjVkt in Eq. (55). Thus the total cost of O_V,binary is (N log (N) poly(l))=(N log(1/ϵ)). Using one query to O_V,binary, O_V,binary^†, and (N log(1/ϵ)) primitive quantum gates, one may thus apply e^−iVt with a phase error (ϵ) for a fixed value of t.

A. Application to Quantum Chemistry in the Plane-Wave Basis

The Hamiltonian that generates time-evolution for a state |φ(t) of interacting electrons in d=3 dimension consists of three operators: the electron kinetic energy T, the electron-nuclei potential energy U, and the electron-electron potential energy V. It has been demonstrated that this electronic structure Hamiltonian is a special case of the general Hubbard Hamiltonian of Eq. (46). In the plane-wave basis,

$\begin{array}{cc}i\partial \psi \left(t\right)〉=H\psi \left(t\right)〉H_P=\frac{1}{2}\sum _{\stackrel{->}{p},\sigma }{{\stackrel{->}{k}}_{\stackrel{->}{p}}}^2c_{\stackrel{->}{p},\sigma }^{†}c_{\stackrel{->}{p},\sigma }+\frac{4\pi }{\Omega }\sum _{\stackrel{->}{p}\ne \stackrel{->}{q}j,\sigma }(-{\zeta }_j\frac{e^{i{\stackrel{->}{k}}_{\stackrel{->}{q}-\stackrel{->}{p}}{\stackrel{->}{R}}_j}}{{{\stackrel{->}{k}}_{\stackrel{->}{p}-\stackrel{->}{q}}}^2}c_{\stackrel{->}{p},\sigma }^{†}c_{\stackrel{->}{p},\sigma }+\frac{2\pi }{\Omega }\sum _{\left(\stackrel{->}{p},\sigma \right)\ne \left(\stackrel{->}{q},{\sigma }^{\prime }\right)\stackrel{->}{v}\ne 0}\frac{c_{\stackrel{->}{p},\sigma }^{†}c_{\stackrel{->}{q},{\sigma }^{\prime }}^{†}c_{\stackrel{->}{q}+\stackrel{->}{v},{\sigma }^{\prime }}c_{\stackrel{->}{p}-\stackrel{->}{v},\sigma }}{{{\stackrel{->}{k}}_{\stackrel{->}{v}}}^2},& \left(58\right)\end{array}$

where k_{{right arrow over (p)}}=2π{right arrow over (p)}/Ω^1/3, {right arrow over (p)} ∈ [−N^1/3,N^1/3]³, r_{{right arrow over (p)}}={right arrow over (p)}(Ω/N)^1/3, Ω represents the volume of the simulation, and n_j is the nuclear charge of the j^th nucleus. Whereas T is diagonal here, one may find an alternate basis where U and V are diagonal. This is the dual basis, defined through the unitary transform FFFT of Eq. (44). In this basis, let us define the state |φ_D(t)=FFFT^†|φ(t), which evolves under the Hamiltonian H, which is of exactly that of Eq. (46), with coefficients

$\begin{array}{cc}\tilde{T}\left(\stackrel{->}{p}\right)=\frac{1}{2}{{\stackrel{->}{k}}_{\stackrel{->}{p}}}^2U\left(\stackrel{->}{p}\right)=-\frac{4\pi }{\Omega }\sum _{\stackrel{->}{v}\ne 0,j}\frac{{\zeta }_j\cos \left[{\stackrel{->}{k}}_{\stackrel{->}{v}}·\left({\stackrel{->}{R}}_{\stackrel{->}{j}}-{\stackrel{->}{r}}_{\stackrel{->}{p}}\right)\right]}{{{\stackrel{->}{k}}_{\stackrel{->}{v}}}^2},V\left(\stackrel{->}{s}\right)=\frac{2\pi }{\Omega }\sum _{\stackrel{->}{v}\ne 0}\frac{\cos \left[{\stackrel{->}{k}}_{\stackrel{->}{v}}·{\stackrel{->}{r}}_{\stackrel{->}{s}}\right]}{{{\stackrel{->}{k}}_{\stackrel{->}{v}}}^2}.& \left(59\right)\end{array}$

Thus the cost of time-evolution by the electronic structure Hamiltonian e^−iHt using the interaction picture is given by Eq. (53). The only parameter that depends on the problem is the normalization factor

$\begin{array}{cc}{\alpha }_T=\sum _{\stackrel{->}{p},\sigma }\frac{{{\stackrel{->}{k}}_{\stackrel{->}{p}}}^2}{2}=\left({\int }_0^{N^{1/3}}\frac{p^2}{{\Omega }^{2/3}}\left(4\pi p^2\right)\mathrm{dp}\right)=\left(\frac{N^{5/3}}{{\Omega }^{2/3}}\right).& \left(60\right)\end{array}$

Thus the total gate complexity of time-evolution under the assumption of constant density (i.e. N/Ω∈O(1)) is

$\begin{array}{cc}{C}_{\mathrm{TDS}}=\left(\frac{N^{8/3}}{{\Omega }^{2/3}}t\mathrm{poly}\log \left(N,{\alpha }_T,t,ϵ\right)\right)=\widetilde{}\left(N^2t\log \left(1/ϵ\right)\right).& \left(61\right)\end{array}$

In contrast, the cost of simulation in the plane-wave dual basis by prior art Ryan Babbush, Nathan Wiebe, Jarrod McClean, James McClain, Hartmut Neven, and Garnet Kin Chan, “Low depth quantum simulation of electronic structure,” arXiv preprint arXiv:1706.00023, 2017, applies the ‘Qubitization’ technique (see Guang Hao Low and Isaac L Chuang, “Hamiltonian simulation by qubitization,” arXiv preprint arXiv:1610.06546, 2016) and has gate complexity that scales like Õ(N^11/3t), and also has a polynomial dependence on the nuclear charge n_j. Embodiments of the disclosed method outperform this, and notably depends only poly-logarithmically on the nuclear charges within the problem.

VI. Application to Sparse Hamiltonian Simulation

In this section, a complexity-theoretic perspective of the improvements that are enabled by simulation with the truncated Dyson series and simulation in the interaction picture are submitted. One can do so by evaluating the query complexity for the simulation of sparse Hamiltonians H. Such Hamiltonians of dimension N are called d-sparse if there are at most d=(polylog(N)) non-zero entries in every row, and the position and values of these entries may be efficiently output, in say a binary representation, by some classical circuit of size (polylog(N)). This abstract model is useful in quantum complexity theory as a natural generalization these classical circuits leads to unitary quantum oracles that can be queried to access the same information, but now in superposition. With this model, one can achieve inSection VIA time-dependent simulation with a square-root improvement with respect to the sparsity parameter, and gate complexity scaling with the average instead of worst-case rate-of-change ∥H∥. By moving to the interaction picture in Section VI B, one can find more efficient time-independent simulation algorithms for diagonally-dominant Hamiltonians.

This model assumes that the Hamiltonian is input to the simulation routine through two oracles: O_f and O_H. O_H is straight forward; it provides the values of the matrix elements of the Hamiltonian given a time index |t and indices |x, |y to for the row and column of H as follows

O _H |t,x,y,0)=|t,x,y,H_xy(t)  (62)

O_f provides the locations of the non-zero matrix elements in any given row or column of H. Specifically, let ƒ(x,j) give the column index of the j^th non-zero matrix element in row x if it exists and an appropriately chosen zero element if it does not. In particular, let r_t,j be the list of column indices of these non-zero matrix elements in row J. One can then define, with a time-index t,

O _ƒ |t,x,j =|t,x,ƒ_t(x,j).  (63)

A. Simulation of Sparse Time-Dependent Hamiltonians

Applying the truncated Dyson series simulation algorithm to sparse Hamiltonians requires us to synthesize HAM-T in Eq. (7) from these oracles O_H, O_F. This is possible by a straightforward construction.

Lemma 4 (Synthesis of HAM-T from sparse Hamiltonian oracles). Let an N×N time-dependent d-sparse Hamiltonian H(s) with max-norm ∥H∥_max:=max_s∥H(s)∥_max be defined on the interval s ∈[0, t] to n_p bits of precision. Then

$\begin{array}{cc}(〈0{}_a\otimes I_s)\mathrm{HAM}\text{-}T\left({0〉}_a\otimes I_s\right)=\sum _tt〉{〈t}_d\otimes \frac{H\left(t\right)}{d{H}_{m\mathrm{ax}}},& \left(64\right)\end{array}$

can be implemented with O(1) queries to O_f and O_H, and (poly(n_p)+log (N)) primitive gates.

Proof. Let U_col, U_row be the following unitary transformations

$\begin{array}{cc}{U}_{\mathrm{col}}{t〉}_d{k〉}_s{0〉}_a:={t〉}_d{\chi }_k\left(t\right)〉=\frac{1}{\sqrt{d}}\sum _{p\in r_k}{t〉}_d{k〉}_s{p〉}_{a_1}\left(\sqrt{\frac{H_{k,p}^{*}\left(t\right)}{{H}_{\mathrm{ma}x}}}{0〉}_{a_2}+\sqrt{1-\frac{H_{k,p}\left(t\right)}{{H}_{\mathrm{ma}x}}}{1〉}_{a_2}\right),& \left(65\right)\\ {〈0}_a{〈j}_s{〈t}_dU_{\mathrm{row}}^{†}:=〈{\stackrel{\_}{\chi }}_j\left(t\right){〈t}_d=\frac{1}{\sqrt{d}}\sum _{q\in r_j}\left(\sqrt{\frac{{\delta }_{j,q}H_{j,q}\left(t\right)+\left(1-{\delta }_{j,q}\right)H_{j,q}\left(t\right)}{{H}_{\mathrm{ma}x}}}{〈0}_{a_2}+\sqrt{1-\frac{H_{q,j}\left(t\right)}{{H}_{\mathrm{ma}x}}}{〈2}_{a_2}\right){〈j}_{a_1}{〈q}_s{〈t}_d,& \left(66\right)\\ 〈{\stackrel{\_}{\chi }}_j\left(t\right)|{\chi }_k\left(t\right)〉=\frac{\sqrt{H_{j,k}\left(t\right)H_{k,j}^{*}\left(t\right)}}{d{H}_{\mathrm{ma}x}}=\frac{H_{j,k}}{d{H}_{\mathrm{ma}x}}.& \left(67\right)\end{array}$

Let |φ=Σ_t,kα_t,k|t_d|k)_s. One then has that

$\begin{array}{cc}\begin{array}{c}\left[0〉{〈0}_a\otimes \right]U_{\mathrm{row}}^{†}·U_{\mathrm{col}}{t〉}_d\psi 〉{0〉}_a=0〉{〈0}_a\otimes \sum _{t^{\prime },j}\left(t^{\prime }〉{〈t^{\prime }}_d\otimes j〉{〈j}_s\right)\\ \sum _{t,k}a_{t,k}U_{\mathrm{row}}^{†}·U_{\mathrm{col}}{t〉}_d{k〉}_s{0〉}_a.\\ ={0〉}_a\sum _{t^{\prime },j}{t^{\prime }〉}_d{j〉}_s\sum _{t,k}a_{t,k}\left(〈{\chi }_j\left(t^{\prime }\right){〈t^{\prime }}_d)({t〉}_d{\chi }_k\left(t\right)〉\right)\\ =\sum _{j,k}a_{t,k}{0〉}_a{t〉}_d{j〉}_s\frac{H_{j,k}\left(t\right)}{d{H}_{\mathrm{ma}x}}=\frac{{0〉}_sH\left(t\right)\psi 〉}{d{H}_{\mathrm{ma}x}}.\end{array}& \left(68\right)\end{array}$

As this result holds for any input state |φ, the choice HAM-T=U_row^†·U_col satisfies Eq. (64).

The query cost then follows from the fact that U_col and U_row^†can be implemented using O(1) calls to O_ƒ. In particular, U_col can be prepared in the following steps:

$\begin{array}{cc}t〉k〉0〉\mapsto t〉k〉\frac{1}{\sqrt{d}}\sum _{=1}^d〉0〉t〉k〉\frac{1}{\sqrt{d}}\sum _{p\in r_k}p〉0〉t〉k〉\frac{1}{\sqrt{d}}\sum _{p\in r_k}p〉H_{k,p}\left(t\right)〉0〉\mapsto t〉k〉\frac{1}{\sqrt{d}}\sum _{p\in r_k}p〉H_{k,p}\left(t\right)〉\left(\sqrt{\frac{H_{k,p}^{*}\left(t\right)}{{H}_{\mathrm{ma}x}}}0〉+\sqrt{1-\frac{H_{k,p}\left(t\right)}{{H}_{\mathrm{ma}x}}}1〉\right)t〉k〉\frac{1}{\sqrt{d}}\sum _{p\in r_k}p〉\left(\sqrt{\frac{H_{k,p}^{*}\left(t\right)}{{H}_{\mathrm{ma}x}}}0〉+\sqrt{1-\frac{H_{k,p}\left(t\right)}{{H}_{\mathrm{ma}x}}}1〉\right)0〉=U_{\mathrm{col}}t〉k〉0〉.& \left(69\right)\end{array}$

Therefore accessing U_col unitaries requires O(1) queries to the fundamental oracles as claimed, along with a arithmetic circuit, of size polynomial in the number of bits used to represent |H_k,p(t), for computing trigonometric functions of the magnitudes of the complex-valued matrix elements as well as their arguments. The argument that U_row^†requires O(1) queries follows in exactly the same manner, but with an additional final step that swaps the s and α₁ registers.□

Once HAM-T, is obtained, the complexity of simulation follows directly from previous results.

Theorem 4 (Simulation of sparse time-dependent Hamiltonians). Let an N×N time-dependent Hamiltonian H(s) for s ∈ [0, t] with max-norm, ∥H∥_max:=max_s∥H(s)∥_max and average rate-of-change

$〈\stackrel{.}{H}〉=\frac{1}{t}{\int }_0^t\frac{\mathrm{dH}\left(s\right)}{\mathrm{ds}}$

ds be encoded in the oracles O_H and O_ƒ from Eqs. (62) and (63) to n_p bits of precision. Let α=d∥H∥_max and =tα. Then the time-ordered evolution, operator [exp(−iƒ₀^tH(s)ds)] may be approximated with error ϵ using

$\begin{array}{cc}\mathrm{Queries}\mathrm{to}O_H\mathrm{and}O_f\text{:}\left(\tau \frac{\log \left(\tau /ϵ\right)}{\log \log \left(\tau /ϵ\right)}\right).& 1.\\ \mathrm{Qubits}\text{:}\left(n_p+\log \left(\frac{N_{\tau }}{ϵ{\alpha }^2}\left(\frac{〈\stackrel{.}{H}〉}{\alpha }+\frac{{H}^2}{{\alpha }^2}\right)\right)\right).& 2.\\ \mathrm{Primitive}\mathrm{gates}\text{:}\left(\mathrm{poly}\left(n_p\right)+\log \left(\frac{N_{\tau }}{ϵ{\alpha }^2}\left(\frac{〈\stackrel{.}{H}〉}{\alpha }+\frac{{H}^2}{{\alpha }^2}\right)\right)\frac{\log \left(\tau /ϵ\right)}{\log \log \left(\tau /ϵ\right)}\right).& 3.\end{array}$

Proof. From Theorem 1, the number of qubits requried is (n_s+n_a+n_d+log log (1/ϵ)). Values for these parameters are obtained from the construction of HAM-T in Lemma 4, which also requires an additional n_p qubits for the bits of precision to which H is encoded. In this construction, n_α=(n_s)=(log (N)). n_d is obtained from the number of time-discretization points required by Theorem 1. Simulation for time t is implemented by simulating segments of duration ⊖(α⁻¹). As there are ⊖(tα) segments, one can rescale ϵ→⊖(ϵ/(tα)).□

This is a quadratic improvement in sparsity d. Furthermore, instead of scaling with the worst-case (log (max_s∥{dot over (H)}(s)∥)), one can obtain scaling with average rate-of-change ∥{dot over (H)}∥. If one further assumes that the computed matrix elements H_j,k are not exact, the number of bit of precision scales like n_p=(log (∥H∥t/ϵ)). Note several generic improvements to Theorem 4 are possible, but will not be pursued further as they are straightforward. For instance, if ∥H(t)∥_max as a function of time is known, one may use step sizes of varying size by encoding each segment t ∈[t_j,t_j+1] with the largest max_{t∈[tj,tj+1]}∥H(t)∥_max, rather than the worst-case max_t∥H(t)∥_max.

B. Simulation of Sparse Time-Independent Hamiltonians in the Interaction Picture

This section concerns time-independent d-sparse Hamiltonians H=A +B where A is diagonal and B_kk=0 for all k. In particular, consider the case of diagonally dominant Hamiltonians, where ∥A∥≥d∥B∥_max. Given norms for each of these terms ∥A∥ and ∥B∥_max, it is straightforward to simulate time-evolution e^−iHt in the Schrödinger picture. For instance, using the truncated Taylor series approach in Eq. (38), one obtains a query complexity of (t(d∥B∥_max+∥A∥) polylog(t,d,∥A∥,∥B∥_max, ϵ)). By instead simulating H_I(t)=e^iAtBe^−iAt in the interaction picture, the dependence on ∥A∥ can be removed, which is particularly useful in cases of strong diagonal dominance ∥A∥≥d∥B∥_max, of which the Hubbard model with long-ranged interactions in Section V is an example. Similar to the disclosed results for time-dependent sparse Hamiltonian simulation in Section VIA, this is easily proven by mapping the input oracles O_H and O_ƒfor matrix values and positions to the oracles of Theorem 3 for the more general result.

Theorem 5 (Simulation of sparse diagonally dominant Hamiltonians). Let an N×N time-independent Hamiltonian H for s ∈[0,t] with max-norm ∥A∥ for the diagonal component and max-norm ∥B∥_max for the off-diagonal component be encoded in the oracles O_H and O_ƒ from Eqs. (62) and (63) to n_p bits of precision. Let α_b=d∥B∥_max. Then the time-evolution operator e^−iHt may be approximated with error ϵ using

$\begin{array}{cc}\mathrm{Queries}\mathrm{to}O_H\mathrm{and}O_f\text{:}\left({\alpha }_Bt\frac{\log \left({\alpha }_B\tau /ϵ\right)}{\log \log \left({\alpha }_B\tau /ϵ\right)}\right).& 1.\\ \mathrm{Qubits}\text{:}\left(n_p+\log \left(N\right)+\log \left(\frac{t}{ϵ}\frac{A}{{\alpha }_B}\right)\right).& 2.\\ \mathrm{Primitive}\mathrm{gates}\text{:}\left(\left(\log \left(N\right)+\mathrm{poly}\left(n_p\right)\log \left(\frac{t}{ϵ}\frac{A}{{\alpha }_B}\right)\right){\alpha }_Bt\frac{\log \left({\alpha }_Bt/ϵ\right)}{\log \log \left({\alpha }_Bt/ϵ\right)}\right)\mathrm{primitive}\mathrm{gates}.& 3.\end{array}$

Proof. This follows immediately by combining the query complexity of Lemma 3 to e^−iAt and HAM-T that encodes the Hamiltonian H_I(t)=e^iAtBe^−iAt in the rotating frame, with the query complexity of the approach in Theorem 3 for synthesizing these oracles using the input oracles O_H and O_ƒ. One possible decomposition of HAM-T is

$\begin{array}{cc}\mathrm{HAM}\text{-}T=\left(\sum _{m=0}^{M-1}m〉{〈m}_d\otimes I_a\otimes e^{\mathrm{iArm}/M}\right)\left(I_d\otimes O_B\right)\left(\sum _{m=0}^{M-1}m〉{〈m}_d\otimes I_a\otimes e^{\mathrm{iArm}/M}\right),\left({〈0}_a\otimes I_s\right)O_B\left({〈0}_a\otimes I_s\right)=\frac{B}{{\alpha }_B},& \left(70\right)\end{array}$

where α_B=d∥B∥_max, =(α_B⁻¹) and

$M=\left(\frac{t}{ϵ}\frac{A}{{\alpha }_B}\right).$

Note that with this construction,

$\left({〈0}_a\otimes I_s\right)\mathrm{HAM}\text{-}T\left({〈0}_a\otimes I_s\right)={\Sigma }_{m=0}^{M-1}m〉{〈m}_d\otimes \frac{H_I\left(\tau m/M\right)}{d{B}_{m\mathrm{ax}}}.$

First, synthesize (Σ_m=0^M−1∥mm|_d⊗e^iAτm/M) using (1) queries to the input oracles O_H, and (log(N)+n_plog(M)) primitive gates. Since A is diagonal, e^−iAt can be simulated for any t>0 using only two queries. This is implemented by the following steps:

$\begin{array}{cc}k〉0〉\mapsto k〉k〉0〉\underset{O_H}{\mapsto }k〉k〉H_{k,k}〉0〉\mapsto k〉k〉e^{-{\mathrm{iH}}_{k,k}\mathrm{Zt}}0〉=e^{-{\mathrm{iH}}_{k,k}t}k〉k〉0〉\underset{O_H^{†}}{\mapsto }e^{-{\mathrm{iH}}_{k,k}t}k〉k〉0〉\to e^{-{\mathrm{iH}}_{k,k}t}k〉0〉.& \left(71\right)\end{array}$

Step one uses n_s=(log (N)) CNOT gates to copy the computational basis state |k. Step three applies (n_p) phase rotation with angle controlled by the bits of |H_k,k, and the value of t, which is given beforehand. Subsequently, (Σ_m=0^M−1|mm|_d⊗I_α⊗e^iAtm/M) may be implemented by a sequence of rotations with angles increasing in a geometric series, and each controlled by a different qubit in the d register, e.g. controlled−e^iAτ2−1/M,e^iAτ2−2/M,e^{iAτ2−n+p/M}. Naively, this requires (log (M)) queries. However, it is only necessary to compute |H_k,k once as the entire sequence of controlled-phases may be applied after step three. Similarly, it is only necessary to copy the computational basis state (1) times.

Second, synthesize O_B using (1) queries to the input oracles O_H and O_ƒ. How this is done should be clear from Lemma 4, by omitting the time-index, and preparing the state 0|0_α2+1|1_α2 in Eq. (65) when the input indices k=p. This has gate complexity (poly(n_p)+log (N)). Thus e^−iAτ and HAM-T combined have query complexity (1) to O_H and O_ƒ, and gate complexity (poly(n_p) log (M)+log (N)). By substituting into Lemma 3, one can obtain the stated results.□

This provides a formal proof that the query complexity of simulating a Hamiltonian, within the interaction picture, is independent of the magnitude of the diagonal elements of the Hamiltonian.

VII. General Embodiments

In this section, example methods for performing aspects of the disclosed embodiments are disclosed. The particular embodiments described should not be construed as limiting, as the disclosed method acts can be performed alone, in different orders, or at least partially simultaneously with one another. Further, any of the disclosed methods or method acts can be performed with any other methods or method acts disclosed herein.

FIG. 6 is an example method for a time-dependent simulation algorithm as disclosed herein.

In FIG. 6, the inputs are shown at 610. The inputs include quantum state subroutine (S); for computing (H(t)), evolution time (t), number of segments (r), order (K). At 612, a determination is made as to whether any segments remain. If so, the process proceeds to 614, where a robust oblivious amplitude amplication procedure is applied. If the procedure of 614 is done, then the process proceeds to the next segment; if the procedure 614 is not done, then the procedure proceeds to 616. At 616, a weighted quantum superposition is prepared over the first K terms in the Dyson series of time evolution operator. At 618, a quantum superposition is prepared over each of the times that the Hamiltonian is evaluated at. At 620, subroutine (S) is applied to construct a state that stores the columns of a rescaling of the kth term in the dyson series, for each k=0 . . . K. At 622, subroutine (S) is applied to construct a state that stores the rows of a rescaling of the kth term in the dyson series, for each k=0 . . . , K. At 624, linear combinations of unitary methods are used to conditionally implement the evolution to the input state of 614.

FIG. 7 is an example method for an example interaction picture simulation method as disclosed herein.

At 710, a quantum state, Hamiltonian function, and evolution time are input. At 712, a classical computer is used to construct an interaction picture Hamiltonian by conjugating each term in the off-diagonal Hamiltonian by the evolution according to the diagonal terms. At 714, the interaction picture version of the Hamiltonian is simulated on a quantum computer using a time-dependent Hamiltonian simulation method (e.g., such as that of FIG. 1). At 716, the interaction picture is transformed back on the quantum computer by counter-rotating the quantum state. At 718, the resulting quantum state is output.

FIG. 8 is an example method simulating chemistry and Hubbard models as disclosed herein. At 810, a quantum state, Hamiltonian function, and an evolution time are input. At 182, a classical computer is used to transform to a frame where a potential operator is diagonal. At 814, a simulation method (e.g., the method of FIG. 2) is applied to a quantum state by the classical computer. And, at 816, an evolved quantum state is output (e.g., by the classical computer).

FIG. 9 is an example method of a compression method as disclosed herein. At 910, numerous values are input, including one or more of (a) a classical variable j=1; (b) a success quantum register A; (c) target quantum register S; (d) counter quantum register B; (e) counter quantum register C; (f) a set of J quantum circuits Q₁,Q₂,Q_j, where Q_j applies matrix M_j on register S conditional register A being in a state that indicates ‘success. At 912, it is determined whether j=j+1. If not, then the method proceeds to 914. At 914, and conditional on B and C being the initial quantum state, Q_j is applied. Then, at 916, j is incremented by 1, and conditional on the A being in a ‘success quantum state, B is decremented and C is incremeneted with quantum arithmetic. 916 leads back into 912, until it is determined that j=j+1. If so, at 918, the method outputs a quantum circuit that applies on register S the product of matrices M₁ . . . M_k conditional on register A and C being in the initial quantum state, and register b being in the quantum state k.

FIG. 14 illustrates an example method for performing a quantum simulation in accordance with an embodiment of the disclosed technology.

At 1410, a quantum computer is configured to simulate a quantum system, wherein a Hamiltonian in the simulation is represented in the interaction picture. At 1412, a simulation of the quantum system is performed using the quantum computer.

In certain implementations, the simulation of the quantum system is a subroutine that is repeated two or more times. In some implementations, the simulation is performed using linear combinations of matrices. For instance, in some cases, the simulation uses linear combinations of unitaries performed on a diagonally dominant matrix (e.g., using linear combinations of unitaries performed on the diagonally dominant components of the diagonally dominant matrix). In certain implementations, the quantum system is modelled by a Hubbard model. In particular implementations, the quantum system describes a physical chemical system or molecule. In some implementations, the Hamiltonian is sparse and the simulation uses a state of an auxillary qubit to encode matrix elements of the Hamiltonian instead of using graph decomposition techniques. In certain implementations, the simulation is performed by compressing ancillas for quantum simulation of a time-dependent Hamiltonian.

FIG. 15 illustrates a further example method for performing a quantum simulation in accordance with an embodiment of the disclosed technology.

At 1510, a quantum algorithm is implemented on a quantum computer for simulating a general sparse time-dependent quantum system. In this embodiment, the quantum algorithm does not use graph decomposition techniques.

In certain implementations, a Hamiltonian used in the simulation is represented in the interaction picture. In some implementations, the simulation uses linear combinations of unitaries performed on a diagonally dominant matrix. In particular implementations, a Hamilltonian used in the simulation is represented in the interaction picture and is chosen to be a diagonal matrix. In certain implementations the quantum system is modelled by a Hubbard model, a physical chemical system, or a molecule. In further implementations, the simulation includes compressing ancillas used to index a time for the simulation.

VIII. Example Computing Environments

FIG. 10 illustrates a generalized example of a suitable classical computing environment 1000 in which aspects of the described embodiments can be implemented. The computing environment 1000 is not intended to suggest any limitation as to the scope of use or functionality of the disclosed technology, as the techniques and tools described herein can be implemented in diverse general-purpose or special-purpose environments that have computing hardware.

With reference to FIG. 10, the computing environment 1000 includes at least one processing device 1010 and memory 1020. In FIG. 2, this most basic configuration 1030 is included within a dashed line. The processing device 1010 (e.g., a CPU or microprocessor) executes computer-executable instructions. In a multi-processing system, multiple processing devices execute computer-executable instructions to increase processing power. The memory 1020 may be volatile memory (e.g., registers, cache, RAM, DRAM, SRAM), non-volatile memory (e.g., ROM, EEPROM, flash memory), or some combination of the two. The memory 1020 stores software 1080 implementing tools for peforming any of the disclosed simulation techniques in the quantum computer as described herein. The memory 1020 can also store software 1080 for synthesizing, generating, or compiling quantum circuits for performing the described simulation techniques using quantum computing devices as described herein.

The computing environment can have additional features. For example, the computing environment 1000 includes storage 1040, one or more input devices 1050, one or more output devices 1060, and one or more communication connections 1070. An interconnection mechanism (not shown), such as a bus, controller, or network, interconnects the components of the computing environment 1000. Typically, operating system software (not shown) provides an operating environment for other software executing in the computing environment 1000, and coordinates activities of the components of the computing environment 1000.

The storage 1040 can be removable or non-removable, and includes one or more magnetic disks (e.g., hard drives), solid state drives (e.g. flash drives), magnetic tapes or cassettes, CD-ROMs, DVDs, or any other tangible non-volatile storage medium which can be used to store information and which can be accessed within the computing environment 1000. The storage 1040 can also store instructions for the software 1080 implementing any of the disclosed simulation techniques in a quantum computing device. The storage 1040 can also store instructions for the software 1080 for generating and/or synthesizing any of the described techniques, systems, or quantum circuits.

The input device(s) 1050 can be a touch input device such as a keyboard, touchscreen, mouse, pen, trackball, a voice input device, a scanning device, or another device that provides input to the computing environment 1000. The output device(s) 1060 can be a display device (e.g., a computer monitor, laptop display, smartphone display, tablet display, netbook display, or touchscreen), printer, speaker, or another device that provides output from the computing environment 1000.

The communication connection(s) 1070 enable communication over a communication medium to another computing entity. The communication medium conveys information such as computer-executable instructions or other data in a modulated data signal. A modulated data signal is a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media include wired or wireless techniques implemented with an electrical, optical, RF, infrared, acoustic, or other carrier.

As noted, the various methods, techniques for controlling a quantum computing device, circuit design techniques, or compilation/synthesis techniques can be described in the general context of computer-readable instructions stored on one or more computer-readable media. Computer-readable media are any available media (e.g., memory or storage device) that can be accessed within or by a computing environment. Computer-readable media include tangible computer-readable memory or storage devices, such as memory 1020 and/or storage 1040, and do not include propagating carrier waves or signals per se (tangible computer-readable memory or storage devices do not include propagating carrier waves or signals per se).

Various embodiments of the methods disclosed herein can also be described in the general context of computer-executable instructions (such as those included in program modules) being executed in a computing environment by a processor. Generally, program modules include routines, programs, libraries, objects, classes, components, data structures, and so on, that perform particular tasks or implement particular abstract data types. The functionality of the program modules may be combined or split between program modules as desired in various embodiments. Computer-executable instructions for program modules may be executed within a local or distributed computing environment.

An example of a possible network topology 1100 (e.g., a client-server network) for implementing a system according to the disclosed technology is depicted in FIG. 11. Networked computing device 1120 can be, for example, a computer running a browser or other software connected to a network 1112. The computing device 1120 can have a computer architecture as shown in FIG. 10 and discussed above. The computing device 1120 is not limited to a traditional personal computer but can comprise other computing hardware configured to connect to and communicate with a network 1112 (e.g., smart phones, laptop computers, tablet computers, or other mobile computing devices, servers, network devices, dedicated devices, and the like). Further, the computing device 1120 can comprise an FPGA or other programmable logic device. In the illustrated embodiment, the computing device 1120 is configured to communicate with a computing device 1130 (e.g., a remote server, such as a server in a cloud computing environment) via a network 1112. In the illustrated embodiment, the computing device 1120 is configured to transmit input data to the computing device 1130, and the computing device 1130 is configured to implement a technique for controlling a quantum computing device according to any of the disclosed embodiments and/or a circuit generation/compilation/synthesis technique for generating quantum circuits for performing any of the techniques disclosed herein. The computing device 1130 can output results to the computing device 1120. Any of the data received from the computing device 1130 can be stored or displayed on the computing device 1120 (e.g., displayed as data on a graphical user interface or web page at the computing devices 1120). In the illustrated embodiment, the illustrated network 1112 can be implemented as a Local Area Network (LAN) using wired networking (e.g., the Ethernet IEEE standard 802.3 or other appropriate standard) or wireless networking (e.g. one of the IEEE standards 802.11a, 802.11b, 802.11g, or 802.11n or other appropriate standard). Alternatively, at least part of the network 1112 can be the Internet or a similar public network and operate using an appropriate protocol (e.g., the HTTP protocol).

Another example of a possible network topology 1200 (e.g., a distributed computing environment) for implementing a system according to the disclosed technology is depicted in FIG. 12. Networked computing device 1220 can be, for example, a computer running a browser or other software connected to a network 1212. The computing device 1220 can have a computer architecture as shown in FIG. 12 and discussed above. In the illustrated embodiment, the computing device 1220 is configured to communicate with multiple computing devices 1230, 1231, 1232 (e.g., remote servers or other distributed computing devices, such as one or more servers in a cloud computing environment) via the network 1212. In the illustrated embodiment, each of the computing devices 1230, 1231, 1232 in the computing environment 1200 is used to perform at least a portion of a technique for controlling a quantum computing device according to any of the disclosed embodiments and/or a circuit generation/compilation/synthesis technique for generating quantum circuits for performing any of the techniques disclosed herein. In other words, the computing devices 1230, 1231, 1232 form a distributed computing environment in which aspects of the techniques as disclosed herein and/or quantum circuit generation/compilation/synthesis processes are shared across multiple computing devices. The computing device 1220 is configured to transmit input data to the computing devices 1230, 1231, 1232, which are configured to distributively implement such as process, including performance of any of the disclosed methods or creation of any of the disclosed circuits, and to provide results to the computing device 1220. Any of the data received from the computing devices 1230, 1231, 1232 can be stored or displayed on the computing device 1220 (e.g., displayed as data on a graphical user interface or web page at the computing devices 1220). The illustrated network 1212 can be any of the networks discussed above with respect to FIG. 11.

With reference to FIG. 13, an exemplary system for implementing the disclosed technology includes computing environment 1300. In computing environment 1300, a compiled quantum computer circuit description (including quantum circuits configured to perform any of the disclosed simulation techniques as disclosed herein) can be used to program (or configure) one or more quantum processing units such that the quantum processing unit(s) implement the circuit described by the quantum computer circuit description.

The environment 1300 includes one or more quantum processing units 1302 and one or more readout device(s) 1308. The quantum processing unit(s) execute quantum circuits that are precompiled and described by the quantum computer circuit description. The quantum processing unit(s) can be one or more of, but not limited to: (a) a superconducting quantum computer; (b) an ion trap quantum computer; (c) a fault-tolerant architecture for quantum computing; and/or (d) a topological quantum architecture (e.g., a topological quantum computing device using Majorana zero modes). The precompiled quantum circuits, including any of the disclosed circuits, can be sent into (or otherwise applied to) the quantum processing unit(s) via control lines 1306 at the control of quantum processor controller 520. The quantum processor controller (QP controller) 1320 can operate in conjunction with a classical processor 1310 (e.g., having an architecture as described above with respect to FIG. 10) to implement the desired quantum computing process. In the illustrated example, the QP controller 1320 further implements the desired quantum computing process via one or more QP subcontrollers 1304 that are specially adapted to control a corresponding one of the quantum processor(s) 1302. For instance, in one example, the quantum controller 1320 facilitates implementation of the compiled quantum circuit by sending instructions to one or more memories (e.g., lower-temperature memories), which then pass the instructions to low-temperature control unit(s) (e.g., QP subcontroller(s) 1304) that transmit, for instance, pulse sequences representing the gates to the quantum processing unit(s) 1302 for implementation. In other examples, the QP controller(s) 1320 and QP subcontroller(s) 1304 operate to provide appropriate magnetic fields, encoded operations, or other such control signals to the quantum processor(s) to implement the operations of the compiled quantum computer circuit description. The quantum controller(s) can further interact with readout devices 1308 to help control and implement the desired quantum computing process (e.g., by reading or measuring out data results from the quantum processing units once available, etc.)

With reference to FIG. 13, compilation is the process of translating a high-level description of a quantum algorithm into a quantum computer circuit description comprising a sequence of quantum operations or gates, which can include the circuits as disclosed herein (e.g., the circuits configured to perform one or more simulations as disclosed herein). The compilation can be performed by a compiler 1322 using a classical processor 1310 (e.g., as shown in FIG. 10) of the environment 1300 which loads the high-level description from memory or storage devices 1312 and stores the resulting quantum computer circuit description in the memory or storage devices 1312.

In other embodiments, compilation and/or verification can be performed remotely by a remote computer 1360 (e.g., a computer having a computing environment as described above with respect to FIG. 10) which stores the resulting quantum computer circuit description in one or more memory or storage devices 1362 and transmits the quantum computer circuit description to the computing environment 1300 for implementation in the quantum processing unit(s) 1302. Still further, the remote computer 1300 can store the high-level description in the memory or storage devices 1362 and transmit the high-level description to the computing environment 1300 for compilation and use with the quantum processor(s)). In any of these scenarios, results from the computation performed by the quantum processor(s) can be communicated to the remote computer after and/or during the computation process. Still further, the remote computer can communicate with the QP controller(s) 1320 such that the quantum computing process (including any compilation, verification, and QP control procedures) can be remotely controlled by the remote computer 1360. In general, the remote computer 1360 communicates with the QP controller(s) 1320, compiler/synthesizer 1322, and/or verification tool 1323 via communication connections 1350.

In particular embodiments, the environment 1300 can be a cloud computing environment, which provides the quantum processing resources of the environment 1300 to one or more remote computers (such as remote computer 1360) over a suitable network (which can include the internet).

IX. Summation

The dynamics of interest in many condensed matter systems occur in the low-energy subspace of the Hamiltonian. This work demonstrates that by simulating quantum dynamics in the interaction picture, the cost of simulation on a quantum computer for a large class of Hamiltonians can be made to scale with the low-energy component. This is especially useful when the dynamics at high energy scales are, in a certain sense, simple, but nevertheless are necessary as they couple to low energy scales. This represents a significant advance compared to state-of-art time-independent quantum simulation algorithms that generally scales with the spectral norm of the full Hamiltonian. Finding further improvements in simulation algorithms specialized for low-energy subspaces remains a major open problem. Embodiments of the disclosed approach are complementary to alternatives based on spectral gap amplification, and the possibility of combining these methods is an interesting future direction.

More generally, the complexity of time-independent quantum simulation for generic Hamiltonians, given minimal information, appears to have been resolved. Thus future advancements, such as this work, will likely focus on exploiting the detailed structure of Hamiltonians of interest. For example, the result for time-dependent sparse Hamiltonian simulation has scaling (d∥H∥_maxt), but improvement to (√{square root over (d∥H∥_max∥H∥₁t)}) is straight-forward, if the induced one-norm ∥H∥₁ of the Hamiltonian is also known beforehand. The promise of results in similar directions is exemplified by recent work that exploit the geometric locality of interactions, or the sizes of different terms in a Hamiltonian. The challenge will be finding characterizations of Hamiltonians that are sufficiently specific so as to enable a speedup, yet sufficiently general so as to include problems of practical and scientific value.

X. Appendix

A. The Truncated Taylor Series Algorithm

The truncated Taylor series simulation algorithm was a major advance in quantum simulation for its conceptual simplicity and computational efficiency. The original algorithm is motivated by truncating the Taylor expansion of the time-evolution operator at degree K.

$\begin{array}{cc}{e}^{-\mathrm{iHt}}=1-\mathrm{iHt}+\frac{{\left(-\mathrm{iHt}\right)}^2}{2!}+\frac{{\left(-\mathrm{iHt}\right)}^3}{3!}\dots =\underset{{\stackrel{\_}{R}}_K}{\underset{}{\sum _{k=0}^K\frac{{\left(-\mathrm{iHt}\right)}^k}{k!}}}+\underset{R_K}{\underset{}{\sum _{k=K+1}^{\infty }\frac{{\left(-\mathrm{iHt}\right)}^k}{k!}}}.& \left(72\right)\end{array}$

Assuming that t>0 and that the truncation order K≥2∥H∥t, the norms of R_K and the remainder term R_K are bounded by

$\begin{array}{cc}{\stackrel{\_}{R}}_K=e^{-\mathrm{iHt}}-R_K\le 1+R_K,R_K\le \sum _{k=K+1}^{\infty }\frac{{\left(Ht\right)}^k}{k!}\le \frac{{\left(Ht\right)}^{K+1}}{\left(K+1\right)!}\sum _{k=K+2}^{\infty }{\left(1/2\right)}^{k-K-1}=\frac{2{\left(Ht\right)}^{K+1}}{\left(K+1\right)!}.& \left(73\right)\end{array}$

Thus any unitary quantum circuit TTS that acts jointly on registers α,b,s and applies the non-unitary operator (00|_ab⊗I_s)TTS(|00_ab⊗I_s)≈R_K approximates the time-evolution operator with error δ and failure probability p given by

$\begin{array}{cc}\delta =e^{-\mathrm{iHt}}-{\stackrel{\_}{R}}_K=R_K\le \frac{2{\left(Ht\right)}^{K+1}}{\left(K+1\right)!},p\le 1-\underset{{\psi 〉}_s}{\min }{\frac{{\stackrel{\_}{R}}_K{\psi 〉}_s}{1+R_K}}^2=1-\underset{{\psi 〉}_s}{\min }{\frac{\left(e^{-\mathrm{iHt}}-R_K\right){\psi 〉}_s}{1+R_K}}^2\le 1-{\frac{1-R_K}{1+R_K}}^2=4R_K=4\delta .& \left(74\right)\end{array}$

Solving Eq. (74) for ∥H∥t=(1) gives the required truncation order

$K=\left(\frac{\log \left(1/\delta \right)}{\log \log \left(1/\delta \right)}\right).$

The simulation algorithm TTS in FIG. 4 is obtained by constructing two oracles. HAM_K, which applies positive integer powers of (−iH)^k up to k=K, and COEF_K, which prepares a quantum state that selects these terms with the right coefficients. HAM_K will require additional ancilla registers, which can be indexed with {right arrow over (α)}and {right arrow over (b)}. Note that the gate and space complexity in the truncated Taylor series algorithm is dominated by that of HAM_K.

$\begin{array}{cc}\left({〈0}_{\stackrel{->}{a}}\otimes I_{s\stackrel{->}{b}}\right){\mathrm{HAM}}_K\left({〈0}_{\stackrel{->}{a}}\otimes I_{s\stackrel{->}{b}}\right):=\sum _{k=0}^Kk〉{〈k}_{\stackrel{->}{b}}\otimes {\left(-\mathrm{iH}\right)}^k,{\mathrm{COEF}}_K{0〉}_{\stackrel{->}{b}}:=\frac{1}{\sqrt{\beta }}\sum _{k=0}^K\sqrt{\frac{t^k}{k!}}{k〉}_{\stackrel{->}{b}},\beta =\sum _{k=0}^K\frac{t^k}{k!}\le e^t.& \left(75\right)\end{array}$

FIG. 4 depicts the quantum circuit representation of (top, left) an example implementation of HAM_K from Eq. (75) using K queries to controlled-HAM, (top, right) a single step of the truncated Taylor series algorithm before oblivious amplitude amplification, and (bottom) a single step of time-evolution by the truncated Taylor series algorithm from Eq. (78). Note that β=2 as a single-round of oblivious amplitude amplification is used. Thin horizontal lines depict single-qubit registers. Filled circles depict a unitary controlled on the |0 state.

The original algorithm implements HAM_K using K queries to controlled-HAM

C-HAM:=|11|_b⊗I_as+|00|_b⊗HAM  (76)

with K copies of registers α and b. The state |k_{{right arrow over (b)}}=|0^⊗k|1^⊗K−k that selects desired powers of H is encoded in unary, and so COEF_K may be implemented using (K) primitive gates. Up to a proportionality factor β, the unitaries of Eq. (75) allow us to implement the desired linear combination R_K for simulating time-evolution.

$\begin{array}{cc}{\mathrm{TTS}}_{\beta }:=\left({\mathrm{COEF}}_K^{†}\otimes I_{\overrightarrow{a}s}\right){\mathrm{HAM}}_K\left({\mathrm{COEF}}_K\otimes I_{\overrightarrow{a}s}\right)(〈0{}_{\overrightarrow{a}b}\otimes I_s){{\mathrm{TTS}}_{\beta }(0〉}_{\overrightarrow{a}b}\otimes I_s=\frac{{\stackrel{\_}{R}}_K}{\beta }\approx \frac{e^{-\mathrm{iHt}}}{\beta }.& \left(77\right)\end{array}$

As R_k is close to unitary, the success probability ≈1/β² may be boosted using oblivious amplitude amplification. When β=2, a single round of oblivious amplitude amplification suffices to boost the success probability to 1−(δ). Thus, one can choose ln 2≤t=(1) such that β=2. If one desires |t|<ln 2, β may be decreased by appending a single-qubit ancilla and noting that |0|e^iθX|0|=|cos θ|≤1. Thus simulation is accomplished with the circuit

TTS=TTS _β=2(REF_{{right arrow over (α)}b}⊗I_s)TTS_β=2^†(REF_{{right arrow over (α)}b}⊗I_s(TTS_β=2,REF_{{right arrow over (α)}b}=I_{{right arrow over (α)}b}−2|00|_{{right arrow over (α)}b}.  (78)

This approximates time-evolution by e^−iHt with error ∥(0|_{{right arrow over (α)}b}⊗I_s)TTS(|0_{{right arrow over (α)}b}⊗I_s)−e^−iHt∥=(δ). In order to simulate evolution e^−iHT by longer times T>t, one can apply TTS^T/t− here t=⊖(1) is chosen such that T/t is an integer. The overall error

ϵ=∥(0|_{{right arrow over (α)}b}⊗I_s)TTS^T/t(|0_{{right arrow over (α)}b}⊗I_s)−e^−iHT∥=(Tδ),  (79)

and success probability 1−(ϵ) may thus be controlled by choosing the error of each segment to

$\mathrm{be}\delta =\left(\frac{ϵ}{T}\right).$

This requires a truncation order of

$K=\left(\frac{\log \left(\alpha T/ϵ\right)}{\mathrm{loglog}\left(\alpha T/ϵ\right)}\right).$

One may drop the implicit assumption that ∥H∥≤1, by rescaling H→H/α, for some normalization constant α≥∥H∥. Thus simulation of e^−iHt requires

$\left(\alpha T\frac{\log \left(\alpha T/ϵ\right)}{\mathrm{loglog}\left(\alpha T/ϵ\right)}\right)$

queries to C-HAM. Note that the gate cost of all queries to COEF_K at

$\left(\alpha T\frac{\log \left(\alpha T/ϵ\right)}{\mathrm{loglog}\left(\alpha T/ϵ\right)}\right)$

and that of REF_{{right arrow over (α)}b} at

$\left(n_a\alpha T\frac{\log \left(\alpha T/ϵ\right)}{\mathrm{loglog}\left(\alpha T/ϵ\right)}\right),$

is typically dominated by the gate cost of all applications of C-HAM.

The ancilla overhead of the truncated Taylor series algorithm, at

$n_s+\left(n_a\frac{\log \left(1/ϵ\right)}{\mathrm{loglog}\left(1/ϵ\right)}\right)$

qubits, may be significantly improved by choosing the sequence of unitaries in the compression gadget Lemma 2 of Section III C to be U_j=−iHAM. This straightforwardly furnishes the following result.

Corollary 1 (Hamiltonian simulation by a compressed truncated Taylor series). Let a time-independent Hamiltonian H be encoded in standard-form with normalization α and n_s+n_α qubits, as per Eq. (5). Then the truncated Taylor series algorithm approximates the time-evolution operator e^−iHt for any |αt|≤ln2 to error ϵ using

$1.\mathrm{Queries}\mathrm{to}\mathrm{HAM}\text{:}\left(\frac{\log \left(1/ϵ\right)}{\mathrm{loglog}\left(1/ϵ\right)}\right).2.\mathrm{Qubits}\text{:}n_s+\left(n_a+\mathrm{loglog}\left(1/ϵ\right)\right).3.\mathrm{Primitive}\mathrm{gates}\text{:}\left(\left(n_a+\mathrm{loglog}\left(1/ϵ\right)\right)\frac{\log \left(1/ϵ\right)}{\mathrm{loglog}\left(1/ϵ\right)}\right).$

For longer-time simulations e^−iHT of duration T>t, Corollary l is applied αT/ln (2) times, each with error

$\left(\frac{ϵ}{\alpha T}\right).$

This leads a query complexity

$\left(\alpha T\frac{\log \left(\alpha T/ϵ\right)}{\mathrm{loglog}\left(\alpha T/ϵ\right)}\right).$

Though the compressed algorithm is still worse than the quantum signal processing approach, which uses n_s+(n_α) qubits, the technique is applicable to simulating time-dependent Hamiltonians, as demonstrated in Section III.

XI. Error from Truncating and Discretizing the Dyson Series

In this section, the proof of Lemma 1 is completed for the error from truncating the Dyson series at order K, and the error from approximating its terms, which are time-ordered integrals, with Riemann sums. These results provide a rigorous upper bound on the error of time-dependent Hamiltonian simulation. Let D_k be the k^th term in the Dyson expansion, and let B_k be the Riemann sum of D_k with each dimension discretized into M=t/Δ segments.

$\begin{array}{cc}\left[e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}\right]=\sum _{k=0}^{\infty }{\left(-i\right)}^kD_k=\underset{M\to \infty }{\lim }\sum _{k=0}^{\infty }\frac{{\left(-\mathrm{it}\right)}^k}{M^k}B_k,D_k:=\frac{1}{k!}{\int }_0^t\cdots {\int }_0^t\left[H\left(t_1\right)\cdots H\left(t_k\right)\right]d^kt,B_k:=\sum _{0\le m_k<\cdots <m_1<M}H\left(m_k\Delta \right)\cdots H\left(m_1\Delta \right).& \left(80\right)\end{array}$

It is now proven that the bounds on the ϵ₁ term, which is the error due to truncating the Dyson series at order K.

Lemma 5. Let H(s): →^N×N be differentiable on the domain [0,t]. For any ϵ₁ ∈ [0, 2^−e], an approximation to the time ordered operator exponential of −iH(s) can be constructed such that

$\left[e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}\right]-\sum _{k=0}^K{\left(-i\right)}^kD_k\le {ϵ}_1,1.K\ge \lceil -1+\frac{2\ln \left(1/{ϵ}_1\right)}{\mathrm{lnln}\left(1/{ϵ}_1\right)+1}\rceil$ $2.{\max }_sH\left(s\right)t\le \ln 2$

if one takesProof of Lemma 5. We start by bounding |D_k∥.

$\begin{array}{cc}D_k=\frac{1}{k!}{\int }_0^t\cdots {\int }_0^t\left[H\left(t_1\right)\cdots H\left(t_k\right)\right]d^kt\le \hspace{1em}\hspace{1em}\hspace{1em}\frac{1}{k!}{\int }_0^t\cdots {\int }_0^t\prod _{j=1}^kH\left(t_j\right)d^kt\le \frac{{\left({t\max }_sH\left(s\right)\right)}^k}{k!}.& \left(81\right)\end{array}$

At this point, the proof is identical to the time-independent case as max_s ∥H(s)∥ is independent of time. Thus using Stirling's approximation and assuming K≥2 max_s ∥H(s)∥|t|,

$\begin{array}{cc}{ϵ}_1=\left[e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}\right]-\sum _{k=0}^K{\left(-i\right)}^kD_k\le \sum _{k=K+1}^{\infty }D_k\le \sum _{k=K+1}^{\infty }\frac{{\left({t\max }_sH\left(s\right)\right)}^k}{k!}\le \frac{{\left({t\max }_sH\left(s\right)\right)}^{K+1}}{\left(K+1\right)!}\sum _{k=K+2}^{\infty }{\left(1/2\right)}^{k-K-1}=\frac{{\left({t\max }_sH\left(s\right)\right)}^{K+1}}{\left(K+1\right)!}\le {\left(\frac{\left({\mathrm{te}\max }_sH\left(s\right)\right)}{K+1}\right)}^{K+1}& \left(82\right)\end{array}$

Now one can find that this in turn is less than ϵ₁ if max_s ∥H(s)∥te<min{ln(1/ϵ₁),eln2}≤1 given that, ϵ₁≤2^−e and

$\begin{array}{cc}K\ge \max \left\{-1+\frac{\ln \left(1/{ϵ}_1\right)}{W\left(\frac{\ln \left(1/{ϵ}_1\right)}{{\max }_sH\left(s\right)\mathrm{te}}\right)},2\underset{s}{\max }H\left(s\right)t\right\},& \left(83\right)\end{array}$

where W is the Lambert-W function. Using the fact that for x≥1, W(x)≥(ln(x)+1)/2 and ln(eln2)<1 one can obtain the simpler bound

$\begin{array}{cc}K=\lceil -1+\frac{2\ln \left(1/{ϵ}_1\right)}{\mathrm{lnln}\left(1/{ϵ}_1\right)+1}\rceil =\left(\frac{\ln \left(1/{ϵ}_1\right)}{\mathrm{lnln}\left(1/{ϵ}_1\right)}\right).& \left(84\right)\end{array}$

It is now proven that the bounds on the ϵ₂ term for the error from approximating the Dyson series with its Riemann sum.

Lemma 6. Let H(s): →^N×N be differentiable on the domain [0,t]. Let one also define the quantities

$〈\stackrel{.}{H}〉:=\frac{1}{t}{\int }_0^t\frac{\mathrm{dH}\left(s\right)}{\mathrm{ds}}$

ds. For integer K≥0 and ϵ₂>0,

$\sum _{k=0}^K{\left(-i\right)}^kD_k-\sum _{k=0}^K{\left(-i\frac{t}{M}\right)}^kB_k\le {ϵ}_2,$

by choosing any M such that

$1.M\ge \frac{t^2}{{ϵ}_2}4e^{{\max }_sH\left(s\right)t}\left(〈\stackrel{.}{H}〉+{\max }_s{H\left(s\right)}^2\right),2.M\ge K^2.$

Proof of Lemma 6. One first expands the time-ordered evolution operator using the Dyson series. One can then examine the error incurred in evaluating a given order of the Dyson series for a small hypercubic region of sidelength Δ=t/M. One can then upper bound the maximum number of such hypercubes within the allowed volume and use the triangle inequality to argue that the error is the product of the number of such hypercubes and the maximum error per hypercube.

Since H(s) is a differentiable function it holds from Taylor's theorem that for any δ«1 and computational basis states |x,|y,

$\begin{array}{cc}〈xH\left(s+\delta \right)y〉=〈xH\left(s\right)y〉+\delta 〈x\stackrel{.}{H}\left(s\right)y〉+o\left(\underset{s}{\max }{\stackrel{.}{H}\left(s\right)}_{\max }\delta \right).& \left(85\right)\end{array}$

Since computational basis states form a complete orthonormal basis it follows through norm inequalities that

H(s+δ)=H(s)+δH(s)+o(∥H(s)∥_max N²δ).  (86)

One then has from Taylor's theorem and the triangle inequality that

$\begin{array}{cc}H\left(s+\delta \right)-H\left(s\right)=\sum _{j=1}^r\left[H\left(s+j\delta /r\right)-H\left(s+\left[j-1\right]\delta /r\right)\right]\le \sum _{j=1}^r\stackrel{.}{H}\left(s+\left[j-1\right]\delta /r\right)\delta /r+r\left[o\left(\underset{s}{\max }{\stackrel{.}{H}\left(s\right)}_{\max }N^2\delta /r\right)\right]\le {\int }_0^{\delta }\stackrel{.}{H}\left(s\right)\mathrm{ds}+r\left[o\left(\underset{s}{\max }{\stackrel{.}{H}\left(s\right)}_{\max }N^2\delta /r\right)\right].& \left(87\right)\end{array}$

Since this equation holds for all r, it also holds in the limit as r approaches infinity. Therefore

∥H(s+δ)−H(s)∥≤∫₀^δ∥{dot over (H)}(s)∥ds.  (88)

Next, let one consider the error in approximating the integral over a hypercube to lowest order and let one define the hypercube to be C with x₁, . . . , x_q being the corner of the hypercube with smallest norm. First note that in general if A_j and B_j are a sequence of bounded operators and ∥·∥ is a sub-multiplicative norm then it is straight forward to show using an inductive argument that for all positive integer q.

$\begin{array}{cc}\prod _{j=1}^qA_j-\prod _{j=1}^qB_j\le \sum _{k=1}^q\left(\prod _{j=1}^{k-1}A_j\right)A_k-B_k\left(\prod _{j=k+1}^qB_j\right).& \left(89\right)\end{array}$

By applying this in combination with Eq. (88) to region C, the error induced is

$\begin{array}{cc}{\int }_CH\left(x_1+y_1\right)\dots H\left(x_q+y_q\right)d^qy-{\Delta }^q\prod _{j=1}^qH\left(x_j\right)\le {\int }_C\prod _{j=1}^qH\left(x_j+y_j\right)-\prod _{j=1}^qH\left(x_j\right){\mathrm{dy}}^q,\le \sum _{k=1}^q\left(\prod _{j=1}^{k-1}{\int }_0^{\Delta }H\left(x_j+s\right)\mathrm{ds}\right)\left({\int }_0^{\Delta }{\int }_0^s\stackrel{.}{H}\left(x_k+y\right)\mathrm{dyds}\right)\left(\prod _{j=k+1}^q{\int }_0^{\Delta }H\left(x_j\right)\mathrm{ds}\right)\le \sum _{k=1}^q\left(\prod _{j=1}^{k-1}{\int }_0^{\Delta }H\left(x_j+s\right)\mathrm{ds}\right)\left({\int }_0^{\Delta }{\int }_0^s\stackrel{.}{H}\left(x_k+y\right)\mathrm{dyds}\right)\left(\prod _{j=k+1}^q{\int }_0^{\Delta }\alpha \mathrm{ds}\right)\le {\left(\alpha \right)}^{q-1}\Delta \sum _{k=1}^q\left(\prod _{j\ne k}^q{\int }_0^{\Delta }\mathrm{ds}\right)\left({\int }_0^{\Delta }\stackrel{.}{H}\left(x_k+s\right)\mathrm{ds}\right)& \left(90\right)\\ \mathrm{where}\alpha :={\max }_sH\left(s\right).& \end{array}$

There are two regions in the problem. The first region, which one calls the bulk, is the region that satisfies all the constraints of the problem namely bulk :={(t₁, . . . , t_q):└t₁/Δ┘>. . . >└t_q/Δ┘}. Thus for any index x₁, . . . , x_q to a hypercube in the bulk, the ordering of terms H(x₁+t₁) . . . H(x_q+t_q) in the integrand of Eq. (90) is fixed. The second region is called the boundary which is the region in which the hypercubes used in the Riemann sum would stretch outside the allowed region for the integral. Since one can approximate the integral to be zero on all hypercubes that intersect the boundary, the maximum error in the approximation is the maximum error that the discrete approximation to the integrand can take within the region scaled to the volume of the corresponding region.

Finally one has from Eq. (90) that the contribution to the error from integration over the bulk of the simplex is

$\begin{array}{cc}\sum _{\underset{x_1<x_2<\dots <x_q}{\overrightarrow{x}\in {\left\{0,\Delta ,\dots ,\left(M-1\right)\Delta \right\}}^q}}{\int }_CH\left(x_1+t_1\right)\dots H\left(x_q+t_q\right)d^qt-{\Delta }^q\prod _{j=1}^qH\left(x_j\right)\le \sum _{\underset{x_1<x_2<\dots <x_q}{\overrightarrow{x}\in {\left\{0,\Delta ,\dots ,\left(M\dots 1\right)\Delta \right\}}^q}}{\left(\alpha \right)}^{q-1}\Delta \sum _{k=1}^q\left(\prod _{j\ne k}^q{\int }_0^{\Delta }\mathrm{ds}\right)\left({\int }_0^{\Delta }\stackrel{.}{H}\left(x_k+s\right)\mathrm{ds}\right)& \left(91\right)\end{array}$

In order to understand how the error scales let one examine the partial sum over x₁ for fixed k>1 is

$\begin{array}{cc}\sum _{x_2,\dots ,x_q}\sum _{x_1=0}^{x_2-1}{\int }_0^{\Delta }\stackrel{.}{H}\left(x_1+s\right)\mathrm{ds}\left[{\left(\alpha \right)}^{q-1}\Delta \left(\prod _{j\ne k}^q{\int }_0^{\Delta }\mathrm{ds}\right)\left({\int }_0^{\Delta }\stackrel{.}{H}\left(x_k+s\right)\mathrm{ds}\right)\right]\le \sum _{x_2,\dots ,x_q}{\int }_0^{x_2\Delta }\stackrel{.}{H}\left(s\right)\mathrm{ds}\left[{\left(\alpha \right)}^{q-1}\Delta \left(\prod _{j\ne k}^q{\int }_0^{\Delta }H\left(x_j+s\right)\mathrm{ds}\right)\left({\int }_0^{\Delta }\stackrel{.}{H}\left(x_k+s\right)\mathrm{ds}\right)\right].& \left(92\right)\end{array}$

The integral then takes exactly the same form as the original integral and so by repeating the argument q−1 times it is easy to see, even in the case where k=1, that

$\begin{array}{cc}\sum _{\underset{x_1<x_2<\dots <x_q}{\overrightarrow{x}\in {\left\{0,\Delta ,\dots ,\left(M-1\right)\Delta \right\}}^q}}{\left(\alpha \right)}^{q=1}\Delta \sum _{k=1}^q\left(\prod _{j\ne k}^q{\int }_0^{\Delta }\mathrm{ds}\right)\left({\int }_0^{\Delta }\stackrel{.}{H}\left(x_k+s\right)\mathrm{ds}\right)\le {\left(\alpha \right)}^{q-1}\Delta \sum _{k=1}^q\left(\prod _{j\ne k}^q{\int }_0^{x_{j+1}\Delta }\mathrm{ds}\right)\left({\int }_0^{x_{k+1}\Delta }\stackrel{.}{H}\left(s\right)\mathrm{ds}\right)\le \frac{{\left(\alpha t\right)}^{q-1}}{\left[q-1\right]!}\Delta {\int }_0^t\stackrel{.}{H}\left(s\right)\mathrm{ds},& \left(93\right)\end{array}$

where the definition that x_q+1:=M=t/Δ has been used and the fact that ƒ₀^x∥H(s)∥ds is a monotonically increasing function of x. Thus the contribution to the error from the boundary is at most

$\begin{array}{cc}\sum _{q=1}^K\frac{{\left(\alpha t\right)}^{q-1}}{\left[q-1\right]!}\Delta {\int }_0^t\stackrel{.}{H}\left(s\right)\mathrm{ds}\le \sum _{q=1}^{\infty }\frac{{\left(\alpha \right)}^{q-1}}{\left[q-1\right]!}\Delta {\int }_0^t\stackrel{.}{H}\left(s\right)\mathrm{ds}=e^{\alpha t}\Delta {\int }_0^T\stackrel{.}{H}\left(s\right)\mathrm{ds}.& \left(94\right)\end{array}$

Next one desirably estimate the volume of the boundary. If a point is on the boundary then by definition there exists at least one t_j such that └t_j/Δ┘=└t_j+1/Δ┘ taking t₀=t. All other values are consistent with points within the bulk. It is then straight forward to see that (after relabeling the indexes for the summation) that the volume can be expressed as the sum over all possiole choices of such sums with at least one matched index. If one further assumes that q²Δmax_s∥H(s)∥/[αt]≤ln(2) then one has the following upper bound on boundary contribution to the error in the Dyson series:

$\begin{array}{cc}\int \prod _{j=1}^qH\left(t_q\right){\delta }_{t\in \mathrm{bdy}}{\mathrm{dt}}^q\le \sum _{p=1}^q{\Delta }^q\underset{s}{\max }{H\left(s\right)}^p{\alpha }^{q-p}\left(\begin{array}{c}q\\ p\end{array}\right)\sum _{j_1=1}^{t/\Delta }\sum _{j_2=1}^{j_1-1}\dots \sum _{j_{q-p}=1}^{j_{q-p-1}-1}1={\Delta }^q{\alpha }^q\sum _{p=1}^q\underset{s}{\max }{H\left(s\right)}^p{\alpha }^{-p}\left(\begin{array}{c}q\\ p\end{array}\right)\left(\begin{array}{c}t/\Delta \\ q-p\end{array}\right)·\le {\Delta }^q{\alpha }^q\sum _{p=1}^q\underset{s}{\max }{H\left(s\right)}^p{\alpha }^{-p}\frac{{\left(t/\Delta \right)}^q}{q!p!}{\left(\frac{q^2\Delta }{t}\right)}^p=\frac{t^q{\alpha }^q}{q!}\sum _{p=1}^q\frac{1}{p!}{\left(\frac{q^2\Delta {\max }_sH\left(s\right)}{\alpha t}\right)}^p\le \frac{t^q{\alpha }^q}{q!}\left(\frac{q^2\Delta {\max }_sH\left(s\right)}{\alpha t}\right)\sum _{p=0}^{\infty }\frac{1}{p!}{\left(\frac{q^2\Delta {\max }_sH\left(s\right)}{{\alpha }^t}\right)}^p\le \frac{2{q\left(t\alpha \right)}^{q-1}}{\left(q-1\right)!}\left(\Delta \underset{s}{\max }H\left(s\right)\right)& \left(95\right)\end{array}$

Note that when q=1, there is no boundary contribution. Using the fact that q/(q−1)≤2, ∀q≥2, this upper bound

$\begin{array}{cc}\int \prod _{j=1}^qH\left(t_q\right){\delta }_{t\in \mathrm{bdy}}{\mathrm{dt}}^q\le \frac{4\Delta {\max }_sH\left(s\right){\left(\alpha t\right)}^{q-1}}{\left(q-2\right)!}& \left(96\right)\end{array}$

It then follows from summing Eq. (96) that the error is

$\begin{array}{cc}{\delta }_{\mathrm{bdy}}\le \sum _{q=1}^K\int \prod _{j=1}^qH\left(t_q\right){\delta }_{t\in \mathrm{bdy}}{\mathrm{dt}}^q\le \sum _{q=2}^{\infty }\frac{4\Delta {\max }_sH\left(s\right){\left(\alpha t\right)}^{q-1}}{\left(q-2\right)!}\le 4\Delta \alpha t\underset{s}{\max }H\left(s\right)e^{\alpha t}.& \left(97\right)\end{array}$

By adding this result to that of Eq. (94)

$\begin{array}{cc}\sum _{q=1}^KD_q-{\Delta }^qB_q\le {\delta }_{\mathrm{bulk}}+{\delta }_{\mathrm{bdy}}\le 4\Delta {\mathrm{te}}^{{\max }_sH\left(s\right)t}\left(〈\stackrel{.}{H}〉+\underset{s}{\max }{H\left(s\right)}^2\right)& \left(98\right)\end{array}$

It follows from elementary algebra that this total error is at most ϵ₂ if

$\begin{array}{cc}\Delta \le \frac{{ϵ}_2}{4{\mathrm{te}}^{{\max }_sH\left(s\right)t}\left[〈\stackrel{.}{H}〉+{\max }_s{H\left(s\right)}^2\right]}.& \left(99\right)\end{array}$

Expressed in terms of the number of points

$M=\frac{t}{\Delta },$

the total error is at most ϵ₂ if choose any M such that

$\begin{array}{cc}M\ge \frac{t^2}{{ϵ}_2}4e^{{\max }_sH\left(s\right)t}\left[〈\stackrel{.}{H}〉+\underset{s}{\max }{H\left(s\right)}^2\right]& \left(100\right)\end{array}$

The final bound on M quoted immediately follows from

$\frac{q^2\Delta }{\alpha t}{\max }_sH\left(s\right)\le \ln \left(2\right)\Rightarrow K\le \sqrt{\ln \left(2\right)M}\le \sqrt{M}.$

Now that it has been proven that the necessary results regarding the error in the truncated Dyson series simulation, the following proof of Lemma 1 can be provided:

Proof of Lemma 1. This is proven by combining two intermediate results using a triangle inequality. The approximation error is upper-bounded by

$\begin{array}{cc}\left[e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}\right]-\sum _{k=0}^K{\left(-i\frac{t}{M}\right)}^kB_k=& \left(101\right)\\ \left[e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}\right]-\sum _{k=0}^K{\left(-i\right)}^kD_k+\sum _{k=0}^K{\left(-i\right)}^kD_k-\sum _{k=0}^K{\left(-i\frac{t}{M}\right)}^kB_k& \left(102\right)\\ \le \underset{\underset{{ϵ}_1}{}}{\left[e^{-i{\int }_0^tH\left(s\right)\mathrm{ds}}\right]-\sum _{k=0}^K{\left(-i\right)}^kD_k}+\underset{\underset{{ϵ}_2}{}}{\sum _{k=0}^K{\left(-i\right)}^kD_k-\sum _{k=0}^K{\left(-i\frac{t}{M}\right)}^kB_k}\le ϵ.& \left(103\right)\end{array}$

One can take in both cases the errors to obey ϵ₁=ϵ/2 and ϵ₂=ϵ/2. The result then follows by taking the most restrictive of the assumptions of Lemma 5 and Lemma 6. □

XII. Concluding Remarks

Having described and illustrated the principles of the disclosed technology with reference to the illustrated embodiments, it will be recognized that the illustrated embodiments can be modified in arrangement and detail without departing from such principles. For instance, elements of the illustrated embodiments shown in software may be implemented in hardware and vice-versa. Also, the technologies from any example can be combined with the technologies described in any one or more of the other examples. It will be appreciated that procedures and functions such as those described with reference to the illustrated examples can be implemented in a single hardware or software module, or separate modules can be provided. The particular arrangements above are provided for convenient illustration, and other arrangements can be used.

Claims

1. A method, comprising: configuring a quantum computer to simulate a quantum system, wherein a Hamiltonian in the simulation is represented in the interaction picture; andperforming a simulation of the quantum system using the quantum computer.

2. The method of claim 1, wherein the simulation of the quantum system is a subroutine that is repeated two or more times.

3. The method of claim 1, wherein the simulation is performed using linear combinations of unitaries.

4. The method of claim 3, wherein the simulation uses linear combinations of unitaries performed on a diagonally dominant matrix.

5. The method of claim 4, wherein the simulation using linear combinations of unitaries is performed on the diagonally dominant components of the diagonally dominant matrix.

6. The method of claim 1, wherein the quantum system is modelled by a Hubbard model.

7. The method of claim 1, wherein the quantum system describes a physical chemical system or molecule.

8. The method of claim 1, wherein the Hamiltonian is sparse and the simulation uses the state of an auxiliary qubit to encode the matrix elements of the Hamiltonian instead of using graph decomposition techniques.

9. The method of claim 1, further comprising compressing ancillas for quantum simulation of a time-dependent Hamiltonian.

10. A method, comprising: implementing a quantum algorithm on a quantum computer for simulating a general sparse time-dependent quantum system, wherein the quantum algorithm does not use graph decomposition techniques.

11. The method of claim 10, wherein a quantum Hamiltonian used in the simulation is represented in the interaction picture.

12. The method of claim 10, wherein the simulation uses linear combinations of unitaries performed on a diagonally dominant matrix.

13. The method of claim 10, wherein a quantum Hamiltonian used in the simulation is represented in the interaction picture and is chosen to be a diagonal matrix.

14. The method of claim 10, wherein the quantum system is modelled by a Hubbard model, a physical chemical system, or a molecule.

15. The method of claim 10, further comprising compressing ancillas used to index a time for the simulation.

16. A quantum system, comprising: a classical computer; anda quantum computer,wherein the classical computer is configured to configure the quantum computer to simulate a quantum system within the interaction picture.

17. The system of claim 16, wherein the simulation is performed in using linear combinations of unitaries.

18. The system of claim 16, wherein the simulation uses linear combinations of unitaries performed on a diagonally dominant matrix.

19. The system of claim 16, wherein the quantum system is modelled by a Hubbard model.

20. The system of claim 16, wherein the simulation is performed at least in part by compressing ancillas used to index evolution time within a quantum simulation of a time-dependent Hamiltonian.