Fast-forwarding quantum evolution

We investigate the problem of fast-forwarding quantum evolution, whereby the dynamics of certain quantum systems can be simulated with gate complexity that is sublinear in the evolution time. We provide a definition of fast-forwarding that considers the model of quantum computation, the Hamiltonians that induce the evolution, and the properties of the initial states. Our definition accounts for any asymptotic complexity improvement of the general case and we use it to demonstrate fast-forwarding in several quantum systems. In particular, we show that some local spin systems whose Hamiltonians can be taken into block diagonal form using an efficient quantum circuit, such as those that are permutation-invariant, can be exponentially fast-forwarded. We also show that certain classes of positive semidefinite local spin systems, also known as frustration-free, can be polynomially fast-forwarded, provided the initial state is supported on a subspace of sufficiently low energies. Last, we show that all quadratic fermionic systems and number-conserving quadratic bosonic systems can be exponentially fast-forwarded in a model where quantum gates are exponentials of specific fermionic or bosonic operators, respectively. Our results extend the classes of physical Hamiltonians that were previously known to be fast-forwarded, while not necessarily requiring methods that diagonalize the Hamiltonians efficiently. We further develop a connection between fast-forwarding and precise energy measurements that also accounts for polynomial improvements.


Introduction
Since Feynman's initial proposal of simulating physics with quantum computers [1], a significant amount of research in quantum computing has focused on quantum algorithms for Hamiltonian simulation, i.e., the problem of simulating the time evolution of a quantum system induced by a Hamiltonian H.The main figure of efficiency is how the quantum complexity of these algorithms, as determined by the number of elementary (e.g., two-qubit) gates, scales with various parameters such as the evolution time t > 0. To date, the most efficient known methods for Hamiltonian simulation have quantum complexities that are almost linear in t (cf., [2][3][4][5][6][7][8][9][10][11][12][13][14]).These methods are thus optimal since simulating all quantum systems with complexity sublinear in t is impossible [4,15,16].
Nevertheless, a natural question is whether such complexities can be significantly reduced in specific cases, opening up the possibility of fast-forwarding Hamiltonian simulation.Roughly, a quantum system or Hamiltonian is said to be fast-forwarded if its time evolution can be simulated with quantum complexity scaling sublinearly in t.An answer to this question is relevant for both foundational and practical reasons.For example, the ability to fast-forward a Hamiltonian might allow us to study physical systems on quantum computers more rapidly.It could also result in other important quantum speedups, as some well-known quantum algorithms use Hamiltonian simulation as a subroutine (cf., [17,18]).
Indeed, a few examples of exponential fast-forwarding are known [15], in which there exist quantum algorithms for Hamiltonian simulation of quantum complexity at most polylogarithmic in t.These examples include Hamiltonians that can be diagonalized via an efficient quantum circuit, commuting local Hamiltonians, and quadratic fermionic Hamiltonians [19][20][21].But while these cases are interesting and demonstrate the possibility of fast-forwarding, they are only a handful, and the field of fast-forwarding quantum evolution remains largely unexplored.Characterizing larger classes of Hamiltonians that can be fast-forwarded is crucial.
In this paper, we further explore the theme of fast-forwarding and present new examples that can be fast-forwarded.To this end, we first provide a definition of fast-forwarding that accounts for any asymptotic complexity improvement of the general case, going beyond the exponential fast-forwarding studied previously [15].We also consider the problem of fast-forwarding in subspaces, which concerns the case where quantum evolution occurs only in a certain subspace of the full Hilbert space.This notion of subspace fast-forwarding is useful for simulating physical systems because often the evolution occurs in certain subspaces of, for example, low energies or certain preserved symmetries [22][23][24].Moreover, since certain quantum systems (e.g., bosonic systems) cannot be directly simulated on a digital quantum computer, we provide a definition of fast-forwarding that is relative to a specified set of observables.The "elementary gates" in this case correspond to certain unitary operators that are exponentials of these observables.These definitions are presented in detail in Sec. 2.
Following these definitions, we present several examples of quantum systems that can be fast-forwarded and provide detailed constructions for simulating their time evolution.These are:

Block diagonalizable Hamiltonians:
A class of Hamiltonians that can be exponentially fast-forwarded consists of those Hamiltonians that can be brought into block diagonal form with an efficient quantum circuit if each block can be computed efficiently and fast-forwarded.We investigate fast-forwarding based on this property in Sec.3.1 for spin systems.A particular case, which is analyzed in Sec.3.1.1,is the class of spin Hamiltonians that are invariant under permutations of spins (and thus preserve the magnitude of the total angular momentum).In this case, we achieve exponential fast-forwarding by employing the Schur transform [25,26], which block diagonalizes the Hamiltonian in the angular momentum subspaces.
Frustation-free Hamiltonians at low energies: In Sec.3.2, we investigate subspace fastforwarding for certain positive Hamiltonians of spin systems, which include those that satisfy a frustration-free property [27,28].We show that these Hamiltonians can be polynomially fastforwarded when the input states are guaranteed to be in a certain low-energy subspace.We achieve fast-forwarding by using the spectral gap amplification method given in Refs.[29,30] in combination with quantum phase estimation [31,32].
Fermionic and bosonic Hamiltonians: In Sec. 4, we study exponential fast-forwarding in quadratic fermionic and bosonic Hamiltonians.We first consider a Lie algebraic setting and focus on Lie algebraic models of quantum computation, where the quantum gates correspond to certain unitary transformations induced by the algebra.In Sec.4.1 we describe exponential fastforwarding via Lie-algebra diagonalization.We then apply the technique to formalize a result on exponential fast-forwarding of quadratic fermionic Hamiltonians (Sec.4.1.1)and numberconserving quadratic bosonic Hamiltonians (Sec.4.1.2).
Our results address the simulation of quantum systems that are abundant in physics.These systems include condensed matter spin models and quantum chemistry and nuclear physics models, such as the well-known Lipkin-Meshkov-Glick model [33], which preserve the magnitude of the total angular momentum.Frustration-free Hamiltonians are also ubiquitous and include the AKLT model [34] and, more generally, those "parent" Hamiltonians that appear in the context of projected entangled pair states (PEPS) [27].While a complexity improvement for simulating these systems under the assumption that the initial state is supported in a low-energy subspace was shown in Ref. [22], that result does not demonstrate fast-forwarding as the quantum complexity is still superlinear in t.Fermionic and bosonic Hamiltonians are also important, and fast simulation methods for these systems will play an important role in the general problem of simulating quantum field theories [35].Our methods exploit different properties of these systems and go beyond the fast-forwarding approach based on diagonalization.
Last, we note that our definitions immediately lead us to a generalization of the correspondence between fast-forwarding and precise energy measurements discussed in Ref. [15].In Sec. 5 we show that, roughly, polynomial fast-forwarding is equivalent to polynomially-precise energy measurements in qubit systems.

Concepts and definitions
For a given Hamiltonian H and t > 0, Hamiltonian simulation methods aim at simulating the evolution operator U (t) := e −itH .They do this by implementing a sequence of "elementary" quantum gates, and the number of these gates determines the quantum complexity of the method.This complexity depends on parameters such as t, system size, and precision.The fast-forwarding problem is then focused on finding fast ways of simulating U (t), where the figure of merit is the quantum complexity and its asymptotic scaling, particularly with t.Roughly, a Hamiltonian is said to be fast-forwarded if this complexity is sublinear in t.
Several points must be addressed before providing precise definitions of fast-forwarding.First, the quantum complexity depends on the computational model under consideration, which specifies what the elementary quantum gates are.Usually, these quantum gates are chosen to be compatible with physical implementations.For example, in the standard circuit model of quantum computation, elementary quantum gates may correspond to two-qubit gates.For a fermionic or bosonic model of computation, elementary gates correspond to simple unitary operators induced by corresponding fermionic or bosonic algebras.

