Pith. sign in

REVIEW 3 major objections 5 minor 1 cited by

Time-Dependent Hamiltonian Simulation via Time-Independent Dynamics in a Larger Space

T0 review · 3 major / 5 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Time-dependent Hamiltonian simulation reduces to time-independent evolution on a larger clock space at the same asymptotic cost as the best known algorithms.

desk verdict A genuinely promising clock-based time-dependent Hamiltonian simulation algorithm whose proof has a real dimensional error in Lemma 9 and a few other gaps, but the central idea is coherent and likely fixable. read the letter →

arxiv 2507.19345 v1 pith:ZG42EJCQ submitted 2025-07-25 quant-ph

Zecheng Li , Chunhao Wang This is my paper · ORCID
classification quant-ph MSC 81P68
keywords time-dependentHamiltoniansimulationdiscreteclockDuhamel'sprincipleGaussianquadraturelinearcombinationofblock-encodingssparse-accessmodelquantumcomplexityancillaoverhead
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Time-dependent Hamiltonians are more realistic than static ones but harder to simulate because the evolution is time-ordered. This paper shows that the problem can be reduced to time-independent evolution in a larger space: a coherent clock register advances stepwise and controls which $H(t)$ acts, so the whole joint system evolves under a single time-independent Hamiltonian. The authors prove that this discrete-clock strategy, with Duhamel's principle and Gaussian quadrature, reaches the same asymptotic query complexity as the best known time-dependent simulation methods, $O(dTH_{\max}\log(TdH_{\max}/\epsilon)/\log\log(TdH_{\max}/\epsilon))$ queries for $d$-sparse $n$-qubit Hamiltonians. This matters because it says the intuitive “external clock” picture is not just a proof of concept with extra cost; it is a computationally competitive way to model and simulate time-dependent systems.

What carries the argument

The load-bearing object is the discrete clock: $M$ clock states $|n\rangle$ label slices of width $\delta=T/M$, with $H_{\mathrm{sys}}$ applying $H(n\delta)$ on slice $n$ and $H_{\mathrm{clk}}=(1/\delta)\log U_+$ shifting the clock by one step per slice. Its norm is large, about $M/T$, so the paper never simulates $H_{\mathrm{clk}}$ directly in the time domain; instead a Fourier transform converts it to a diagonal operator $D$ that can be fast-forwarded. Duhamel's principle then separates $D$ from the system part $B$, writing $e^{-i(D+B)t}$ as $e^{-iDt}$ times a series of nested integrals of rotated block-encodings $e^{iDs}Be^{-iDs}$. Scaled Gauss–Legendre quadrature converts each nested integral into a weighted sum of unitary products, and the weights are prepared by an efficient state-preparation routine based on Legendre-weight asymptotics. This combination is what removes the earlier quadratic-in-time overhead and keeps the precision dependence polylogarithmic.

What would settle it

Evaluate the bound in Lemma 9 on a concrete Hamiltonian with known $\dot{H}_{\max}$, e.g. $H(t)=\sigma_z\cos(\omega t)$, by computing the norm difference $\|e^{-i(H_{\mathrm{clk}}+H_{\mathrm{sys}})T}|0\rangle|\psi\rangle-|T\rangle U(T,0)|\psi\rangle\|$ as $M$ grows. If the error follows $T^2\dot{H}_{\max}/(2\sqrt{M})$, then the paper's $M=O(T^4\dot{H}_{\max}/\epsilon^2)$ is dimensionally off and the clock register must scale as $T^4\dot{H}_{\max}^2/\epsilon^2$; a more favorable scaling would support the stated lemma.

Watch

Extended reading notes

Core claim

