Pith. sign in

REVIEW 3 major objections 5 minor 44 references

High-Performance Contraction of Quantum Circuits for Riemannian Optimization

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

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

Pith's one-line read Second-order Riemannian circuit optimization can be run matrix-free, evaluating objective, gradient, and Hessian through cached state-vector contractions.

desk verdict Solid HPC implementation paper with a genuine cached-Hessian contribution, but the unspecified matrix-free action of U and the mislabeled benchmark model need fixing before the claims hold. read the letter →

arxiv 2506.23775 v1 pith:DU7YAFIL submitted 2025-06-30 quant-ph physics.comp-ph

Fabian Putterer , Max M. Zumpe , Isabel Nha Minh Le , Qunsheng Huang , Christian B. Mendl This is my paper
classification quant-phphysics.comp-ph PACS 03.67.Ac
keywords Riemannianoptimizationquantumcircuitmatrix-freeevaluationstatevectorsimulationHamiltonianFermi-Hubbardmodelparityconservationparallelcomputing
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

Second-order Riemannian optimization of quantum circuit gates is usually blocked by memory: storing the target unitary time-evolution operator for $k$ qubits costs $O(2^{2k})$ entries. This paper removes that wall by evaluating the objective, gradient, and Hessian as sums over computational basis states, assuming only state vectors of length $2^k$ fit in memory. A forward pass caches intermediate states and a backward pass reuses them, so the gradient requires $O(n)$ gate applications instead of $O(n^2)$; a second family of forward passes through 'gate holes' assembles the full Hessian. On the Fermi-Hubbard model with up to 16 sites, the resulting trust-region implementation reaches near-linear parallel speed-up to 112 threads, gains an order of magnitude from parity-conserving gates and translation invariance, and converges in about 200 steps where a first-order Riemannian ADAM took 2000. The comparison with an MPO-based optimizer indicates a crossover: state-vector contraction is faster for small systems, while tensor-network representations scale better for large ones.

What carries the argument

The load-bearing mechanism is the 'gate hole': a tensor-network diagram with a single gate $G_\ell$ removed, so the open tensor legs of the hole give the derivative with respect to the entries of that gate. The optimizer evaluates each summand in the trace objective by contracting such networks; a forward pass caches the intermediate state vectors $|\psi_1\rangle, |\psi_2\rangle, \dots$, and a backward pass with the adjoint target state produces $\langle\phi_1|, \langle\phi_2|, \dots$, so sandwiching a hole between the cached pair costs one contraction per gate. For the Hessian, a second forward pass starts at each hole with an $m^2$-dimensional state vector array, with entries interleaved in memory for vectorization, and propagates it through the circuit, generating every later second-derivative block in the same pass. Two structural reductions close the argument: parity-conserving gates halve the number of temporary arrays, and translational invariance identifies equivalent hole pairs so only one member of each class is computed.

What would settle it

Look at the released code for the routine that evaluates $U|j\rangle$ and measure peak memory at 16 qubits: if applying $U$ requires a dense $2^k \times 2^k$ matrix, or if the measured memory scales as $2^{2k}$ entries rather than $2^k$, the matrix-free claim collapses; if $U$ is applied by a Trotter circuit of depth $D$, the optimized object is that approximate evolution and every cost estimate gains a factor $D$.

Watch

Extended reading notes

Core claim

The paper's central technical claim is that a matrix-free algorithmic framework—evaluating every quantity as a sum over state vectors—makes Riemannian trust-region optimization with exact Hessians practical for circuits of up to about 16 qubits. In the authors' words, the gradient computation requires $O(n)$ gate applications to a state vector instead of $O(n^2)$ for the naive approach, and computing the whole Hessian matrix is computationally advantageous over Hessian-vector products inside this optimization setting. The method achieves this by caching intermediate states from a forward simulation pass, running a backward pass with the adjoint target state, and using 'gate holes'—tensor diagrams with a gate omitted—to read off derivatives when a hole is sandwiched between the two cached vectors. The Hessian is assembled by propagating, for each gate, an interleaved state vector array whose extra index labels the entries of the missing gate, and parity conservation plus translational invariance cut the work substantially. Benchmarks on the spinless and spinful Fermi-Hubbard models reach 16 sites, show nearly linear parallel scaling up to 112 threads, and demonstrate that the exact-Hessian trust-region method reduces the approximation error by two orders of magnitude in roughly 200 steps where a first-order Riemannian ADAM optimizer took 2000 steps and found a worse optimum.