Definition 2.1 (Models of quantum computation). A model of quantum computation can be specified by a set of observables
. .} acting on a Hilbert space H.The elementary quantum gates are unitary transformations expressed as exponentials e −iθ l O l , where θ l ∈ R and |θ l | ≤ 1.A quantum circuit in this model is a sequence of elementary quantum gates, and the number of these gates is the quantum complexity.
The condition |θ l | ≤ 1 is arbitrary -i.e., we can bound the phases by a different constant -but is needed to restrict the power of each quantum gate.This is particularly relevant in bosonic models of computation where, in contrast with certain two-qubit gates (induced by Pauli operators), bosonic gates are not periodic in θ l .
Second, known no-fast-forwarding results [4,15,16] place a lower bound on the worst-case quantum complexity for simulating classes of Hamiltonians as long as the evolution time satisfies t ≤ T , where T depends on certain problem parameters, such as the number of qubits or spins.These lower bounds are commonly presented as asymptotic scalings.If the Hamiltonian is fixed, however, it may be possible to simulate that particular Hamiltonian with quantum complexity that has a very mild (polylogarithmic) dependence on t, for example, by exact diagonalization for large t.Since the asymptotic scaling of the quantum complexity with t and other parameters is in general of relevance, we will consider sequences of Hamiltonians {H n } n that depend on a "system-size" parameter n = 1, 2, . ... For qubit systems, n is the number of qubits.For fermionic or bosonic systems, n can be the number of modes.By allowing the system size to grow, we are able to consider maximum evolution times that increase in order to determine the true asymptotic scaling of the gate complexity.For the problem of fast-forwarding quantum evolution, it is then important to determine the parameters of Hamiltonian simulation precisely as a function of n, which are defined as follows: The operator 1l A is the identity operator acting on an ancillary register A and |0 A is some simple initial state for that register.
Throughout this paper, |φ is the Euclidean norm of the quantum state |φ and A is the spectral norm of the operator A. Definition 2.2 concerns the largest quantum complexity, G(n), for approximating e −itHn for all times t ≤ T (n).While this is not necessary, we will see that understanding the asymptotic behavior of G(n) alone will suffice to classify many classes of Hamiltonians that can be fastforwarded, including previously known examples and the examples we provide in the following sections.Nevertheless, one may be interested in the ability of fast-forwarding in, for example, other specific regions of t, in which case the above definition could be adapted to that setting.
It is important to remark that a circuit V n (t) might include operations during a pre-or post-processing step.In some cases these steps can be implemented on a classical computer (see the examples in Sec.4), but we will assume they are all part of the quantum operation that simulates the Hamiltonian, thereby avoiding any complication in separating quantum and classical complexities.Some examples in this paper do require some form of pre-processing, but the complexity of such a step is not dominant in those cases.
Last, any useful definition of fast-forwarding must capture the ability to simulate a particular Hamiltonian (or a class of Hamiltonians) with quantum complexity that is below a lower bound established for worst-case instances of a class.For example, one can establish a no-fastforwarding theorem for the class of local spin Hamiltonians [16] that would apply to the worst case, but there are still local Hamiltonians in that class that can be simulated more rapidly with quantum complexity that is sublinear in t, such as XY Ising models [19].The no-fast-forwarding line, which we define below, will play an important role in a definition of fast-forwarding.

Definition 2.3 (No-fast-forwarding line).
Let {C n } n denote classes of Hamiltonians, i.e.C n is a subset of the Hermitian operators acting on H n , and let T (n) ≥ 0 and (n) ≥ 0 be functions of n.The no-fast-forwarding line l(n) with respect to these classes is the function where the quantum circuits That is, for a given n, the no-fast-forwarding line is the minimum quantum complexity required for simulating every Hamiltonian in a given class and quantum computational model.This line depends on the maximum simulation time T (n); however, in our analyses and examples T (n) is a fixed function of n and we do not need to consider this dependence explicitly.
If a particular sequence of Hamiltonians of those classes can be simulated with less quantum complexity, i.e. asymptotically less than l(n), then we will claim that such a Hamiltonian sequence can be fast-forwarded.In more detail, we define fast-forwarding as follows: Our definition of fast-forwarding is relative to the classes of Hamiltonians {C n } n , and this is needed because certain classes are more difficult to simulate than others.If, however, those classes are chosen to be too restrictive, then the definition will not capture the ability to fastforward a Hamiltonian in an interesting class.For example, a diagonal qubit Hamiltonian H n may not be fast-forwarded relative to a class {C n } n of diagonal qubit Hamiltonians despite having an algorithm of polylogarithmic complexity in t because every Hamiltonian in C n can be simulated with such complexity.But if {C n } n are more general, not necessarily diagonal qubit Hamiltonians, and H n ∈ C n is diagonal, then the definition will serve its purpose.Likewise, we will require {C n } n and {H n } n to consist of Hamiltonians that are normalized in some way.Otherwise, l(n) and G(n) could be artificially large or small, respectively, implying fast-forwarding under our definition.
Definition 2.4 also depends on a Hamiltonian sequence {H n } n with no explicit requirement that these Hamiltonians are related in some way.Nevertheless, the definition becomes useful when the sequence describes the "same" type of Hamiltonians for different system sizes n.For example, H n may be constructed from H n−1 by adding a term that involves a new subsystem; e.g., the n-th spin or the n-th fermionic or bosonic mode.We sometimes refer to such sequences as meaningful sequences of Hamiltonians and define them more precisely for spin and fermionic or bosonic systems in Secs. 3 and 4, respectively.Similarly, while no requirement is set for the subspaces {S n } n , the definition will be useful when S n is related to S n−1 in some way (e.g., S n ≡ H n ).For simplicity, we will be concerned with the simulation of Hamiltonians to constant error (n) = , but our results can be easily generalized to other cases.
It is generally difficult to find the no-fast-forwarding line l(n).To show that a Hamiltonian can be fast-forwarded, we often show that it can be simulated with asymptotic quantum complexity that grows slower in t than a lower bound l (n, t) of l(n).These lower bounds, also known as no-fast-forwarding theorems, are known for some classes of Hamiltonians.Reference [16], for example, provides this lower bound for the class of geometrically-local qubit Hamiltonians, although these Hamiltonians are time-dependent.In this case, l (n, t) = Ω(nt) for t ≤ T (n) = 4 n and thus l(n) = Ω(n4 n ).Related is a result of Ref. [15] that strongly suggests that no exponential fast-forwarding is possible for all n-qubit Hamiltonians that are 2-sparse, where the matrix of H n has at most two nonzero elements per row/column.Other known lower bounds apply to the setting in which Hamiltonians can be accessed via a black-box unitary [4].These results suggest that for some classes of Hamiltonians analyzed in this paper, the no-fast-forwarding line satisfies l(n) = Ω(nT (n)), where T (n) is exponential in n (e.g., T (n) = 4 n ).When the no-fastforwarding line has this form, Def.2.4 coincides with the intuitive notion of fast-forwarding as a simulation algorithm achieving complexity scaling sublinearly in the evolution time.
The various types of fast-forwarding can be characterized by the asymptotic behavior of G(n) and l(n).For example, for the exponential fast-forwarding problem analyzed in Ref. [15], a class of Hamiltonians can be simulated with quantum complexity G(n) = O(poly(n)) while l(n) (or T (n)) is exponential in n.Our definition, however, allows for more general cases, including polynomial fast-forwarding.This occurs when, in particular, both G(n) and l(n) are exponential in n, but G(n)/l(n) → 0. For example, a Hamiltonian simulation method of quantum complexity that scales as nt α for α < 1 and all t ≤ T (n) = 4 n , will imply polynomial fast-forwarding relative to a class of Hamiltonians with no-fast-forwarding line of the form l(n) = Ω(n4 n ).In Fig. 1 we sketch examples of fast-forwarding and no-fast-forwarding using our definitions, where all the relevant quantities are increasing in n or t.
< l a t e x i t s h a 1 _ b a s e 6 4 = " l / O d k s 7 T y a    In the following, we assume = 1 and do not assign units to Hamiltonians or time, which is common practice for analyzing quantum simulation algorithms.Nevertheless, if one is interested in the resulting complexity in an actual application where units are considered, this will easily follow from our results.We also use A, A , etc., to denote ancillary systems, which include all additional systems required by a particular Hamiltonian simulation approach, such as those needed to implement certain classical computations reversibly.