The central claim, Theorem 1, is that for a $d$-sparse time-dependent Hamiltonian $H(t)$ on $n$ qubits, $t\in[0,T]$, the time-ordered evolution $U(T)=\mathcal{T}\exp(-i\int_0^T H(t)\,dt)$ can be simulated to precision $\epsilon$ with $O(dTH_{\max}\log(TdH_{\max}/\epsilon)/\log\log(TdH_{\max}/\epsilon))$ queries to the sparse-access oracles, where $H_{\max}$ bounds the max-norm of $H(t)$, plus the gate and ancilla costs stated in the theorem. The strategy is to prepare $|T\rangle\otimes U(T)|\psi\rangle$ by evolving the joint state under $H_{\mathrm{clk}}+H_{\mathrm{sys}}$, with $H_{\mathrm{sys}}=\sum_n |n\rangle\langle n|\otimes H(n\delta)$ and $H_{\mathrm{clk}}=(1/\delta)\log U_+$ on $M$ clock states; after a Fourier transform the clock part becomes a large diagonal operator $D$, and Duhamel's principle expands $e^{-i(D+B)T}$ into $e^{-iDT}$ times a series of multiple integrals. Scaled Gauss–Legendre quadrature approximates those integrals as a weighted sum of products of block-encoded unitaries, implemented as a linear combination of block-encodings. The claimed upshot is that the discrete-clock framework matches the performance of interaction-picture and truncated-Dyson methods, and that it improves on the earlier clock construction's quadratic-in-$T$ and polynomial-in-$1/\epsilon$ overhead.

Load-bearing premise

The load-bearing premise is Lemma 9's claim that a clock dimension $M=O(T^4\dot{H}_{\max}/\epsilon^2)$ suffices—where $\dot{H}_{\max}$ is the maximum rate of change of $H(t)$—to make the discrete-clock evolution approximate the true time-ordered evolution within $\epsilon$; the paper's own displayed error $T^2\dot{H}_{\max}/(2\sqrt{M})$ actually forces $M=\Omega(T^4\dot{H}_{\max}^2/\epsilon^2)$, so this premise, as stated, needs repair.

Editorial extensions

If this is right

  • The discrete-clock reduction now carries the same worst-case query complexity as interaction-picture and truncated-Dyson algorithms, so viewing time dependence as a larger time-independent system costs nothing asymptotically in queries.
  • The ancillary cost is only polylogarithmic in $1/\epsilon$ plus a logarithm of the clock dimension, so high-precision simulations remain practical in this framework.
  • Because $H_{\mathrm{clk}}$ is never simulated directly—only its diagonal Fourier image is fast-forwarded—the method is a concrete template for compiling time-ordered dynamics into a time-independent circuit.
  • With Hamiltonian rescaling, the method adapts to $L^1$-norm dependence, making it competitive for Hamiltonians whose norm fluctuates strongly over time.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The proof's Lemma 9 appears dimensionally inconsistent: the displayed error $T^2\dot{H}_{\max}/(2\sqrt{M})$ forces $M=\Omega(T^4\dot{H}_{\max}^2/\epsilon^2)$, not $M=O(T^4\dot{H}_{\max}/\epsilon^2)$; if so, the clock-register size changes but the theorem's query complexity likely survives.
  • The same Duhamel-plus-quadrature structure should apply to any time-ordered product in which one factor is diagonal and fast-forwardable, for instance Lindblad or Floquet propagators, giving a testable extension beyond unitary Hamiltonian simulation.
  • A direct numerical check of the commutator error on a simple two-level time-dependent Hamiltonian would settle whether the $M^{-1/2}$ improvement over naive step splitting in Eq. (36) is real or an artifact of the bound.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper proposes a quantum algorithm for simulating a d-sparse time-dependent Hamiltonian H(t) on n qubits over t in [0,T] by embedding the evolution into a time-independent Hamiltonian in a larger space. The construction uses a discrete clock whose Hamiltonian is the logarithm of a cyclic increment operator, together with a system Hamiltonian diagonal in the clock register. The authors invoke Duhamel's principle to separate the clock and system parts, approximate the resulting multiple integrals by scaled Gauss-Legendre quadrature, and implement the resulting linear combination of unitaries via block-encoding and Grover-Rudolph state preparation. The stated main result, Theorem 1, gives O(dTHmax log(TdHmax/epsilon)/loglog(TdHmax/epsilon)) oracle queries plus the gate and ancilla counts shown in Eqs. (6)-(8). The paper is positioned as a proof of concept that the discrete-clock reduction can match the state-of-the-art complexity for time-dependent Hamiltonian simulation, improving on the earlier clock construction of Watkins et al.