Load-bearing premise

The entire complexity and memory argument assumes that the target unitary $U$ can be applied to an arbitrary state vector $|j\rangle$ without ever forming the full $2^k \times 2^k$ matrix, but the paper never specifies the routine that implements this matrix-free action for the Fermi-Hubbard targets.

Editorial extensions

If this is right

  • A 16-qubit, 64-gate circuit needs about 128 MiB of cached state vectors, versus 64 GiB per layer for a dense matrix, so exact Hessian optimization fits on a single server node.
  • Gradient cost is $O(n 4^k)$ and the full Hessian is $O(n^2 4^k)$, so the exponential qubit dependence, not the circuit depth, sets the practical boundary.
  • Parity-conserving gates reach the same final approximation error as unrestricted gates for parity-conserving Hamiltonians while reducing optimization runtime by roughly an order of magnitude.
  • Exploiting translational invariance removes redundant gate-hole pairs and keeps most of the speedup even when caches saturate.
  • For small systems the state-vector approach beats the MPO baseline on gradient time; the comparison implies a crossover point beyond which the MPO approach wins.

Reading between the lines

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

  • The paper leaves the exact cost of one matrix-free application of $U$ unspecified; a natural test is to benchmark the same optimizer with $U|j\rangle$ realized by a depth-$D$ Trotter circuit, which would show whether the claimed savings survive for a concretely implementable target.
  • The same gate-hole kernels apply whenever the objective is linear in each gate, so they should transfer directly to other compilation tasks—preparing a target state, implementing phase-estimation building blocks—not only Hamiltonian time evolution.
  • The planned random sampling of the trace in Eq. (6) points toward a hybrid: replace the exact basis-state sum with a stochastic estimator inside an MPS representation and use Hessian-vector products, which could combine the convergence of second-order methods with tensor-network scaling.
Share X Bluesky LinkedIn Reddit HN

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 presents a matrix-free implementation of Riemannian trust-region optimization for compiling quantum circuits that approximate Hamiltonian time evolution. The objective function, gradient, and Hessian are evaluated by summing over computational basis states, applying the circuit gates to state vectors rather than storing the full unitary matrices. The authors describe caching/backpropagation for gradient computation, second forward passes for the full Hessian, optimized kernels for gate application and gate-hole contraction, and symmetry reductions from parity conservation and translational invariance. Benchmarks on one-dimensional spinless and spinful Hubbard-type models up to 16 sites report near-linear parallel speedups and are compared with a matrix-product-operator-based Riemannian ADAM implementation.

Significance. If the central algorithmic claims are correct, the paper is a useful engineering contribution: it provides reproducible HPC kernels for second-order Riemannian circuit optimization with exact Hessians, and it demonstrates order-of-magnitude speedups from exploiting parity and translation symmetries. The caching/backpropagation scheme and the Hessian contraction rules are internally consistent and follow standard tensor-network/automatic-differentiation practice. The availability of source-code links and the detailed pseudocode are strengths. However, the significance is substantially qualified by two load-bearing gaps: the concrete mechanism for applying the target unitary U to a state vector is never specified, and the main benchmark model is not the Fermi-Hubbard model claimed in the abstract but a hard-core boson variant with periodic boundary strings omitted. These issues affect the meaning of the matrix-free memory claims and the interpretation of the reported benchmark errors.