Fast-forwarding of local spin systems
In this section, we consider fast-forwarding relative to the class of local spin systems, where n spins are located at the vertices of lattices Λ n , n = 1, 2, . ... Each spin is of dimension d, and for each n, the Hilbert space is H n = C d ⊗n .For each system there is a Hamiltonian H n acting on H n that describes the interactions.This Hamiltonian is a sum of (local) Hermitian terms; that is, H n = X⊂Λn h X , where h X describes the interactions of spins in a subset X ⊂ Λ n .We detail the structure of these Hamiltonians by assuming them to be k-local and of degree g.This means that each subset X involves at most k spins, and each spin is involved in at most g of the subsets X.For simplicity, we take k and g to be constant and also assume h X ≤ 1, for all X.The no-fast-forwarding line is assumed to be l(n) = Ω(nT (n)), where T (n) = d 2n .
The meaningful Hamiltonian sequences {H n } n are such that H n = H n−1 ⊗ 1l n + v n , where v n is a sum of interaction terms that act non-trivially on the new (n-th) spin and other spins of the system.The Hilbert spaces are such that H n = H n−1 ⊗ C d and 1l n is the identity operator on C d , the space associated with the new spin.We are interested in the complexity of simulating spin Hamiltonians in the standard gate-based model, where elementary quantum gates are two-qubit gates.Nevertheless, some results of this section apply to more general quantum systems that are not necessarily spin systems.
The first example of fast-forwarding of a spin system is described in Sec.3.1, where we study Hamiltonians with certain block diagonal structure, which occurs due to a symmetry of the system.Roughly, if a Hamiltonian can be taken to a block diagonal form via a unitary that admits an efficient quantum circuit implementation, and the block diagonal Hamiltonian can be simulated with complexity sublinear in t, then the original Hamiltonian can be fast-forwarded.This occurs, for example, when the Hamiltonian is invariant under the permutation of spins, such as for the well-known Lipkin-Meshkov-Glick model [33], and we show that this case can be exponentially fast-forwarded.Permutation-invariant spin Hamiltonians have also been used in quantum computing for noise protection [36] and optimization [37].
The second example is described in Sec.3.2, where we study the so-called parent or frustrationfree Hamiltonians in the context of subspace fast-forwarding.We show that these Hamiltonians can be polynomially fast-forwarded if the subspaces S n are those of "low" energies.The actual level of fast-forwarding depends on the parameters of the problem, especially on a low-energy cutoff ∆, which might depend on the evolution time t.
In the following, we drop the subscript n from the Hamiltonians and Hilbert spaces when these are clear from context.

Block diagonalization
Any n-spin Hamiltonian H can be decomposed based on its action on invariant subspaces as where µ may be associated with some conserved quantity (quantum number), H| Iµ is the restriction of the Hamiltonian to the subspace I µ ⊆ H, and H = µ I µ .To fast-forward H, we are particularly interested in cases where the evolution under each H| Iµ can be fast-forwarded.More precisely, let U be a block diagonalizing unitary operation or quantum circuit that performs the mapping where A, A are some ancillary systems and the basis states {|µ A } µ encode the values of µ.In general, I µ are subspaces of a different Hilbert space H , so the Hamiltonians H | I µ may be different than H| Iµ , but we require dim I µ = dim I µ .Note that the tensor product decompositions on the left and right hand sides of Eq. (5) may also be different.Consider now another unitary that approximates the evolution under each for all |ψ ∈ I µ .We obtain: Theorem 3.1.Let > 0, T > 0, g be the quantum complexity of U in Eq. (5), and g (t, ) be an upper bound on the quantum complexity of U (t) in Eq. (6), such that Eq. ( 7) holds.Assume that g (T, ) ≥ g (t, ) for all t ∈ [0, T ].Then, there exist quantum circuits {V (t)} t that simulate H on H with parameters (T, , 2g + g (T, )) for all 0 ≤ t ≤ T .
Proof.For each t ≤ T , the quantum circuit V (t) = U † U (t)U of Fig. 2 can be used to approximate e −itH .That circuit implements U and U † , adding 2g to the quantum complexity, and also implements U (t) that has quantum complexity bounded by g (T, ).We can bound the simulation error as follows: ≤ , (10) where |ψ ∈ H is any state and |φ = U |ψ ⊗ |0 A .Fast-forwarding using this approach is possible if the quantum complexity of V (t) is sublinear in t for a sufficiently large range of values of t.Thus, the ability to fast-forward block diagonalizable Hamiltonians depends on the complexity of the various procedures in Fig. 2. Of particular interest are those Hamiltonians where the unitary U in Eq. (5) has quantum complexity g = poly(n) and U (t) in Eq. (6) has quantum complexity g (T, ) = poly(n, log(T )), for constant error .These Hamiltonians can be exponentially fast-forwarded.They include Hamiltonians that can be efficiently (block) diagonalized, where dim I µ is polynomial in n and, for each µ, the Hamiltonians H | I µ can be efficiently computed and simulated, as in the example of Sec.3.1.1below.
Note that implementing U (t) requires implementing the unitaries U µ (t) conditional on the ancillary state |µ A .There are at most dim H = d n different values of µ, and thus at most d n unitaries U µ (t).The quantum complexity of U (t) can then be exponential in n in the worst case, but as we discussed, we are interested in cases where this complexity is only poly(n).A standard approach to achieve this complexity in some cases is by having access to a classical algorithm that, on any input µ, provides a classical description of the quantum circuit U µ (t) in time poly(n).The classical circuit can be efficiently implemented on a quantum computer using reversible quantum gates, which we denote by C; see Fig. 3.The unitary U (t) can then be efficiently implemented by applying the corresponding quantum gates of U µ (t) conditional on the ancillary register state that encodes the quantum circuit.The last step is to apply the inverse of C to reset the ancillary state.

