{"id":"81773ac0-a58d-4fd2-8d7b-2ca5efa2ca90","arxiv_id":"2506.23775","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"A matrix-free, cached Hessian framework enables memory-efficient Riemannian trust-region optimization of quantum circuit gates, with near-linear parallel speedup up to 112 threads.","lead":"This paper details a memory-efficient, HPC-parallelized implementation of Riemannian trust-region optimization for tuning gates in quantum circuits to approximate Hamiltonian time evolution. It reports nearly linear speedups up to 112 CPU threads and faster convergence than a first-order MPO-based alternative.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The paper never specifies how U|j> is computed in Eq. (6); Section V.B omits U's action cost from the complexity model, so the matrix-free memory and benchmark claims rest on an unstated and possibly dense or Trotterized target.","rationale":"I read the paper as making a concrete algorithmic claim: Riemannian trust-region circuit optimization can be run in a matrix-free way, evaluating Eq. (6) as sums over state vectors, with only state vectors and small gate matrices stored. For that claim to hold, one must be able to apply the target unitary U to every computational basis state without forming U. The paper never gives this routine, and Section V.B's complexity expressions implicitly assume that U|j> is cheap or else is not part of the measured cost. This is the most load-bearing weakness because it sits directly under the stated memory savings and the 16-site benchmark interpretation. The concern is checkable through the linked code, so it does not warrant rejection; it warrants the reader's conditional verdict. Secondary issues, such as the abstract calling the hard-core boson benchmark 'Fermi-Hubbard' even though Section VI.A explicitly replaces the periodic fermionic term with a hard-core boson term, are real but do not invalidate the algorithmic core. I also credit the paper for detailed kernel pseudocode, honest discussion of cache limitations, and public code, which make the missing U specification a documentation/verification gap rather than an unsupported framework.","tokens_in":17780,"tokens_out":14430,"duration_ms":173159,"concrete_test":"Inspect the repository at github.com/MaxSanZumpe/rqcopt_hpc-matchgate and locate the routine computing U|j> for the Figure 12 and Figure 13 benchmarks. Verify that (a) no dense 2^k x 2^k matrix is allocated at nqubits=16, and (b) U|j> is obtained by a sparse/Krylov action e^{-iHt}|j> for the exact Hamiltonian in Eq. (28), not by a fixed Trotter circuit. If (a) fails, the memory claims collapse; if (b) fails, rerun the 16-site parallel scaling and convergence experiments with U equal to the exact time evolution and report whether the stated approximation errors are still reached.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central complexity claims in Section V.B (target function O(n 4^k), gradient O(n 4^k), Hessian O(n^2 4^k)) count only gate applications of C(G) to basis states. They do not include the cost of applying the target unitary U to |j> in Eq. (6), although every summand requires U|j>. Section II.B only says that 'the action of U is implemented as a matrix-free application to a state vector,' without specifying the mechanism or its cost. In the 16-site benchmarks, the target is the time-evolution operator of the hard-core boson Hamiltonian in Eq. (28). A dense representation of U would require about 64 GiB, directly contradicting the paper's memory premise. A Trotterized U would mean the optimized circuit is compressing a fixed approximate evolution rather than approximating the exact time evolution, changing the meaning of the reported errors. A sparse/Krylov e^{-iHt}|j> action would resolve the issue, but it is never described. This is load-bearing because the entire 'matrix-free' claim and the benchmark fidelity numbers depend on which concrete U|j> routine is actually used.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","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.","tokens_in":18041,"tokens_out":10562,"duration_ms":108479,"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":[{"comment":"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.","section":"§II.B, Eq. (6); §V.B"},{"comment":"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.","section":"§VI.A, Eqs. (25), (28)"},{"comment":"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.","section":"§IV.B; Appendix A"}],"minor_comments":[{"comment":"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.","section":"§II.A"},{"comment":"The summation expression '2k−1X' appears to be a typesetting artifact; please ensure the sum is formatted as \\sum_{j=0}^{2^k-1}.","section":"§II.B, Eq. (6)"},{"comment":"In the caption of Fig. 12(c), '14 core reference point' should read '14-thread reference point' to match the axis label.","section":"§VI.C, Fig. 12 caption"},{"comment":"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.","section":"§VI.E, Fig. 17"},{"comment":"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.","section":"§V.A"}],"recommendation":"major_revision","confidential_remarks":"The manuscript is transparent about code availability and builds honestly on prior work. The missing specification of the U|j⟩ routine is a serious gap that should be fixed before publication, because it directly underpins the matrix-free premise and the complexity model. The benchmark model relabeling should also be corrected in the abstract and introduction. I would not reject the paper, but these points need substantive revision."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Punchline: this is a competent, useful implementation paper. The main algorithmic ideas are (i) evaluating the trace in Eq. (6) by summing over basis states with a matrix-free U, (ii) a backprop-style caching scheme that brings gradient cost from O(n^2) to O(n) gate applications, and (iii) a second forward pass that computes the full Hessian with parity and translation savings. The pseudocode is concrete, the code is released, and the parallel-scaling benchmarks are credible. The comparison with the MPO approach is appropriately qualitative. This is real work that others can build on.\n\nThe soft spots: The paper repeatedly claims a 'matrix-free' application of U but never says how U|j> is computed. For the benchmark target, the time-evolution operator of a hard-core boson model, a dense U would be 64 GiB at 16 qubits, exactly what the paper says it avoids. A Trotterized or Krylov application changes the meaning of the approximation or adds a cost that is absent from the complexity table in Section V.B. The complexity statements count only gate applications of C(G); they ignore the per-basis-state cost of U|j>. That is a real gap, not a nitpick, because the memory and time advantages are the paper's core selling points. It can be fixed by specifying the routine (e.g., Krylov/Lanczos for e^{-iHt}|j>) and including its cost in the analysis, or by explicitly limiting the claims to cases where U is efficiently applicable.\n\nSecond, the abstract and introduction say 'Fermi-Hubbard model' without qualification, but the spinless benchmark omits the Jordan-Wigner Z-strings at the periodic boundary, turning it into a hard-core boson model. The paper states this clearly in Section VI.A, but the abstract is misleading. A one-sentence qualifier would fix it.\n\nOverall, the math and the implementation are sound on their own terms. The Hessian-vector product appendix is a nice bonus. This deserves a serious referee, but the referee should ask for the U action to be specified and the abstract to be corrected. My own verdict: conditional.","headline":"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.","tokens_in":18530,"tokens_out":2591,"would_cite":true,"duration_ms":27724,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":["03.67.Ac"],"model":"deepseek-v4-flash","headline":"Second-order Riemannian circuit optimization can be run matrix-free, evaluating objective, gradient, and Hessian through cached state-vector contractions.","keywords":["Riemannian optimization","quantum circuit optimization","matrix-free evaluation","state vector simulation","Hamiltonian simulation","Fermi-Hubbard model","parity conservation","parallel computing"],"falsifier":"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$.","tokens_in":17609,"feed_emoji":"⚛️","tokens_out":12095,"duration_ms":111160,"temperature":0.7,"pith_summary":"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.","feed_headline":"16-qubit circuits now get exact Hessian optimization","feed_subtitle":"State vectors alone evaluate gradients and Hessians, cutting memory from gigabytes to megabytes","key_machinery":"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.","core_discovery":"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.","pith_inferences":["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."],"forward_implications":["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."],"supporting_citations":[{"why":"Supplies the Riemannian trust-region circuit optimization setup and brick-wall ansatz this work extends.","marker":"[17]"},{"why":"Is the MPO-based Riemannian optimizer used as the comparison baseline for gradient time and convergence.","marker":"[18]"},{"why":"Provides the Riemannian gradient, Hessian, and projection formulas for isometric tensor networks that the gate derivations rely on.","marker":"[25]"},{"why":"Gives the geometry of the unitary manifold and its tangent space used throughout the optimization.","marker":"[28]"},{"why":"Defines the Riemannian trust-region algorithm, retraction, and Hessian that the implementation follows.","marker":"[29]"},{"why":"Supplies the truncated conjugate-gradient method used to solve the trust-region subproblem.","marker":"[30]"},{"why":"Provides the Adam update rule adapted to the Riemannian setting and used as the first-order baseline in the convergence comparison.","marker":"[32]"}],"fun_headline_variants":["Exact Hessians for 16-qubit circuits via state vectors","Matrix-free quantum circuit optimization scales to 112 threads","Riemannian trust-region with exact Hessian for quantum gates","Quantum circuit gate optimization without full unitary matrices"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"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.","fun_headline_variants_meta":{"raw":{"variants":["Exact Hessians for 16-qubit circuits via state vectors","Matrix-free quantum circuit optimization scales to 112 threads","Riemannian trust-region with exact Hessian for quantum gates","Quantum circuit gate optimization without full unitary matrices"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000304,"raw_usage":{"total_tokens":1767,"prompt_tokens":987,"completion_tokens":780,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":603,"completion_tokens_details":{"reasoning_tokens":725}},"tokens_in":603,"tokens_out":780,"duration_ms":7912,"temperature":1.0,"reasoning_tokens":725,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T21:32:21.684950+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"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$.","supporting_citations":[{"cited_title":"Mansuroglu, T","cited_arxiv_id":null,"evidence_quote":"Supplies the Riemannian trust-region circuit optimization setup and brick-wall ansatz this work extends."},{"cited_title":"Mansuroglu, F","cited_arxiv_id":null,"evidence_quote":"Is the MPO-based Riemannian optimizer used as the comparison baseline for gradient time and convergence."},{"cited_title":"Efficient Quantum Circuit Compilation for Near-Term Quantum Advantage","cited_arxiv_id":"2501.07387","evidence_quote":"Gives the geometry of the unitary manifold and its tangent space used throughout the optimization."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Defines the Riemannian trust-region algorithm, retraction, and Hessian that the implementation follows."},{"cited_title":"Hauru, M","cited_arxiv_id":null,"evidence_quote":"Supplies the truncated conjugate-gradient method used to solve the trust-region subproblem."},{"cited_title":"A Riemannian Approach to the Lindbladian Dynamics of a Locally Purified Tensor Network","cited_arxiv_id":"2409.08127","evidence_quote":"Provides the Adam update rule adapted to the Riemannian setting and used as the first-order baseline in the convergence comparison."}],"review_version":1}