Significance. If the proof were completed, the result would be conceptually significant: it would show that a simple discrete-clock Hamiltonian, despite having a large norm, can support a simulation algorithm matching the best known time-dependent simulation bounds, rather than the quadratic-in-time scaling of the earlier discrete-clock work. The algorithmic structure -- Duhamel separation of clock and system, Gaussian quadrature in the interaction frame, and separate Grover-Rudolph preparation of quadrature amplitudes -- is a genuinely different route from the standard truncated Dyson series and interaction-picture algorithms. However, the significance is conditional because the central error analysis contains a dimensionally inconsistent scaling in Lemma 9, an unresolved inconsistency in the number of quadrature points between Eqs. (71) and (87), and a quadrature notation that is too garbled to verify Lemma 11. These issues are not cosmetic; they propagate into the clock norm, the quadrature order, and the final complexity statements.

major comments (3)
  1. [Section 3, Lemma 9 (Eqs. 28-40)] The scaling of M in Lemma 9 is dimensionally inconsistent and understates the clock norm. The per-step error Eq. (35) is epsilon_1 = O(T^2 Hdotmax/(2 M^{3/2})). Summing over M steps gives epsilon_0 = O(T^2 Hdotmax/(2 sqrt(M))) in Eq. (36). Setting epsilon_0 <= epsilon therefore requires M = Omega(T^4 Hdotmax^2/epsilon^2), not M = O(T^4 Hdotmax/epsilon^2) as printed in Eq. (37) and Eq. (25). The same problem appears in Eq. (12), which states M = Theta(T^3 Hdotmax/epsilon^2). Consequently Eq. (38) and Eq. (40) bound ||Hclk|| = ||D|| by O(T^3 Hdotmax/epsilon^2) whereas the corrected M would give O(T^3 Hdotmax^2/epsilon^2). Since Lemma 11's quadrature error (Eq. (66)) scales as ||D||^{2q}, the subsequent choices of q in Eqs. (71) and (87) and the gate count in Eq. (92) are all derived from an underestimated ||D||. This is a load-bearing error in the proof of Theorem 1.
  2. [Section 4.2, Eqs. (71) and (87)] The manuscript gives two different lower bounds for the number q of Gauss-Legendre quadrature points. Eq. (71) states q >= Omega(T^6 alpha^2 Hdotmax/epsilon^2), while Eq. (87) states q >= Omega(T^4 Hdotmax/epsilon^2). These differ by a factor T^2 alpha^2 and are never reconciled. Moreover, as printed, both expressions have units of time^2 when Hdotmax has units of inverse time squared, so they are dimensionally inconsistent on their face; the corrected expressions should involve Hdotmax^2, as follows from the corrected ||D|| in Lemma 9. Because the state-preparation gate count in Eq. (92) and the ancilla count in Eq. (98) depend on log q, the proof of the final complexity statement is not established until this inconsistency is resolved.
  3. [Section 4.2, Eqs. (57)-(62) and Lemma 12] The quadrature approximation that underlies Lemma 11 cannot be checked as written. Eq. (57) defines scaled nodes s_k x_j / t and scaled weights s_k w_j / t, but the subsequent definitions in Eqs. (58)-(60) introduce u_j(x) = x \hat s_j / t and v_j(x) = x w_j / t, with \hat x_{jk} := \hat s_{jk}, without clarifying whether \hat s_j denotes an unscaled Legendre root or a scaled root, and whether the composition in Eq. (62) respects the simplex 0 <= s_1 <= ... <= s_k <= t. This ambiguity directly impacts the correctness of Eq. (63) and the error bound Eq. (65). In addition, Lemma 12's proof is not fully rigorous: the statement claims preparation with O(log 1/epsilon) gates using q = Omega((1/epsilon^2) log(1/epsilon)), but the proof's reference to 'the full sum ... = t^{ell+1}/(ell+1)' introduces a parameter t that is not defined in the lemma and is not the integration interval of the unscaled Gauss-Legendre quadrature. Since Eq. (92) relies on Lemma 12 to claim O(log q) state preparation, this gap is load-bearing for the gate complexity claim.