Permutation-invariant spin Hamiltonians
We apply the results of Sec.3.1 to fast-forward Hamiltonians that are invariant under permutations of spins.This setting is relevant for studying nuclear and condensed matter systems, where the well-known Lipkin-Meshkov-Glick model is a prime example [33].We use the block diagonal structure of these Hamiltonians to show that their time evolution can be exponentially fast-forwarded.In particular, the permutation-invariance ensures the following: 1.The Schur transform U Sch , which is a unitary transformation, takes the Hamiltonian to a block diagonal form according to the decomposition Thus, the block diagonalizing quantum circuit in Eq. ( 5) is U = U Sch , and the blocks or subspaces are labeled by quantum numbers µ = (λ, p) associated with invariant subspaces After implementing the operator we transform back to the original basis.We now consider the complexity of simulating H when t ≤ T (n) = d 2n and > 0 is constant.
We allow /3 error for each of the three components U Sch , e −itH| Q λ , and U † Sch .As described in Ref. [26], U Sch (and U † Sch ) can be implemented with complexity n poly(log n, d, log1 ) = poly(n).In the Schur basis, each subspace Q λ has dimension given by the number of semistandard Young tableaux of shape λ and maximum entry d, which is O(n d 2 ) 1 .Thus, each block e −itH| Q λ of the unitary operator U (t) has size polynomial in n and can be decomposed into a product of poly(n) two-level unitaries using QR decomposition by Givens rotations, as described in Section 4.5.1 of Ref. [38].The circuit U (t) consists of these two-level unitaries controlled on the A 1 register.By classically calculating a description of the quantum circuit for λ on another ancillary register and applying the conditional two-level unitaries as in Fig. 3, we obtain a circuit implementing U (t).Alternatively, because there are at most ) labels λ, we could also evolve the blocks conditioned on the each value of λ separately.In either implementation, the circuit for U (t) has quantum complexity that is polynomial in n.
We can obtain a more precise expression for the simulation complexity by fixing specific encodings for the different registers in the Schur basis.For simplicity, we demonstrate the result for qubit systems: Proof.For d = 2, a partition λ = (λ 1 , λ 2 ) into at most two parts with λ 1 + λ 2 = n, λ 1 ≥ λ 2 ≥ 0 can equivalently be described by providing J = λ 2 −λ 1 2 , which is the total angular momentum labeling representations of SU (2).
In Appendix A, we explicitly describe the circuit for the Schur transform for the qubit case, following Ref.[25], and using a unary encoding of the registers that encode λ (or J) and q.That is, for a given basis state |J or |q , all qubits of the register are |0 except the one corresponding to the value of J or q, which is |1 .The gate complexity of the circuit U Sch is O(n 3 ).
The dimensions of the irreducible representations of SU (2) are dim Q J = 2J + 1 ≤ n + 1, so the QR decomposition expresses U J (t) as the product of O(n 2 ) two-level operations.The unary encoding ensures that each two-level unitary, acting on a subspace spanned by |q , |q + 1 , is a two-qubit gate with support on the corresponding qubits.We implement the block diagonal unitary U (t) by evolving the system in each irreducible representation separately, as shown in Fig. 5.By encoding the |J register in unary, the unitaries acting on the |q register are controlled on single qubits in the |J register, resulting in a constant cost per two-level unitary.
Because there are O(n) possible values of J, this gives a total of O(n 3 ) two-qubit elementary gates to implement U (t). Adding the cost of the quantum complexity of U Sch , we can simulate the evolution of the Hamiltonian H with O(n 3 ) elementary gates.Examples of permutation-invariant Hamiltonians are vast.One characterization is that they are in the universal enveloping algebra U (su(d)): Consider a Hamiltonian H with terms that are products of su(d) operators A acting on the representation space H = C d ⊗n as For example, the su(2) operators are spanned by angular momentum operators where each qubit of the Hilbert space is identified with the standard representation Q 1/2 of su(2).
Since H is manifestly permutation-invariant, any U (su(d)) Hamiltonian can be fast-forwarded using Thm.3.2.Conversely, this example is the most general case because up to an additive constant, every permutation-invariant Hamiltonian is an element of U (su(d)).Indeed, by Schur-Weyl duality, the commutant of the image of the symmetric group S n in C d ⊗n is spanned by elements of the form A ⊗n for a A ∈ M d (C), which are generated by gl(d).The Hermitian elements are the U (su(d)) operators up to an additive constant.
A famous example of a U (su(2)) Hamiltonian is the Lipkin-Meshkov-Glick (LMG) model that appears in nuclear physics [33].The LMG model describes a system of n fermions which can each be spin up or spin down.The Hamiltonian is given by Here, σ =↑, ↓ corresponds to the two possible spins with σ the opposite spin, i runs from 1 to n, and the constants V and W describe the interaction strengths.By defining the operators which satisfy the usual sl(2, C) commutation relations, we can rewrite the Hamiltonian up to a constant as We see that H is a U (su(2)) Hamiltonian on a system of n qubits where each qubit i stores the spin of fermion i.Thus, by Thm.3.3, the LMG model can be exponentially fast-forwarded.

Frustration-free spin Hamiltonians at low-energies
We present a method for polynomially fast-forwarding a class of Hamiltonians denominated as frustration-free [27,28,34], when the initial state is supported in a certain low-energy subspace.This setting can be relevant for studying quantum phase transitions, the simulation of adiabatic quantum state preparation, and more, where spectral gaps can decrease with the system size [22].For a spin system, a frustration-free Hamiltonian is H = X⊂Λ h X , where each h X has the additional property h X ≥ 0 and the lowest eigenvalue of H is zero.As before, we assume h X ≤ 1 so that H ≤ L, where L denotes the number of subsets X appearing in H.While we focus on spin systems, we note that the results of this section may be applied to other systems.Our approach to fast-forward H uses a well-known Hamiltonian simulation method based on quantum eigenvalue (or phase) estimation [31,32], but other related approaches could also be used (cf., [39]).This method first estimates (a function of) an eigenvalue of H and then implements the corresponding conditional phase (cf., Ref [40]); see Fig. 6.To fast-forward H, we combine this method with the spectral gap amplification technique of Ref. [29] to amplify the magnitude of some eigenvalues of H.The basic reason that allows for fast-forwarding in this case is that the amplified eigenvalues can be estimated with less accuracy -and thus less quantum complexity -than that needed for the estimation of the actual eigenvalues of H, as long as the initial state is supported in a subspace of sufficiently low energies.Our main result on fast-forwarding is given in Thm.3.7 below, but we first prove some lemmas needed for simulating H via quantum eigenvalue estimation.
Figure 6: (a) Hamiltonian simulation via quantum eigenvalue estimation: on input state |ψ j ⊗ |0 A , where |ψ j is an eigenstate of H of eigenvalue λ j , the unitary U (H) outputs a state where the ancillary register |f (λ j ) encodes information about (a function of) the eigenvalue.We then apply the phase e −itλj on |f (λ j ) and invert U (H).The output state is approximately e −itλj |ψ j ⊗ |0 A and the overall quantum complexity of this approach depends on the approximation error.(b) An example of a building block of U (H) in this case is the standard quantum phase estimation algorithm.The unitary W = e −iH / √ L is constructed from H and QF T is the quantum Fourier transform.To increase the confidence level, U (H) uses this block repeatedly many times [41].
Lemma 3.4 (Eigenvalue amplification, from Appendix B of Ref. [29]).Let H = X⊂Λ h X be frustration-free and let 0 = λ 0 ≤ λ 1 ≤ . . .be the (ordered) eigenvalues of H associated with the eigenstates |ψ j , j = 0, 1, . ...Then, the Hamiltonian acts as the square root of H on the subspace where the ancillary state is fixed to |0 A : The states |X A are orthogonal basis states (labeled by X) of an ancillary system.Furthermore, if λ j > 0 and The eigenvalues of H are either zero or ±λ j = ± λ j .
Thus, λ j λ j if 0 < λ j 1, where eigenvalue amplification occurs.Note that each √ h X can be classically computed in constant time as this is also a k-local term and k = O(1) by assumption.
We use the method of Fig. 6 to simulate H by estimating the eigenvalues of H via quantum eigenvalue estimation.If . Thus, we are able to demand a less accurate estimation of λ j 's for an accurate estimation of λ j in this case: Lemma 3.5.Let ≥ 0, t > 0, and ∆ > 0.Then, an estimate of an eigenvalue λ j ≤ ∆ of H within accuracy /(2t) is implied by an estimate of one of the corresponding eigenvalues ±λ j of H , defined in Eq. ( 16), within accuracy Proof.The estimate of λ j is obtained from the squared of the estimate of λ j or −λ j .Thus, it suffices to prove or, equivalently, 2δ A similar bound follows if we assume δ = /(8t √ ∆) ≤ /(4t).Thus, it suffices to choose δ according to Eq. ( 19) to satisfy Eq. ( 20).Lemma 3.6 (Quantum eigenvalue estimation).Let H be as in Eq. (16).Then, there exists a quantum circuit U (H) that, acting on input |ψ j ⊗ |0 A , outputs an estimate of λ j within accuracy δ and probability c ≥ 1 − /2 after a simple measurement.The quantum complexity of The Õ notation hides logarithmic factors in L, 1/δ, and log(1/ ).
Proof.The result follows from previous works.In particular, we can use the high-confidence quantum phase estimation algorithm of Ref. [41].Let W = e −iH / √ L be a unitary operator (note that H ≤ √ L).On input |ψ j ⊗ |0 A , that algorithm outputs either λ j / √ L or −λ j / √ L with probability greater or equal than 1 − /2 and within accuracy δ/ √ L after a simple projective measurement.This is because |ψ j ⊗ |0 A is a superposition of eigenstates of H of eigenvalues ±λ j .The quantum complexity of quantum phase estimation is dominated by the number of uses of W , or its conditional version, which in this case is m = O(log(1/ ) √ L/δ).Next, we can simulate W using a known algorithm for Hamiltonian simulation.To avoid undesired overheads due to the precision factor, we consider the method of Ref. [9]; alternatively, we could use the method of Ref. [11].Reference [9] implements W by implementing a truncated Taylor series of the exponential operator.That method requires a decomposition of the Hamiltonian as a linear combination of unitary operations.When H is a k-local, n-spin Hamiltonian, and k = O(1), it is simple to write H as a sum of O(L) unitaries.To this end, we encode the ancilla register of dimension L into log L qubits with binary encoding.This implies that the Hamiltonian H is a sum of L-many (k + log L)-local terms.Each of these terms can be written as a sum of O(1) unitaries.For example, √ h X can be processed into a sum of O(1) k-local unitaries.Also, The latter can be easily expressed as products of O(log L) controlled bit and phase flips (two-qubit gates) using standard techniques [38].
Then, we use the method of Ref. [9] to simulate W .This method assumes a presentation of the Hamiltonian as a linear combination of unitaries.When the evolution time is 1/ √ L and the Hamiltonian is a sum of O(L) unitaries, and each is at most (k + log L)-local, with k = O(1), the quantum complexity of this method is Õ(L 3/2 log(1/δ )).The Õ notation hides logarithmic factors in L, and δ is the accuracy.
The quantum circuit U (H) is the high-confidence quantum phase estimation algorithm, which is built upon repeated many calls of Fig. 6(b), and where W is approximated as above.The result then follows by noticing that it suffices to choose δ = O(δ/m) for overall accuracy δ.The resulting quantum complexity is where we dropped logarithmic factors in L, 1/δ, and log(1/ ).
According to Lemma 3.6, fast-forwarding of frustration-free Hamiltonians can then occur when 1/δ is sublinear in t, since the conditional phase operation of Fig. 6(a) has a very mild (polylogarithmic) complexity dependence on t.This can happen if ∆ is sufficiently small; for example, when ∆ is a decreasing function of t.The main result of this section is:

