We present the problem of approximating the time-evolution operator e−iH^t to error ϵ , where the Hamiltonian H^=(⟨G|⊗I^)U^(|G⟩⊗I^) is the projection of a unitary oracle U^ onto the state |G⟩ created by another unitary oracle. Our algorithm solves this with a query complexity O(t+log(1/ϵ)) to both oracles that is optimal with respect to all parameters in both the asymptotic and non-asymptotic regime, and also with low overhead, using at most two additional ancilla qubits. This approach to Hamiltonian simulation subsumes important prior art considering Hamiltonians which are d -sparse or a linear combination of unitaries, leading to significant improvements in space and gate complexity, such as a quadratic speed-up for precision simulations. It also motivates useful new instances, such as where H^ is a density matrix. A key technical result is `qubitization', which uses the controlled version of these oracles to embed any H^ in an invariant SU(2) subspace. A large class of operator functions of H^ can then be computed with optimal query complexity, of which e−iH^t is a special case.
We present the problem of approximating the time-evolution operator e−iH^t to error ϵ , where the Hamiltonian H^=(⟨G|⊗I^)U^(|G⟩⊗I^) is the projection of a unitary oracle U^ onto the state |G⟩ created by another unitary oracle. Our algorithm solves this with a query complexity O(t+log(1/ϵ)) to both oracles that is optimal with respect to all parameters in both the asymptotic and non-asymptotic regime, and also with low overhead, using at most two additional ancilla qubits. This approach to Hamiltonian simulation subsumes important prior art considering Hamiltonians which are d -sparse or a linear combination of unitaries, leading to significant improvements in space and gate complexity, such as a quadratic speed-up for precision simulations. It also motivates useful new instances, such as where H^ is a density matrix. A key technical result is `qubitization', which uses the controlled version of these oracles to embed any H^ in an invariant SU(2) subspace. A large class of operator functions of H^ can then be computed with optimal query complexity, of which e−iH^t is a special case.
We present a quantum algorithm for approximating the real time evolution e−iHt of an arbitrary d-sparse Hamiltonian to error є, given black-box access to the positions and b-bit values of its non-zero matrix entries. The query complexity of our algorithm is O((t√d||H||1 → 2)1+o(1)/єo(1)) with respect to the largest Euclidean row norm ||H||1 → 2, which is shown to be optimal up to subpolynomial factors through a matching lower bound, and it uses a factor O(b) more gates. This provides a polynomial speedup in sparsity for the common case where the spectral norm is known, and generalizes previous approaches which achieve optimal scaling, but with respect to more restrictive parameters. By exploiting knowledge of the spectral norm, our algorithm solves the black-box unitary implementation problem – O(d1/2+o(1)) queries suffice to approximate any d-sparse unitary in the black-box setting, which matches the quantum search lower bound of Ω(√d) queries and improves upon prior art [Berry and Childs, QIP 2010] of Õ(d2/3) queries. Combined with known techniques, we also solve systems of sparse linear equations with condition number κ using O((κ √d)1+o(1)/єo(1)) queries, which is a quadratic improvement in sparsity.
We give a quantum algorithm for simulating a d-sparse Hermitian Hamiltonian H, assuming a known upper bound Λ on its maximum column Euclidean norm ∥H∥1→2. For tΛ≥1/2, simulation with operator-norm error ε uses O(tΛd+dlog(2/ε)) sparse-oracle queries. This removes the subpolynomial overhead in Low's algorithm [STOC 2019], replacing it with an additive logarithmic precision term. For d>1 and tΛ≥log(2/ε), the bound matches the worst-case lower bound. A known spectral-norm upper bound may also be used in place of Λ. The number of 1- and 2-qubit gates is linear in the query scale, up to oracle costs and polynomial overhead in the input bit lengths and logarithmic precision parameters.
As applications, we obtain O(κdpolylog(κ/ε)) queries for solving d-sparse quantum linear systems with ∥A∥≤1 and ∥A−1∥≤κ, under standard sparse and state-preparation access. We also give a gate-efficient implementation of black-box unitaries with at most d nonzero entries per row and column using O(dlog(2/ε)) queries, given sparse access to the unitary and its adjoint. At constant error, the query bound is optimal and yields Θ(N) queries for arbitrary N×N unitaries, resolving the open question on black-box unitary implementation posed by Berry and Childs [QIC 2012].
We give a quantum algorithm for Lindbladian simulation given a block encoding of the Hamiltonian H and a projected unitary encoding of the stacked jump operator B=∑k=1m∣k⟩⊗Lk, with normalization factors αH and αB, respectively. For evolution time t, set τ=(αH+αB2)t. The algorithm approximates the evolution channel to diamond-norm error ε using O(τ+log(e+log(1/ε)/τ)log(1/ε)) oracle queries, matching the query lower bound for Hamiltonian simulation. The number of additional one- and two-qubit gates is linear in the query complexity up to polylogarithmic factors. The query- and gate-complexity bounds extend to Lipschitz-continuous time-dependent Lindbladians under coherent time-indexed oracle access. Our construction uses a one-query transducer that implements a product of rational approximations to short-time evolution when supplied with a catalyst. We bound the error from omitting the catalyst by exploiting orthogonality between different sequences of Kraus labels. The gate implementation combines a compressed Kraus-label representation, which stores only the positions and values of the nonzero labels, with the rotation factorization of Chen et al.
We provide a quantum algorithm for simulating the dynamics of sparse Hamiltonians with complexity sublogarithmic in the inverse error, an exponential improvement over previous methods. Specifically, we show that a d-sparse Hamiltonian H on n qubits can be simulated for time t with precision ε using O(τlog(τ/ε)/log log(τ/ε)) queries and O(τnlog2(τ/ε)/log log(τ/ε)) additional 2-qubit gates, where τ=d2||H||maxt. Unlike previous approaches based on product formulas, the query complexity is independent of the number of qubits acted on, and for time-varying Hamiltonians, the gate complexity is logarithmic in the norm of the derivative of the Hamiltonian. Our algorithm is based on a significantly improved simulation of the continuous- and fractional-query models using discrete quantum queries, showing that the former models are not much more powerful than the discrete model even for very small error. We also significantly simplify the analysis of this conversion, avoiding the need for a complex fault correction procedure. Our simplification relies on a new form of "oblivious amplitude amplification" that can be applied even though the reflection about the input state is unavailable. Finally, we prove new lower bounds showing that our algorithms are optimal as a function of the error.
We give a query-optimal algorithm for simulating a general n-qubit time-dependent Hamiltonian H(t) on [0,T], assuming that H is Lipschitz continuous and ∥H(t)∥≤α. In the standard $\mathrm{HAM\mbox{-}T}$ access model, the algorithm approximates the time-ordered propagator UH(T) to error ε using O(αT+log(e+log(1/ε)/(αT))log(1/ε)) $\mathrm{HAM\mbox{-}T}$ queries. This matches the known query lower bound for time-independent Hamiltonians, showing that time dependence incurs no asymptotic query overhead.
Our method first constructs a one-query transducer that, given an auxiliary state, implements an approximation to UH(T) and returns the state unchanged. A weighted combination of circuits that apply the transducer different numbers of times makes the error caused by omitting this state decay factorially, yielding the stated optimal precision dependence. For time-independent Hamiltonians, the same method also gives a query-optimal alternative to qubitization.
We consider the task of simulating time evolution under a Hamiltonian H within its low-energy subspace. Assuming access to a block-encoding of H ′ := ( H − E ) / λ , for some λ > 0 and E ∈ R , the goal is to implement an ϵ -approximation to the evolution operator e − i t H when the initial state is confined to the subspace corresponding to eigenvalues [ − 1 , − 1 + Δ / λ ] of H ′ , for Δ ≤ λ . We present a quantum algorithm that requires O ( t λ Γ + λ / Γ log ( 1 / ϵ ) ) queries to the block-encoding for any choice of Γ such that Δ ≤ Γ ≤ λ . When the parameters satisfy log ( 1 / ϵ ) = o ( t λ ) and Δ / λ = o ( 1 ) , this result improves over generic methods with query complexity Ω ( t λ ) . Our quantum algorithm leverages spectral gap amplification and the quantum singular value transform.For a given H , the block-encoding of its H ′ must be prepared efficiently to achieve an asymptotic speedup in simulating the low-energy subspace; we refer to these Hamiltonians as g a p − a m p l i f i a b l e . We show necessary and sufficient conditions for gap amplifiability in terms of an operationally useful decomposition of H