major comments (3)
  1. [§II.B, Eq. (6); §V.B] The central matrix-free claim is not supported as written because the paper never specifies how the target unitary U is applied to a basis state |j⟩. Equation (6) requires U|j⟩ for each of the 2^k summands, and the memory and time complexity statements in §V.B count only the C(G) gate applications. For the 16-site benchmarks, U = exp(-i t \tilde H) with \tilde H from Eq. (28): a dense representation of U would require about 64 GiB, contradicting the memory premise, while a Trotterized U would replace the exact evolution operator by an approximate circuit and change the meaning of the reported errors. Please specify the concrete routine for U|j⟩ (e.g., Krylov or time-stepping action of exp(-iHt), sparse exponential, or explicit Trotter product), include its cost in the complexity model, and state which target is actually used in the benchmarks.
  2. [§VI.A, Eqs. (25), (28)] The benchmark model is not the spinless Fermi-Hubbard model claimed in the abstract and introduction. By omitting the Z-strings in the periodic wrap-around term, Eq. (28) defines a hard-core boson Hamiltonian, which differs from the fermionic model in Eq. (25) in the boundary hopping term and in the exchange statistics around the ring. The paper acknowledges the modification, but the title-level and abstract-level claim of benchmarking the Fermi-Hubbard model is therefore overstated, and the reported fidelities and errors refer to a different target. Either implement the fermionic periodic Hamiltonian, including the string terms, or consistently describe the numerical study as a hard-core boson model and qualify the Fermi-Hubbard framing.
  3. [§IV.B; Appendix A] The paper asserts that computing the entire Hessian matrix is computationally advantageous over Hessian-vector products in this setting, but no quantitative comparison is provided. The argument in §IV.B is plausible for a trust-region solver with many inner iterations, yet the claim is load-bearing for the choice of second-order method. Please add at least a small runtime comparison between the full-Hessian approach and the Hessian-vector-product approach described in Appendix A, or soften the assertion to a qualitative statement.
minor comments (5)
  1. [§II.A] The symbol U(m) for the unitary group clashes with the target unitary U in the same section; a different notation, such as 𝕌(m), would improve readability.
  2. [§II.B, Eq. (6)] The summation expression '2k−1X' appears to be a typesetting artifact; please ensure the sum is formatted as \sum_{j=0}^{2^k-1}.
  3. [§VI.C, Fig. 12 caption] In the caption of Fig. 12(c), '14 core reference point' should read '14-thread reference point' to match the axis label.
  4. [§VI.E, Fig. 17] The convergence comparison in Fig. 17 uses different initializations and different iteration counts for the two methods; the paper should state more explicitly that this is a qualitative comparison and that the initial error levels differ.
  5. [§V.A] The memory estimate of 64 GiB for a dense 16-qubit layer is helpful, but the notation '8 B · 2 · (216)2' is hard to read; consider writing 16 bytes × 2^{32} entries.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the derivation chain is self-contained; the main assumptions are stated premises, not conclusions imported from themselves.

full rationale

The paper's central derivation chain is internally self-contained. Eq. (6) follows from the trace identity in Eq. (4) and the resolution of the identity in the computational basis; it is not a fitted quantity. The gradient and Hessian formulas are derived from standard complex-matrix calculus, Riemannian projection, and explicit tensor-network diagrams; the caching/backpropagation scheme is presented with pseudocode and complexity counts that follow from the stated loop structure. The Riemannian trust-region machinery is standard and is cited to external references, not to the authors' own prior work as the sole justification. Self-citations to Refs. [17,18] provide background and an alternative MPO comparison, but they are not used to import a uniqueness theorem or to forbid alternatives, and the performance claims are measured benchmarks rather than predictions from fitted constants. The parity-conserving gate structure and the hard-core-boson replacement of the periodic Jordan-Wigner term are explicitly stated model choices, not hidden consequences of the target function. The one unstated element is the practical implementation of the 'matrix-free action of U' in Section II.B and its cost; this is a completeness gap in the complexity model, not a circular step, because the complexity claims would fail (if U is dense) or change meaning (if U is Trotterized) without affecting the internal consistency of the derivation. No equation is shown to reduce to another equation by construction, and no fitted parameter is renamed as a prediction. Therefore no significant circularity is present.