Theorem 3.7 (Polynomial fast-forwarding of frustration-free Hamiltonians at low energies). Let {C n } n denote the classes of k-local, n-spin Hamiltonians of dimension d acting on
Then, there exist quantum circuits {V n (t)} n,t in the standard gate model that are Proof.The definition of fast-forwarding considers the simulation of H n for all times 0 ≤ t ≤ T (n) and it suffices to consider the maximum T (n) to place an upper bound on the quantum complexity G(n).The simulation method we use is the one described in Fig. 6, where we first estimate the eigenvalues of H n to implement the conditional phase that approximates e −itλ j .
Let δ n = /(8 T (n)) < /(4T (n)) and c = 1 − /4.Using the high-confidence version of quantum phase estimation of Ref. [41] and building U (H) according to Lemma 3.6, the output state of U (H) is |ψ j ⊗ |f (λ j ) A when the input state is |ψ j ⊗ |0 A .Here, |f (λ j ) A is a linear combination of basis states and has the following properties: with probability at least 1 − /4, it is supported on a subspace where the corresponding registers encode the eigenvalue λ j of H within precision δ n .Equivalently, with probability at least 1 − /4, it is supported on a subspace where the corresponding registers encode the eigenvalue λ j of H within precision /(2T (n)); see Lemma 3.5.The conditional phase operation then introduces an error that is at most t /(2T (n)) ≤ /2.Inverting U (H) can also add an additional factor of /4 to the error.Thus, this approach simulates H n for time t ≤ T (n) with overall error bounded by /4 + /2 + /4 = .The resulting circuits following this approach are the {V n (t)} n,t , given in Fig. 6.
The quantum complexity for this method is dominated by that of U (H), analyzed in Lemma 3.6.For constant error, this is Õ((L 2 (n)) T (n)), where we dropped logarithmic factors in L(n) and T (n).This complexity is sublinear in T (n).Assuming l(n) = Ω(nT (n)), then G(n)/l(n) → 0 for cases where, for example, T (n) is exponential in n.
The dominant factor in the scaling of G(n) in Thm.3.7 is coming from T (n), and we refer to this case as "quadratic" fast-forwarding.While Thm. 3.7 focuses on the case where ∆ decreases as 1/T , it is clear that if ∆ decreases as 1/T α , for any positive α = 1, other types of polynomial fast-forwarding can result.
As mentioned in Sec. 2, while l(n) may not be known, several results in the literature strongly suggest that l 4 Fast-forwarding of fermionic and bosonic systems Quantum systems obeying various particle statistics such as fermions or bosons play an important role in physics, including condensed matter and quantum field theories, quantum chemistry, and more.In second quantization, Hamiltonians of n-mode fermionic and bosonic systems are written in terms of annihilation and creation operators c i , c † i , respectively, where i = 1, . . ., n. Fermionic operators satisfy the canonical anticommutation relations while bosonic operators satisfy the canonical commutation relations A fermionic or bosonic Hamiltonian is written as where each h I describes interactions among a subset I of fermionic or bosonic modes.More precisely, h I is a sum of terms of the form a(c and a ∈ C. Due to the exclusion principle, e i = f j = 1 for fermionic systems whereas e i ≥ 1 and f i ≥ 1 for bosonic systems, for all i ≤ k and j ≤ l.The Hilbert space H is the standard Fock space with the proper symmetrization [42].
As for spin systems, we can define the degree of H to be the largest sum of the exponents the terms of h I and the weight of H to be the largest value of k + l.We will be particularly interested in those physically relevant cases where the degree and weight of H are constant and further assume |a| ≤ 1.In this context, a fermionic or bosonic Hamiltonian sequence {H n } n is meaningful if we can construct H n from H n−1 by adding an interaction term v n that acts non-trivially on the n-th mode.Our definition of fast-forwarding also depends on the model of quantum computation, and in this case, the fermionic and bosonic models are such that the elementary quantum gates have the form e iθ l O l , where O l is a fermionic or bosonic operator of bounded weight and degree and |θ l | ≤ 1; see Def. 2.1.Note that these models are different than the standard gate model, but a number of mappings can be used to simulate fermionic or bosonic systems with qubit quantum computers if desired [3,43].
Very few results in the literature can be used to address the no-fast-forwarding line for fermionic or bosonic systems.Such are the known results for local spin systems [16] that, under some assumptions, could also be applied to this setting.(The resulting complexity bounds will be weakened by overheads due to mappings between various models of quantum computing.)For certain classes of fermionic or bosonic systems, these results imply a quantum complexity that is at least linear in t, in certain range.In general, we conjecture l(n) = Ω(poly(n)T (n)) for the fermionic and bosonic systems discussed in the following sections, where T (n) = exp(Ω(n)).We will prove exponential fast-forwarding of quadratic fermionic and certain quadratic bosonic Hamiltonians under this assumption, where the weight of H is at most 2. We do this by using a Lie-algebra diagonalization approach that can be applied more generally.

Lie-algebra diagonalization
We describe an approach for fast-forwarding Hamiltonians that are elements of a Lie algebra of small dimension.Hamiltonian simulation via diagonalization was also recently explored in Refs.[44,45] with a focus on near term simulation of qubit Hamiltonians.Our method, which works for fermionic, bosonic, and other types of Hamiltonians, uses a Lie algebraic version of the Jacobi eigenvalue algorithm for diagonalizing matrices [46][47][48], which we review.
Suppose the Hamiltonian H is an element of a real compact semisimple Lie algebra g with Lie group G.The Cartan-Weyl basis decomposition of the complexified Lie algebra implies where h is the Cartan subalgebra, R + ⊆ h * are the positive roots and each g α is the associated two-dimensional space corresponding to the roots α and −α.Because g is compact, each Lie subalgebra generated by g α is isomorphic to su(2) and spanned by generalized Pauli elements The Lie-algebra diagonalization approach is simply a sequence of su(2) rotations that eliminate the off-diagonal elements on 2 × 2 blocks gradually.In the first step we set H (0) = H.At each step j ≥ 0, we write The H

(j)
D ∈ h term is the diagonal component of the Hamiltonian H (j) .The off-diagonal coefficients are a α ∈ R and the goal is to make these small.To this end, we eliminate the a (j) α j , b (j) α j 's of largest norm at each step.This is accomplished by performing the transformation The unitaries V (j) are su(2) rotations given by where the coefficients |π x,y | ≤ π can be determined from H (j) in time polynomial in dim g; more details can be found in Ref. [48].
Convergence of the sequence {H (j) } j to a diagonal operator can be measured using the distance from each Hamiltonian to the Cartan subalgebra, defined by the norm of the off-diagonal terms Wildberger proved that this algorithm converges exponentially [46]: Lemma 4.1 (Wildberger).Let H be an element of a real compact semisimple Lie algebra g with Lie group G. Let l = |R + | < 1 2 dim g.Then, there is a sequence of r unitaries V (j) ∈ exp(ig α j ) ⊆ G such that The Hamiltonian simulation approach via Lie-algebra diagonalization is given in Fig 7 .In principle, each unitary V (j) is a sequence of elementary gates in a corresponding model of quantum computing determined by g.For simplicity, we define this model so that each V (j) is a single elementary gate of unit cost.Additionally, the value of r can be chosen so that the desired accuracy in the diagonalization is achieved.In particular, there exists that achieves d h (H (r) ) ≤ εd h (H).The diagonal operation e −itH (r) D can be implemented with quantum complexity that depends on t and the approximation error.We obtain: Lemma 4.2.Let H and H (j) ∈ g be as above, > 0, and T > 0. Let G D (T, ) be an upper bound on the quantum complexity of approximating e −itH (r) D within error /2 for all t ≤ T and assume H (r) − H (r) D ≤ /(2T ).Then, there exist quantum circuits {V (t)} t that simulate H with parameters (T, , 2r + G D (T, )).
Proof.We use the circuit of Fig. 7 to implement V (t).Since each V (j) and (V (j) ) † has unit cost according to the assumptions, the quantum complexity of the circuit in Fig. 7 is 2r plus the cost of implementing e −itH (r) D .The correctness of this simulation method follows from simple norm properties (t ≤ T ): e −itH − V (1) . . .V (r) e −itH (r) D (V (r) ) † . . .(V (1) ) † = e −itH (r) − e −itH (r) If, in addition, we approximate e −itH (r) D with a quantum circuit U of quantum complexity at most G D (T, ) such that e −itH (r) D − U ≤ /2, then the overall approximation error is bounded by and the overall quantum complexity is 2r + G D (T, ).
V (1)   Figure 7: Hamiltonian simulation via Lie-algebra diagonalization.The quantum circuit describes the unitary Of particular interest for fast-forwarding via Lie-algebra diagonalization is the case where l is small relative to the dimension of the Hilbert space.This occurs for many quantum systems, such as quadratic fermionic systems, where the dimension of g is only polynomial in n.In this case, the Lie-algebra diagonalization method described above converges quickly, and to satisfy ≤ /(2T ), it suffices to choose r that is polynomial in n but only polylogarithmic in T / .If, in addition, the quantum complexity of approximating e −itH (r) D within error is also polynomial in n and polylogarithmic in T / , for t ≤ T , we attain exponential fast-forwarding: where p(n), q(n) = poly(n) and X D is the (diagonal) projection of X onto h.Let > 0 and T (n) = τ n for some τ > , we obtain exponential fast-forwarding.
Proof.The proof is a direct consequence of Lemma 4.2 when considering the sequence of Hamiltonians {H n } n and under the assumptions on the asymptotic scalings of quantum complexities.
In particular, the bounds in Eqs.(43) and dim g n = poly(n) allow us to set r = poly(n).The classical complexity of finding the unitaries V (j) is polynomial in the dimension of the Lie algebra and polylogarithmic in the precision, and thus is poly(n) under all the assumptions.
The requirements to achieve exponential fast-forwarding using the Lie-algebra diagonalization approach are satisfied by some important classes of Hamiltonians, such as quadratic fermionic and bosonic Hamiltonians, as we show below.While this diagonalization approach is efficient, in some cases it can be less efficient than directly decomposing the time evolution operator into a sequence of elementary quantum gates using a different approach [20,21].

Quadratic fermionic Hamiltonians
As one example of exponential fast-forwarding via Lie-algebra diagonalization, we consider fermionic Hamiltonians which are quadratic in the creation and annihilation operators.These are written as where we assume α ij = (α ji ) * , |α ij | ≤ 1, and Up to an additive constant, the terms in H span a compact Lie algebra g isomorphic to so(2n, R), where the Cartan subalgebra is spanned by {c † i c i − 1/2} i [49].This satisfies dim g = n(2n − 1), being polynomial in n, and we can obtain a bound of the form (43). Thus we can use the analysis of the Sec.4.1 to demonstrate exponential fast-forwarding.We obtain: Theorem 4.4 (Exponential fast-forwarding of quadratic fermionic Hamiltonians).Let {C n } n denote the classes of n-mode fermionic Hamiltonians acting on Fock spaces H n and {H n ∈ so(2n, R)} n be as in Eq. (44).Let > 0 and T (n) = τ n for some τ > 1.Then, there exist quantum circuits {V n (t)} n,t that are (T (n), , G(n))-fast-forwarding the Hamiltonians {H n } n on the spaces {H n } n , where G(n) = O(n 2 log(T (n))), and thus G(n) = poly(n).In particular, if l(n) = Ω(nT (n)), we obtain exponential fast-forwarding.
Proof.The circuits {V n (t)} n,t to simulate the Hamiltonians {H n } n are given in Fig. 7.For precision , it suffices to choose r in Lemma 4.1 such that H n is the Hamiltonian at the r-th step of the Lie-algebra diagonalization procedure that starts with H n , and H (r) n,D is its projection onto the Cartan subalgebra.The elements of the fermionic so(2n, R) algebra satisfy the bounds of Eq. (43).A precise analysis allows us to take p ).Thus, we choose ε = /(T (n)p(n)n 2 ) in Eq. (39), and it suffices to run iterations of the Lie-algebra diagonalization method for each n, which determines the complexity of V n (t).Each su(2) rotation V (j) in Fig. 7 is the exponential of a weight two fermionic operator and is thus an elementary gate in the fermionic model of computation.Since the exponential of the diagonal Hamiltonian H (r) n,D can be implemented as a sequence of O(n) rotations e −iθ j c † j c j , |θ j | ≤ π, we obtain the desired total quantum complexity G(n) = O(n 2 log(T (n))).