minor comments (5)
  1. [Section 2.3, Eq. (14)] The weight formula uses P'_n(x_j), but the quadrature has q points and should refer to P'_q(x_j); the notation should be made uniform with the rest of the section.
  2. [Theorem 1, statement] The theorem says 'the evolution of H(T) for time T' should be simulated; the intended statement is likely the evolution generated by H(t) for t in [0,T]. This should be corrected.
  3. [Section 3, Eq. (29)] The inequality 'M = O(T^2/epsilon max_s ||Hdot(s)||)' after Eq. (28) is stated as a sufficiency condition but should be an Omega-lower bound on M to make the Riemann-sum error at most epsilon; the direction of the asymptotic notation is misleading.
  4. [Section 4.3, Eq. (92)] The displayed gate complexity O(K + K log q) is then simplified to a form containing log(T Hdotmax/epsilon); after the corrected scaling in Lemma 9 and the corrected q, the simplification should be re-derived explicitly, since the current text jumps from q = O(T^4 Hdotmax log^3(1/epsilon)/epsilon^2) to a final expression without showing the intervening steps.
  5. [Appendix A, Lemma 7 proof] The proof swaps between P'_n and P'_q in the weight formula and in the asymptotic expansion; using a single symbol for the degree would improve readability.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: all parameters are chosen from independent error bounds; self-citations provide background tools, not the central claim.

full rationale

The paper's central claim is an upper bound on query, gate, and ancilla complexity for time-dependent Hamiltonian simulation via a discrete clock. The construction defines Hclk and Hsys from the input Hamiltonian H(t) and a free clock dimension M; Lemma 9 chooses M so that the error between the joint evolution and the target time-ordered evolution is below epsilon. That error bound depends on ||dH/dt|| and T, not on the theorem's final complexity expression. The later choices of quadrature order q, truncation order K, and segment length are obtained from explicit error inequalities in Lemmas 10-11 and Eqs. (70)-(87), using ||D|| (derived from ||Hclk||), ||B|| (which is Hmax), t, and epsilon; no fitted parameter is renamed as a prediction. The self-citations [LW23b] supply a generic linear-combination-of-block-encodings lemma, while [CL25, LW23a, HLL+24] provide background technique; the load-bearing Duhamel formula is proved in the appendix rather than assumed from a self-citation. The paper openly acknowledges that its method matches [LW19] and [KSB19] in complexity and is not presenting a relabeled known result as new. The skeptical concern that Lemma 9's Eq. (37) underestimates M by a factor of Hdot is a possible correctness flaw in the error accounting, but it is not circular: the error bounds remain independent of the theorem statement. No circular step can be exhibited from the paper's own equations or citations.

Assumptions & free parameters 4 free parameters · 5 assumptions · 0 invented entities

The paper introduces no new physical entities; the clock register is a standard ancillary construction. All free parameters are algorithmic design choices made to satisfy error bounds, not fitted to data. The main external inputs are standard sparse-access oracles and standard quantum algorithmic lemmas.