Assumptions & free parameters 0 free parameters · 7 assumptions · 0 invented entities

The central claim rests on standard Riemannian optimization and tensor-network identities, plus one unverified domain assumption (matrix-free U) and one ad hoc model substitution (hard-core boson instead of fermionic Hubbard). The free-parameter count is zero.

assumptions (7)
  • standard math The computational basis states form a complete basis, so the trace in Eq. (6) can be evaluated as a sum over basis states.
    Invoked in Section II.B, Eq. (6). This is a standard identity in linear algebra.
  • domain assumption The target unitary U can be applied to any state vector via an unspecified matrix-free procedure without material cost or approximation.
    Stated in Section II.B; no mechanism or complexity is given. This is the load-bearing unstated premise for avoiding dense storage.
  • standard math The Riemannian geometry and optimization machinery from Absil et al. and Hauru et al. applies, including the projection formula and polar retraction.
    Used in Section III, Eqs. (9), (12), (15). Textbook results for the unitary manifold.
  • domain assumption The derivative of the target function with respect to a gate entry equals the tensor network diagram with that gate omitted (gate hole).
    Taken from Ref. [17], used in Section IV.A. This is a known identity for holomorphic functions of a circuit, but it is imported from prior work.
  • domain assumption The two-qubit gates in the circuit obey the parity-conserving block structure of Eq. (23), and the target Hamiltonian conserves parity.
    Introduced in Section IV.E; valid for the specific Hubbard-like models but restricts the gate ansatz.
  • domain assumption The system is translationally invariant, so equivalent gate-hole pairs under translation contribute identically to the Hessian.
    Used in Section IV.F; requires the brick-wall topology and a translationally invariant target.
  • ad hoc to paper The periodic-boundary Fermi-Hubbard Hamiltonian can be replaced by its hard-core boson version by omitting Z-strings in the Jordan-Wigner transformation.
    Introduced in Section VI.A to preserve translational invariance. This is a model substitution, not an identity, and it changes the physics for the original fermionic system.

how reviews work

0 comments
Cite this review

Pith. "Pith review of High-Performance Contraction of Quantum Circuits for Riemannian Optimization." pith.science (2026). https://pith.science/paper/DU7YAFIL

@misc{pith2026250623775,
  author       = {Pith},
  title        = {Pith review of: High-Performance Contraction of Quantum Circuits for Riemannian Optimization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/DU7YAFIL}},
  note         = {Machine review of arXiv:2506.23775}
}
read the original abstract

This work focuses on optimizing the gates of a quantum circuit with a given topology to approximate the unitary time evolution governed by a Hamiltonian. Recognizing that unitary matrices form a mathematical manifold, we employ Riemannian optimization methods -- specifically the Riemannian trust-region algorithm -- which involves second derivative calculations with respect to the gates. Our key technical contribution is a matrix-free algorithmic framework that avoids the explicit construction and storage of large unitary matrices acting on the whole Hilbert space. Instead, we evaluate all quantities as sums over state vectors, assuming that these vectors can be stored in memory. We develop HPC-optimized kernels for applying gates to state vectors and for the gradient and Hessian computation. Further improvements are achieved by exploiting sparsity structures due to Hamiltonian conservation laws, such as parity conservation, and lattice translation invariance. We benchmark our implementation on the Fermi-Hubbard model with up to 16 sites, demonstrating a nearly linear parallelization speed-up with up to 112 CPU threads. Finally, we compare our implementation with an alternative matrix product operator-based approach.

Figures

Figures reproduced from arXiv: 2506.23775 by the authors.