Quadratic bosonic Hamiltonians
The approach of Sec.4.1 may also be applied to quadratic bosonic Hamiltonians.However, for bosonic Hamiltonians containing non-number-conserving terms c i c j , c † i c † j , the real Lie algebra spanned by the Hermitian terms is noncompact (with complexification sp(2n, C)), and the Lie-algebra diagonalization technique cannot directly be used.Therefore, we consider numberconserving quadratic bosonic Hamiltonians where |α ij | ≤ 1 and α ji = α * ij .This simplification also allows us to restrict to subspaces S m of m total bosons, on which H is a bounded operator.It is clear that S m is invariant under H.By adding a constant to H, we identify the real Lie algebra g generated by the Hermitian terms of H as su(n), which has polynomial dimension dim g = n 2 − 1.The Cartan subalgebra consists of all elements of the form j γ j c † j c j where j γ j = 0 and γ j ∈ R. Then we can use the analysis of Sec.4.1 to show exponential fast-forwarding.Theorem 4.5 (Exponential fast-forwarding of number-conserving quadratic bosonic Hamiltonians).Let {C n } n denote the classes of n-mode, number-conserving bosonic Hamiltonians acting on Fock spaces H n and {H n ∈ su(n)} n be as in Eq. (47).Let > 0 and T (n) = τ n for some τ > 1.Consider the subspaces S m(n) with m(n) = poly(n).Then, there exist quantum circuits , and thus G(n) = poly(n).In particular, if l(n) = Ω(nT (n)), we obtain exponential fast-forwarding.
Proof.The proof is similar to that of Thm.4.4.By restricting to the subspace S m(n) , we may obtain bounds of the form (43), where p(n) = m(n) √ 2n .Since the initial distance to the Cartan subalgebra is d h (H n ) = O(n 2 ), we apply the Lie-algebra diagonalization method for iterations.As in the fermionic case, the su(2) rotations V (j) are elementary gates and the diagonal unitary e −itH (r) n,D can be decomposed as a sequence of O(n) rotations e −iθ j c † j c j , |θ j | ≤ π.Therefore, we obtain a total of G(n) = O(n 2 log(T (n))) gates.