free parameters (4)
  • M, clock register dimension / number of time steps = O(T^4 Hdotmax / epsilon^2) per Lemma 9 (likely needs Hdotmax^2)
    Chosen to balance discretization error against clock norm; it enters all complexity expressions through log M.
  • q, number of Gauss-Legendre quadrature points per level = Omega(T^6 alpha^2 Hdotmax / epsilon^2) in Eq. (71), later Omega(T^4 Hdotmax / epsilon^2) in Eq. (87)
    Chosen to suppress quadrature error from the large clock norm ||D||; the two statements are inconsistent in the text.
  • K, Duhamel truncation order = Theta(log(T alpha / epsilon) / loglog(T alpha / epsilon))
    Chosen to bound the tail of the Duhamel series in each short segment.
  • t, segment length = Theta(1/alpha), alpha = d Hmax
    Chosen so that t||B|| = Theta(1), making the LCU success probability constant per segment.
assumptions (5)
  • domain assumption Sparse-access oracle model with bounded Hmax and Hdotmax (Section 2.1, Definition 3).
    The algorithm assumes d-sparse H(t), differentiable with bounded derivative, and oracle access to entries. This is the standard input model from LW19.
  • standard math Gauss-Legendre quadrature error formula and asymptotic spacing/weight estimates (Lemmas 6-8, citing BFP96 and Sze75).
    Used to bound quadrature error and to prepare weight superpositions; standard numerical analysis results.
  • standard math Duhamel principle / variation of parameters formula (Lemma 10).
    Expansion of e^{-i(D+B)t} as a Volterra series; standard ODE theory.
  • standard math Block-encoding and LCU machinery (Lemma 5 from LW23b; GSLW19 product of block-encodings).
    Used to implement the linear combination of operators; established quantum algorithm tools.
  • domain assumption Grover-Rudolph state preparation is valid for the approximate weight distributions (Lemma 12).
    The paper claims O(log 1/epsilon) gate state preparation with a sketched proof; the proof is not fully detailed and assumes positivity of x^ell w_j over the quadrature nodes.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Time-Dependent Hamiltonian Simulation via Time-Independent Dynamics in a Larger Space." pith.science (2026). https://pith.science/paper/ZG42EJCQ

@misc{pith2026250719345,
  author       = {Pith},
  title        = {Pith review of: Time-Dependent Hamiltonian Simulation via Time-Independent Dynamics in a Larger Space},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZG42EJCQ}},
  note         = {Machine review of arXiv:2507.19345}
}
read the original abstract