Figure 1
Figure 1. FIG. 1: Example of a generic quantum circuit consisting [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. FIG. 2: Tensor network representation of a target [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. FIG. 3: Tensor network representation of the derivative [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (11 more)
Figure 6
Figure 6. Figure 6: FIG. 6: Backward pass and gate gradient computation [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]
Figure 8
Figure 8. Figure 8: FIG. 8: Second forward pass for computing blocks of [PITH_FULL_IMAGE:figures/full_fig_p005_8.png]
Figure 9
Figure 9. Figure 9: FIG. 9: Applying a two-qubit gate to a state vector. (a) [PITH_FULL_IMAGE:figures/full_fig_p006_9.png]
Figure 10
Figure 10. Figure 10: FIG. 10: Tensor network to obtain the gradient w.r.t. [PITH_FULL_IMAGE:figures/full_fig_p007_10.png]
Figure 11
Figure 11. Figure 11: FIG. 11: Transforming a brick wall layout to a [PITH_FULL_IMAGE:figures/full_fig_p008_11.png]
Figure 13
Figure 13. Figure 13: FIG. 13: Speed-up of the optimization procedure due to [PITH_FULL_IMAGE:figures/full_fig_p011_13.png]
Figure 14
Figure 14. Figure 14: FIG. 14: Speed-up of the optimization procedure due to [PITH_FULL_IMAGE:figures/full_fig_p011_14.png]
Figure 12
Figure 12. Figure 12: FIG. 12: Multithreading benchmarks run on the LRZ [PITH_FULL_IMAGE:figures/full_fig_p011_12.png]
Figure 16
Figure 16. Figure 16: FIG. 16: Evaluation time for one summand of the [PITH_FULL_IMAGE:figures/full_fig_p012_16.png]
Figure 17
Figure 17. Figure 17: FIG. 17: Comparison of the convergence behavior of the [PITH_FULL_IMAGE:figures/full_fig_p013_17.png]
Figure 18
Figure 18. Figure 18: FIG. 18: Computational graph for evaluating the [PITH_FULL_IMAGE:figures/full_fig_p014_18.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

44 extracted references · 31 canonical work pages

  1. [1]

    Gate application A gate application can be interpreted as a tensor network contraction, as visualized in Fig. 9. We treat the special case where the gate acts on two neighboring qubits separately, since the indexing is simpler in this case. The qubit wires not affected by the gate have been merged into single tensor legs as far as possible. Note that some...

    work page

  2. [2]

    6 and Fig

    Gate gradient as a gate hole As described above, the gradient or Hessian computation entails contracting a tensor network with a gate hole (see bottom parts of Fig. 6 and Fig. 8). This step is summarized in Fig. 10, where dimensions are grouped analogously to the gate application. i4 i3 i2 i1 i0 j1 j3 ∂G = |ψ⟩|ϕ⟩ FIG. 10: Tensor network to obtain the grad...

    work page

  3. [3]

    sequentialization

    Gate hole application Finally, we discuss the gate hole application to a state vector as visualized in Fig. 7. We interleave the individual state vector entries in the resulting array in our implementation. In other words, a state vector array (|ψ1⟩ , |ψ2⟩ , . . .) adheres to the linear memory layout (ψ1[0], ψ2[0], . . . , ψ1[1], ψ2[1], . . .). Assuming t...

    work page

  4. [4]

    100 random quantum gate initializations are generated for each data point, and the median evaluation time is presented

    Scaling of gradient evaluation time In the following, we analyze the evaluation time of gradient computations for various numbers of qubits, nqubits, and layers, nlayers. 100 random quantum gate initializations are generated for each data point, and the median evaluation time is presented. The results for the MPO method are shown in Fig. 15. The timings f...

    work page

  5. [5]

    embarrassingly parallel

    Convergence comparison Since the trust-region algorithm is a second-order optimization routine, it is expected to converge faster than the first-order Riemannian ADAM algorithm. Additionally, utilizing the Hessian reduces the risk of encountering local minima. To verify this, we compare the convergence behavior of both methods for the spinful Fermi-Hubbar...

    work page

  6. [6]

    Lloyd, Universal quantum simulators, Science 273, 1073 (1996)

    S. Lloyd, Universal quantum simulators, Science 273, 1073 (1996)

    1996

  7. [7]

    Zalka, Simulating quantum systems on a quantum computer, Proc

    C. Zalka, Simulating quantum systems on a quantum computer, Proc. R. Soc. Lond. A 454, 313 (1998)

    work page 1998

  8. [8]

    M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information (Cambridge University Press, 2010)

    2010

Show all 44 references
  1. [9]

    A. W. Harrow, A. Hassidim, and S. Lloyd, Quantum algorithm for linear systems of equations, Phys. Rev. Lett. 103, 150502 (2009)

    2009

  2. [10]

    Y. Dong, L. Lin, and Y. Tong, Ground-state preparation and energy estimation on early fault-tolerant quantum computers via quantum eigenvalue transformation of unitary matrices, PRX Quantum 3, 040305 (2022)

    2022

  3. [11]

    A. M. Childs, Y. Su, M. C. Tran, N. Wiebe, and S. Zhu, Theory of Trotter error with commutator scaling, Phys. Rev. X 11, 011020 (2021)

    2021

  4. [12]

    G. H. Low and I. L. Chuang, Optimal Hamiltonian simulation by quantum signal processing, Phys. Rev. Lett. 118, 010501 (2017)

    2017

  5. [13]

    G. H. Low and I. L. Chuang, Hamiltonian simulation by qubitization, Quantum 3, 163 (2019)

    2019

  6. [14]

    J. M. Martyn, Z. M. Rossi, A. K. Tan, and I. L. Chuang, Grand unification of quantum algorithms, PRX Quantum 2, 040203 (2021)

    2021

  7. [15]

    Motlagh and N

    D. Motlagh and N. Wiebe, Generalized quantum signal processing, PRX Quantum 5, 020368 (2024)

    2024

  8. [16]

    Y. Ge, W. Wenjie, C. Yuheng, P. Kaisen, L. Xudong, Z. Zixiang, W. Yuhan, W. Ruocheng, and Y. Junchi, Quantum circuit synthesis and compilation optimization: Overview and prospects, arXiv:2407.00736 (2024)

    2024

  9. [17]

    Mansuroglu, T

    R. Mansuroglu, T. Eckstein, L. N¨ utzel, S. A. Wilkinson, and M. J. Hartmann, Variational Hamiltonian simulation for translational invariant systems via classical pre- processing, Quantum Sci. Technol. 8, 025006 (2023)

    2023

  10. [18]

    Mansuroglu, F

    R. Mansuroglu, F. Fischer, and M. J. Hartmann, Problem-specific classical optimization of Hamiltonian simulation, Phys. Rev. Res. 5, 043035 (2023)

    2023

  11. [19]

    M. S. J. Tepaske, D. Hahn, and D. J. Luitz, Optimal compression of quantum many-body time evolution operators into brickwall circuits, SciPost Phys. 14, 073 (2023), 2205.03445

    2023 arXiv

  12. [20]

    Mc Keever and M

    C. Mc Keever and M. Lubasch, Classically optimized Hamiltonian simulation, Phys. Rev. Research 5, 023146 (2023)

    2023

  13. [21]

    Mc Keever and M

    C. Mc Keever and M. Lubasch, Towards adiabatic quantum computing using compressed quantum circuits, PRX Quantum 5, 020362 (2024)

    2024

  14. [22]

    Kotil, R

    A. Kotil, R. Banerjee, Q. Huang, and C. B. Mendl, Riemannian quantum circuit optimization for Hamiltonian simulation, J. Phys. A: Math. Theor. 57, 135303 (2024)

    2024

  15. [23]

    I. N. M. Le, S. Sun, and C. B. Mendl, Riemannian quantum circuit optimization based on matrix product operators, arXiv preprint arXiv:2501.08872 (2025), 2501.08872

    2025

  16. [24]

    Causer, F

    L. Causer, F. Jung, A. Mitra, F. Pollmann, and A. Gammon-Smith, Scalable simulation of nonequilibrium quantum dynamics via classically optimized unitary circuits, Phys. Rev. Research 6, 033062 (2024)

    2024

  17. [25]

    Gibbs and L

    J. Gibbs and L. Cincio, Deep circuit compression for quantum dynamics via tensor networks, arXiv preprint arXiv:2409.16361 (2024), 2409.16361

    2024 arXiv

  18. [26]

    Anselme Martin, T

    B. Anselme Martin, T. Ayral, F. Jamet, M. J. Ranˇ ci´ c, and P. Simon, Combining matrix product states and noisy quantum computers for quantum simulation, Phys. Rev. A 109, 062437 (2024)

    2024

  19. [27]

    Rogerson and A

    D. Rogerson and A. Roy, Quantum circuit optimization using differentiable programming of tensor network states, arXiv preprint arXiv:2408.12583 (2024), 2408.12583

    2024 arXiv

  20. [28]

    Guo and S

    Y. Guo and S. Yang, Efficient quantum circuit compilation for near-term quantum advantage, arXiv preprint arXiv:2501.07387 (2025), 2501.07387

    2025 arXiv

  21. [29]

    I. A. Luchnikov, M. E. Krechetov, and S. N. Filippov, Riemannian geometry and automatic differentiation for optimization problems of quantum physics and quantum technologies, New J. Phys. 23, 073006 (2021)

    2021

  22. [30]

    Hauru, M

    M. Hauru, M. Van Damme, and J. Haegeman, Riemannian optimization of isometric tensor networks, SciPost Phys. 10, 040 (2021)

    2021

  23. [31]

    Wiersema and N

    R. Wiersema and N. Killoran, Optimizing quantum circuits with Riemannian gradient flow, Phys. Rev. A 107, 062421 (2023)

    2023

  24. [32]

    Godinez-Ramirez, R

    E. Godinez-Ramirez, R. Milbradt, and C. B. Mendl, A Riemannian approach to the Lindbladian dynamics of a locally purified tensor network, arXiv preprint arXiv:2409.08127 (2024), 2409.08127

    2024 arXiv

  25. [33]

    Edelman, T

    A. Edelman, T. A. Arias, and S. T. Smith, The geometry of algorithms with orthogonality constraints, SIAM J. Matrix Anal. Appl. 20, 303 (1998)

    1998

  26. [34]

    Absil, R

    P.-A. Absil, R. Mahony, and R. Sepulchre, Optimization Algorithms on Matrix Manifolds (Princeton University Press, 2008)

    2008

  27. [35]

    Steihaug, The conjugate gradient method and trust regions in large scale optimization, SIAM J

    T. Steihaug, The conjugate gradient method and trust regions in large scale optimization, SIAM J. Numer. Anal. 20, 626 (1983)

    1983

  28. [36]

    https://github.com/MaxSanZumpe/rqcopt_ hpc-matchgate (2025)

    2025

  29. [37]

    D. P. Kingma and J. Ba, Adam: A method for stochastic optimization, arXiv preprint arXiv:1412.6980 (2014), 1412.6980

    2014 arXiv

  30. [38]

    https://github.com/cmendl/rqcopt_hpc (2024)

    2024

  31. [39]

    https://github.com/putterer/ quantum-brickwall-contraction (2023)

    2023

  32. [40]

    https://github.com/qc-tum/rqcopt (2023)

    2023

  33. [41]

    https://github.com/INMLe/rqcopt-mpo (2025)

    2025

  34. [42]

    Bishop, Exact calculation of the Hessian matrix for the multilayer perceptron, Neural Comput

    C. Bishop, Exact calculation of the Hessian matrix for the multilayer perceptron, Neural Comput. 4, 494 (1992)

    1992

  35. [43]

    Christianson, Automatic Hessians by reverse accumulation, IMA J

    B. Christianson, Automatic Hessians by reverse accumulation, IMA J. Numer. Anal. 12, 135 (1992)

    1992

  36. [44]

    Griewank and A

    A. Griewank and A. Walther, Evaluating Derivatives: Principles and Techniques of Algorithmic Differentiation, 2nd ed. (Society for Industrial and Applied Mathematics, 2008)

    2008

Pith tools

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