Fast-forwarding and energy measurements
We revisit and further develop a connection between fast-forwarding and the time-energy uncertainty principle discussed in Ref. [15], using the setting described in Sec. 2. Our result, which also holds for polynomial fast-forwarding and polynomially-precise energy measurements, is roughly as follows.Suppose we can simulate a (normalized) Hamiltonian for time T using G(T ) elementary gates.Then we can measure the eigenenergies with accuracy O(1/T ) and high confidence using Õ(G(T )) elementary gates, where we dropped polylogarithmic factors in T .Conversely, suppose we can measure the eigenenergies of a Hamiltonian with accuracy δE and high confidence using G(δE) elementary gates.Then, we can simulate the Hamiltonian for time O(1/δE) using O(G(δE)) elementary gates.
To prove this result, we need to provide precise definitions of energy measurements that fit with those in Sec. 2.

Definition 5.1 (Accuracy of energy measurements). An energy measurement has accuracy δE and confidence level η > 0 if, on any input eigenstate of a Hamiltonian, we measure an outcome E that satisfies
where E is the energy of the eigenstate.

Conclusions and outlook
We studied the problem of fast-forwarding quantum evolution in various physical settings and under fairly general conditions, going beyond previous studies [15].We provided a definition of fast-forwarding that considers the model of quantum computation, the classes of Hamiltonians, and properties of the initial states, and used it to demonstrate exponential and polynomial fastforwarding in quantum systems of different particle statistics.These include spin systems that have a permutation-invariant property, frustration-free spin systems, and quadratic fermionic and bosonic systems.Our techniques could be used to demonstrate fast-forwarding of Hamiltonians not discussed in our work.For example, although we focused on quadratic fermionic and bosonic Hamiltonians as an application of Lie-algebra diagonalization in Sec.4.1, that method can be used for any Hamiltonian that is an element of a Lie algebra of small dimension; a recent result in Ref. [45] considers a related problem.Many open questions remain.First, we do not provide a characterization of all Hamiltonians that can be fast-forwarded but rather some examples.It would be interesting to understand this characterization better, as it has important consequences in quantum simulation and quantum complexity.Second, some examples of exponential fast-forwarding, such as those obtained via Lie-algebra diagonalization, are related to Hamiltonians that admit an efficient classical solution, for which spectral properties and related quantities may be computed classically efficiently [50][51][52][53][54]. Developing the connection between exponential fast-forwarding and efficient solvability further will be important for understanding the advantages of exponential fast-forwarding.Third, the polynomial fast-forwarding of Sec.3.2 applies to frustration-free spin Hamiltonians, but it might also be applied to the simulation of more general quantum field theories or other condensed matter systems, as we are often interested in the low-energy dynamics of such Hamiltonians.Fourth, our assumptions on the no-fast-forwarding line are based on no-fast-forwarding theorems in the literature, and extending these theorems to more general quantum systems would allow us to understand the level of fast-forwarding better when using our simulation methods.We expect that these and other questions will form the basis of further studies.

A Complexity of block diagonalizing permutation-invariant qubit Hamiltonians
We give a circuit description of the Schur transform U Sch for qubit (spin-1/2) systems, following Ref.[25].Although it is not the most efficient implementation in terms of gate complexity, it has the advantage of being explicit (without requiring a separate ancillary register for classical computation), and the unary encoding for the |J and |q registers is suitable for simulation of permutation-invariant qubit Hamiltonians in Thm.3.3.
Lemma A.1.The Schur transform U Sch for n-qubit systems can be implemented with O(n 3 ) two-qubit gates.
Proof.As the representation space of U (su(2)), the Hilbert space H = C 2 ⊗n = Q ⊗n 1/2 can be decomposed as where Q J = Sym 2J Q 1/2 is the spin-J irreducible representation space of dimension 2J + 1 and we write a J Q J to mean a J k=1 Q J , i.e., each irreducible representation Q J appears with multiplicity a J .The Schur transform U Sch changes the computational basis to the angular momentum basis.Explicitly, given an input state |x ∈ Q ⊗n 1/2 along with two ancilla registers initialized to |J = 0 , |q = 0 , the algorithm outputs a linear combination of Schur basis states with registers |J , |q , |p 1 , . . ., |p n .The register |J corresponds to the total angular momentum J, labeling the spin-J irreducible representation Q J of dimension 2J + 1.The register |q labels the basis vectors in the Q J representation.Since there are a J copies of each Q J in Q ⊗n 1/2 , the |p i registers label the different copies of Q J in the decomposition.It is crucial for implementing the evolution operator that in each copy, the |q registers label the same vectors.For example, |q = J is always the highest weight vector of the representation.The circuit is shown in Fig. 8. = |001 . . . .This way, a gate conditioned on J = J 0 or q = q 0 is controlled on one qubit instead of all the qubits representing |J or |q .Since n/2 is the maximum value of J, we will need O(n) qubits to represent J and q in this way, but the space H already required n qubits to represent, so the unary encoding does not significantly increase the space complexity.
The Schur transformation circuit is composed of n subroutines of Clebsch-Gordan transforms applied sequentially (Fig. 9) that are decomposed as in Fig. 10.In Fig. 10, the X gates on the |J and |q registers denote the transformation |a → |a + 1 2 .In the unary encoding, it is implemented as a series of swap gates (Fig. 11).Therefore, the X −1 and controlled-X 2 gates on the q and J registers are composed of O(n) elementary gates.If we interpret the computational basis of the |x i register as |0 = |−  The controlled R y gate of Fig. 10 denotes an operation that implements the rotation R y (θ J,q ) = cos θ J,q − sin θ J,q sin θ J,q cos θ J,q , (55) where cos θ J,q = 1 2 + q 2J + 1 , sin θ J,q = 1 2 It is decomposed as O(n 2 ) rotation gates, each with only two controls because of the unary encoding.An example is shown in Fig. 12 with n = 3 and x i = x 3 , the last instance of U CG in the decomposition of U Sch .We see from our decomposition that each U CG consists of O(n 2 ) gates, giving a total of O(n 3 ) gates to implement change of basis unitary U Sch .

B Proof of Theorem 5.3
We provide a proof of Thm.5.3 using the same method as in Ref. [15], but we reproduce it here to calculate the quantum complexity for non-exponential fast-forwarding and precision of energy measurements., (61) so that we have accuracy δE = 2πc 2 l and confidence bounded by η = 1 − 1 2(c−2) .In the (nonideal) circuit, there are l Hadamard and l single qubit rotation gates, O(lG) elementary gates from the controlled time evolution operators e i2 k H , and O(l 2 ) elementary gates to implement the quantum Fourier transform.Therefore, the total gate count is O(l 2 + lG).The error in the circuit is due to the nonideal time evolution operators from the Hamiltonian simulation algorithm.Since each of the l instances contribute an error of at most , the total error in the energy measurement circuit is at most ξ = l .
The converse statement that efficient energy measurements imply the ability to fast-forward makes use of the following lemma.(62) on S.
Proof.Let U be the ideal energy measurement circuit and Ũ be the approximation.In the ideal case (Fig. 14), we apply U , then apply the rotations e −itE for t ≤ T on the |E register, and finally undo the energy measurement by applying U † .When we replace U by Ũ , there will be 2G elementary gates from the applications of Ũ and Ũ † and at most G gates from the rotation e −itE , since the number of ancillary qubits needed to store the energy is at most the number of gates in the algorithm.Note that the binary encoding of |E allows us to implement e −itE in parallel as individual phase gates on the |E register.Thus, the total gate count is O(G).
If the energy measurement had perfect confidence η = 1 and zero error δE = 0, the ideal circuit would exactly fast-forward the Hamiltonian.The error in the actual circuit comes from the imperfect values of η, δE, and ξ.Denote the rotations e −itE by the unitary R. For any eigenstate |ψ E of H in the subspace S, we have ≤ ηδET + 2(1 − η). (65) 7 y + M o w g m c w j l 4 c A M 1 q E M D m s B g D M / w C m 9 O 4 r w 4 7 8 7 H o r X g 5 D P H 8 A f O 5 w / B K Y 8 w < / l a t e x i t > H n 1 < l a t e x i t s h a 1 _ b a s e 6 4 = " + a 9 c K O l s / f q C Y j 9 5 A B I m t S R j 2 u c = " > A A A B 7 H i c b V B N S 8 N A E J 3 U r 1 q / q h 6 9 L B b B U 0 l E 1 G P R S 4 8 V T F t o Q 9 l s N + 3 S z S b s T o Q S + h u 8 e F D E q z / I m / / G b Z u D V h 8 M P N 6 b Y W Z e m E p h 0 H W / n N L a + s b m V n m 7 s r O 7 t 3 9 Q P T x q m y T T j P s s k 4 o N w V t 9 + S 9 p X 9 S 9 q 7 p 7 f 1 l r 3 B Z x l O E E T u E c P L i G B j S h B T 4 w E P A E L / D q K O f Z e X P e l 6 0 l p 5 g 5 h l 9 w P r 4 B 5 R 2 O v g = = < / l a t e x i t > H n Quantum complexity < l a t e x i t s h a 1 _ b a s e 6 4 = " P r 5 a P g X p c w 4 N a U 2 P S o 9 h h y m m H r / 4 f b / 4 b 0 3 Y P 2 v p g 4 P H e D D P z g p g z b V z 3 2 8 m t r W 9 s b u W 3 C z u 7 e / s H x c O j l p a J