In this paper, we present a proof-of-concept quantum algorithm for simulating time-dependent Hamiltonian evolution by reducing the problem to simulating a time-independent Hamiltonian in a larger space using a discrete clock Hamiltonian construction. A similar construction was first explored for this simulation problem by Watkins, Wiebe, Roggero, and Lee [PRX Quantum, 2024]. Our algorithm improves upon their work in terms of the dependence on evolution time and precision. In addition, the complexity matches the state-of-the-art simulation algorithms using other approaches. To achieve this improvement, we use Duhamel's principle to treat the clock and system Hamiltonians separately and exploit properties of Gaussian quadrature to reduce the simulation cost. Our approach demonstrates that time-dependent Hamiltonian simulation can be as efficient in a simpler framework and hence provides a new angle to model and simulate time-dependent systems.

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. High-order Magnus Expansion for Hamiltonian Simulation

    quant-ph 2025-09 conditional novelty 7.0 of 10

    Arbitrary-order Magnus expansion is shown to have commutator-scaling error bounds and a polynomial-cost quantum circuit, yielding a time-dependent Hamiltonian simulation algorithm with O~(αbar^{1+1/p} T^{1+1/p}/ε^{1/p...

Reference graph

Works this paper leans on

43 extracted references · 33 canonical work pages · cited by 1 Pith paper

  1. [1]

    Quantum error correction below the surface code threshold

    Rajeev Acharya, Dmitry A Abanin, Laleh Aghababaie-Beni, Igor Aleiner, Trond I Andersen, Markus Ansmann, Frank Arute, Kunal Arya, Abraham Asfaw, Nikita Astrakhantsev, et al. Quantum error correction below the surface code threshold. Nature , 2024

    work page 2024

  2. [2]

    Quantum supremacy using a programmable superconducting processor

    Frank Arute, Kunal Arya, Ryan Babbush, Dave Bacon, Joseph C Bardin, Rami Barends, Rupak Biswas, Sergio Boixo, Fernando GSL Brandao, David A Buell, et al. Quantum supremacy using a programmable superconducting processor. Nature , 574(7779):505--510, 2019

    2019

  3. [3]

    Adiabatic quantum state generation and statistical zero knowledge

    Dorit Aharonov and Amnon Ta-Shma. Adiabatic quantum state generation and statistical zero knowledge. In Proceedings of the 35th Annual ACM Symposium on Theory of Computing (STOC 2003) , pages 20--29. ACM, 2003

    work page 2003

  4. [4]

    Efficient quantum algorithms for simulating sparse H amiltonians

    Dominic W Berry, Graeme Ahokas, Richard Cleve, and Barry C Sanders. Efficient quantum algorithms for simulating sparse H amiltonians. Communications in Mathematical Physics , 270(2):359--371, 2007

    work page 2007

  5. [5]

    Black-box H amiltonian simulation and unitary implementation

    Dominic W Berry and Andrew M Childs. Black-box H amiltonian simulation and unitary implementation. Quantum Information & Computation , 12(1-2):29--62, 2012

    work page 2012

  6. [6]

    Berry, Andrew M

    Dominic W. Berry, Andrew M. Childs, Richard Cleve, Robin Kothari, and Rolando D. Somma. Simulating hamiltonian dynamics with a truncated taylor series. Physical Review Letters , 114(9), March 2015

    work page 2015

  7. [7]

    Exponential improvement in precision for simulating sparse H amiltonians

    Dominic W Berry, Andrew M Childs, Richard Cleve, Robin Kothari, and Rolando D Somma. Exponential improvement in precision for simulating sparse H amiltonians. Forum of Mathematics, Sigma , 5, 2017

    work page 2017

  8. [8]

    Efficient and practical hamiltonian simulation from time-dependent product formulas

    Jan Lukas Bosse, Andrew M Childs, Charles Derby, Filippo Maria Gambetta, Ashley Montanaro, and Raul A Santos. Efficient and practical hamiltonian simulation from time-dependent product formulas. arXiv preprint arXiv:2403.08729 , 2024

    arXiv 2024

Show all 43 references
  1. [9]

    Hamiltonian simulation with nearly optimal dependence on all parameters

    Dominic W Berry, Andrew M Childs, and Robin Kothari. Hamiltonian simulation with nearly optimal dependence on all parameters. In Proceedings of the 56th Annual Symposium on Foundations of Computer Science (FOCS 2015) , pages 792--809. IEEE, 2015

    2015

  2. [10]

    Time-dependent hamiltonian simulation with L^1 -norm scaling

    Dominic W Berry, Andrew M Childs, Yuan Su, Xin Wang, and Nathan Wiebe. Time-dependent hamiltonian simulation with L^1 -norm scaling. Quantum , 4:254, 2020

    2020

  3. [11]

    Logical quantum processor based on reconfigurable atom arrays

    Dolev Bluvstein, Simon J Evered, Alexandra A Geim, Sophie H Li, Hengyun Zhou, Tom Manovitz, Sepehr Ebadi, Madelyn Cain, Marcin Kalinowski, Dominik Hangleiter, et al. Logical quantum processor based on reconfigurable atom arrays. Nature , 626(7997):58--65, 2024

    2024

  4. [12]

    Brass, J.-W

    H. Brass, J.-W. Fischer, and K. Petras. The gaussian quadrature method. Abhandlungen der Braunschweigischen Wissenschaftlichen Gesellschaft , 47:115--150, 1996

    1996

  5. [13]

    Corrected quantum walk for optimal H amiltonian simulation

    Dominic W Berry and Leonardo Novo. Corrected quantum walk for optimal H amiltonian simulation. Quantum Information & Computation , 16(15-16):1295--1317, 2016

    2016

  6. [14]

    Random compiler for fast hamiltonian simulation

    Earl Campbell. Random compiler for fast hamiltonian simulation. Physical Review Letters , 123(7):070503, 2019

    2019

  7. [15]

    On the relationship between continuous-and discrete-time quantum walk

    Andrew M Childs. On the relationship between continuous-and discrete-time quantum walk. Communications in Mathematical Physics , 294(2):581--603, 2010

    2010

  8. [16]

    Structure-preserving numerical schemes for lindblad equations

    Yu Cao and Jianfeng Lu. Structure-preserving numerical schemes for lindblad equations. Journal of Scientific Computing , 102(1):1--34, 2025

    2025

  9. [17]

    Toward the first quantum simulation with quantum speedup

    Andrew M Childs, Dmitri Maslov, Yunseong Nam, Neil J Ross, and Yuan Su. Toward the first quantum simulation with quantum speedup. Proceedings of the National Academy of Sciences , 115(38):9456--9461, 2018

    2018

  10. [18]

    Hamiltonian simulation using linear combinations of unitary operations

    Andrew M Childs and Nathan Wiebe. Hamiltonian simulation using linear combinations of unitary operations. Quantum Information & Computation , 12(11-12):901--924, 2012

    2012

  11. [19]

    Simulating physics with computers

    Richard P Feynman. Simulating physics with computers. International journal of theoretical physics , 21(6-7):467--488, 1982

    1982

  12. [20]

    Richard P. Feynman. Quantum mechanical computers. Optics News , 11(2):11--20, Feb 1985

    1985

  13. [21]

    Creating superpositions that correspond to efficiently integrable probability distributions

    Lov Grover and Terry Rudolph. Creating superpositions that correspond to efficiently integrable probability distributions. arXiv preprint quant-ph/0208112 , 2002

    2002 arXiv

  14. [22]

    Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics

    Andr \'a s Gily \'e n, Yuan Su, Guang Hao Low, and Nathan Wiebe. Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing (STOC 2019) , pages 193--204, 2019

    2019

  15. [23]

    Quantum algorithm for linear systems of equations

    Aram W Harrow, Avinatan Hassidim, and Seth Lloyd. Quantum algorithm for linear systems of equations. Physical Review Letters , 103(15):150502, 2009

    2009

  16. [24]

    Efficient Optimal Control of Open Quantum Systems

    Wenhao He, Tongyang Li, Xiantao Li, Zecheng Li, Chunhao Wang, and Ke Wang. Efficient Optimal Control of Open Quantum Systems . In 19th Conference on the Theory of Quantum Computation, Communication and Cryptography (TQC 2024) , volume 310 of Leibniz International Proceedings i...

    2024

  17. [25]

    Integer multiplication in time o(nlog ,n)

    David Harvey and Joris Van Der Hoeven. Integer multiplication in time o(nlog ,n). Annals of Mathematics , 193(2):563--617, 2021

    2021

  18. [26]

    Quantum measurements and the abelian stabilizer problem

    A Yu Kitaev. Quantum measurements and the abelian stabilizer problem. arXiv preprint quant-ph/9511026 , 1995

    1995 arXiv

  19. [27]

    Simulating the dynamics of time-dependent hamiltonians with a truncated dyson series

    M \'a ria Kieferov \'a , Artur Scherer, and Dominic W Berry. Simulating the dynamics of time-dependent hamiltonians with a truncated dyson series. Physical Review A , 99(4):042314, 2019

    2019

  20. [28]

    Classical and quantum computation

    Alexei Yu Kitaev, Alexander Shen, and Mikhail N Vyalyi. Classical and quantum computation . Number 47. American Mathematical Soc., 2002

    2002

  21. [29]

    Optimal H amiltonian simulation by quantum signal processing

    Guang Hao Low and Isaac L Chuang. Optimal H amiltonian simulation by quantum signal processing. Physical Review Letters , 118(1):010501, 2017

    2017

  22. [30]

    Hamiltonian simulation by qubitization

    Guang Hao Low and Isaac L Chuang. Hamiltonian simulation by qubitization. Quantum , 3:163, 2019

    2019

  23. [31]

    Universal quantum simulators

    Seth Lloyd. Universal quantum simulators. Science , pages 1073--1078, 1996

    1996

  24. [32]

    Hamiltonian simulation in the interaction picture, 2019

    Guang Hao Low and Nathan Wiebe. Hamiltonian simulation in the interaction picture, 2019

    2019

  25. [33]

    Simulating M arkovian open quantum systems using higher-order series expansion

    Xiantao Li and Chunhao Wang. Simulating M arkovian open quantum systems using higher-order series expansion. In 50th International Colloquium on Automata, Languages, and Programming (ICALP 2023) . Schloss-Dagstuhl-Leibniz Zentrum f \"u r Informatik, 2023

    2023

  26. [34]

    Succinct description and efficient simulation of non- M arkovian open quantum systems

    Xiantao Li and Chunhao Wang. Succinct description and efficient simulation of non- M arkovian open quantum systems. Communications in Mathematical Physics , 401(1):147--183, 2023

    2023

  27. [35]

    Optimal H amiltonian simulation for time-periodic systems

    Kaoru Mizuta and Keisuke Fujii. Optimal H amiltonian simulation for time-periodic systems. Quantum , 7:962, 2023

    2023

  28. [36]

    Explicit error bounds with commutator scaling for time-dependent product and multi-product formulas

    Kaoru Mizuta, Tatsuhiko N Ikeda, and Keisuke Fujii. Explicit error bounds with commutator scaling for time-dependent product and multi-product formulas. arXiv preprint arXiv:2410.14243 , 2024

    2024

  29. [37]

    Demonstration of logical qubits and repeated error correction with better-than-physical error rates

    A Paetznick, MP da Silva, C Ryan-Anderson, JM Bello-Rivas, JP Campora III, A Chernoguzov, JM Dreiling, C Foltz, F Frachon, JP Gaebler, et al. Demonstration of logical qubits and repeated error correction with better-than-physical error rates. arXiv preprint arXiv:2404.02280 , 2024

    2024 arXiv

  30. [38]

    A variational eigenvalue solver on a photonic quantum processor

    Alberto Peruzzo, Jarrod McClean, Peter Shadbolt, Man-Hong Yung, Xiao-Qi Zhou, Peter J Love, Al \'a n Aspuru-Guzik, and Jeremy L O’brien. A variational eigenvalue solver on a photonic quantum processor. Nature communications , 5(1):4213, 2014

    2014

  31. [39]

    Synthesis of quantum-logic circuits

    VV Shende, SS Bullock, and IL Markov. Synthesis of quantum-logic circuits. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems , 25(6):1000--1010, 2006

    2006

  32. [40]

    Real-time quantum error correction beyond break-even

    Volodymyr V Sivak, Alec Eickbusch, Baptiste Royer, Shraddha Singh, Ioannis Tsioutsios, Suhas Ganjam, Alessandro Miano, BL Brock, AZ Ding, Luigi Frunzio, et al. Real-time quantum error correction beyond break-even. Nature , 616(7955):50--55, 2023

    2023

  33. [41]

    Orthogonal Polynomials

    Gábor Szegő. Orthogonal Polynomials . American Mathematical Society, Providence, RI, 1975

    1975

  34. [42]

    Simulating quantum dynamics on a quantum computer

    Nathan Wiebe, Dominic W Berry, Peter H yer, and Barry C Sanders. Simulating quantum dynamics on a quantum computer. Journal of Physics A: Mathematical and Theoretical , 44(44):445308, 2011

    2011

  35. [43]

    Time-dependent hamiltonian simulation using discrete-clock constructions

    Jacob Watkins, Nathan Wiebe, Alessandro Roggero, and Dean Lee. Time-dependent hamiltonian simulation using discrete-clock constructions. PRX Quantum , 5:040316, Oct 2024

    2024

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.