Figure 1 :
Figure 1: Examples of fast-forwarding and no-fast-forwarding according to Def. 2.4.For fast-forwarding, the quantum complexity G F F (n) crosses the lower bound l (n, t) and lies under the no-fast-forwarding line l(n), and G FF (n)/l(n) → 0. For no-fast-forwarding, the quantum complexity G no−FF (n) lies above l(n).Exponential or polynomial fast-forwarding is obtained depending on the asymptotic behavior of G(n) and l(n).The Hamiltonians {H n } n belong to classes {C n } n and model quantum systems of different sizes n.

Figure 2 :
Figure 2: The quantum circuit V (t) simulating the time evolution of a block diagonalizable Hamiltonian.The dashed box denotes the unitary U (t), which implements U µ (t) conditional on |µ A .

Figure 3 :
Figure3: Efficient implementation of U (t) using C, a reversible version of a classical circuit that outputs a description of U µ (t) on input µ.The ancillary system is comprised of two registers: A needed to encode µ and A needed to encode the description of U µ (t).

Theorem 3 . 2 (
Because the dimensions of the blocks are polynomial, we obtain an efficient circuit U (t) for simulating the block diagonal Hamiltonians in the Schur basis, obtaining the following result for permutation-invariant Hamiltonians: Exponential fast-forwarding of permutation-invariant Hamiltonians).Let {C n } n denote the classes of k-local, n-spin Hamiltonians of dimension d acting on spaces H n = C d ⊗nand {H n ∈ C n } n be a sequence of permutation-invariant Hamiltonians.Then, for given > 0, T (n) = d 2n , there exist quantum circuits {V n (t)} n,t in the standard gate model that are (T (n), , G(n))-fast-forwarding the Hamiltonians {H n } n on the spaces {H n } n , where G(n) = poly(n).In particular, if l(n) = Ω(nT (n)), this implies exponential fast-forwarding.Proof.For a given n, Fig.4shows the circuit used to simulate the Hamiltonian H = H n for time t.The Schur transform U Sch block diagonalizes the Hamiltonian H as follows.Consider an n-spin input state |x ∈ H along with an ancillary state |0 A .The unitary U Sch is a basis transformation according to the Schur-Weyl duality.In the Schur basis, basis states |λ of a register A 1 label the Young diagram while each basis state |p ∈ P λ of a register A 2 labels a basis vector of the corresponding symmetric group irreducible representation, and A = A 1 ∪ A 2 in the notation of Sec.3.1; see Eq. (5) and Fig.2.Also, the basis states |q satisfy |q ∈ Q λ ⊆ H .The input state is then mapped to a linear combination of the Schur basis states {|q H ⊗ |λ A 1 ⊗ |p A 2 } q,λ,p .As we have argued, H is block diagonal in the Schur basis, only acting on H conditioned on |λ A 1 .

Theorem 3 . 3 (
Exponential fast-forwarding of permutation-invariant qubit Hamiltonians).Let {C n } n denote the classes of k-local, n-qubit Hamiltonians acting on spaces H n = C 2 ⊗n and {H n ∈ C n } n be a sequence of permutation-invariant qubit Hamiltonians.Then, for given > 0, T (n) = 2 2n , there exist quantum circuits {V n (t)} n,t in the standard gate model that are (T (n), , G(n))-fast-forwarding the Hamiltonians {H n ∈ C n } n on the spaces {H n } n , where G(n) = O(n 3 ).In particular, if l(n) = Ω(nT (n)), this implies exponential fast-forwarding.

Figure 5 :
Figure 5: The quantum circuit U (t) implementing the evolution of the block diagonal Hamiltonian in the Schur basis for n = 3 qubits.This corresponds to the middle block of Fig. 4.Each controlled U J (t) operation consists of O(n 2 ) elementary gates.

Theorem 4 . 3 (
Exponential fast-forwarding via Lie-algebra diagonalization).Let {C n } n denote classes of Hamiltonians acting on spaces {H n } n and H n ∈ C n , H n ∈ g n , where g n is a compact, semisimple Lie algebra of dim g n = poly(n).Assume d h (H n ) = poly(n) and that, for any X

Figure 8 : 2 =
Figure 8: The Schur transformation circuit.On an input |x , the output is a linear combination of the basis states |J ⊗ |q ⊗ |p .

Figure 10 :Figure 11 :
Figure 10: A decomposition of the Clebsch-Gordan unitary U CG with output a linear combination of the basis states |J ⊗ |q ⊗ |p i .
where c is a positive integer and x = 2 l E+1 2π for an eigenstate of energy E. Thus,Pr(|m − x| > c) ≤ Pr(|m − x | > c − 1)

Figure 14 :
Figure 14: The quantum simulation circuit using energy measurements.
Definition 2.2 (Hamiltonian-simulation parameters).Let {H n } n be a sequence of Hamiltonians acting on Hilbert spaces {H n } n .The quantum circuits {V n (t)} n,t simulate the Hamiltonians {H n } n on subspaces {S n ⊆ H n } n with parameters (T (n), (n), G(n)) if the quantum complexity is at most G(n) in a given model of quantum computation and, for each n, all |ψ n ∈ S n , and all Definition 2.4 (Fast-forwarding).Let {C n } n denote classes of Hamiltonians, i.e.C n is a subset of the Hermitian operators acting on H n , and let T (n) ≥ 0 and (n) ≥ 0 be functions of n.The quantum circuits {V n (t)} n,t are said to be (T (n), (n), G(n))-fast-forwarding a Hamiltonian sequence {H n ∈ C n } n on subspaces {S n } n if the following hold: 1.The quantum circuits {V n (t)} n,t simulate the Hamiltonians {H n } n with parameters [25,26] λ and P λ are the irreducible representations of the unitary group U (d) and symmetric group S n , respectively, labeled by the Young diagrams λ ∈ Part(n, d).An efficient quantum algorithm to implement the Schur transform U Sch is shown in Refs.[25,26]and analyzed in detail for the case d = 2 in Appendix A.
itH |x H Figure4: The quantum circuit that simulates the time evolution of a permutation-invariant Hamiltonian.The ancillary register A appearing in Eq. (5) contains two registers A 1 and A 2 in this case.The state after the basis transformation U Sch is in general a linear combination of Schur basis states {|q H ⊗ |λ A 1 ⊗ |p A 2 } q,λ,p .
1.If the quantum complexity of simulating the diagonal version of H n for time t ≤ T (n) within precision /2 is G D (t, ) = poly(n, log(t H n / )), then there exist quantum circuits {V n (t)} n,t that are (T (n), , G(n))-fast-forwarding the Hamiltonians {H n } n on the spaces {H n } n , where 12 , |1 = |12 , the X −1 and controlled-X 2 gates together implement the controlled sum operation |q |x i → |q + x i |x i and |J |x i → |J + x i |x i .Figure 9: The Schur transformation U Sch as a sequence of Clebsch-Gordan unitaries.The output is a linear combination of basis states |J ⊗ |q ⊗ |p .