Quantum-compatible Riemannian conjugate gradient for ground-state preparation

AI summary

Overview

Research area: Quantum algorithms for ground-state preparation, specifically geometric (Riemannian) optimization on the unitary group, bridging classical manifold optimization with quantum circuit design.

Technical level: Advanced. The paper assumes familiarity with Riemannian geometry, Lie algebras, product formulas (group commutators, Trotter–Suzuki), and quantum imaginary-time evolution.

Scope: The paper introduces and numerically benchmarks QCGD, a quantum-compatible Riemannian conjugate-gradient update for ground-state preparation, against the DB-QITE (double-bracket quantum imaginary-time evolution) baseline on antiferromagnetic Heisenberg chains of 10 to 20 qubits.

What This Paper Is About

Preparing the ground state of a Hamiltonian can be framed as minimizing an energy function over the curved space of unitary operators, and the existing geometry-aware quantum method, DB-QITE, is essentially steepest-descent (gradient descent) on that space. The authors ask whether a "memory-enhanced" direction inspired by classical conjugate gradient descent—one that reuses information from the previous search direction—can be implemented as a quantum circuit and deliver larger energy reductions per iteration. The goal is to see whether faster convergence can offset the extra circuit cost, especially in an early fault-tolerant regime.

Key Contributions

1. A quantum-compatible Riemannian conjugate-gradient recursion (QCGD). The authors expand the classical Riemannian CGD search direction into a weighted sum of past state projectors, then approximate the resulting commutator exponential with the same group-commutator product formula used by DB-QITE, plus a Trotter–Suzuki approximation of the summed projector exponentials. The result is an explicit recursive circuit ansatz (Eq. 31).

2. A guaranteed no-worse-than-DB-QITE property. Because the QCGD parameter search includes the conjugate coefficient γ = 0, the QCGD candidate set always contains the corresponding DB-QITE update, so QCGD cannot increase the energy relative to that fallback at a given step.

3. A numerical benchmark against DB-QITE. Using the antiferromagnetic Heisenberg Hamiltonian for L ∈ {10, 12, 14, 16, 18, 20} qubits, with singlet and HVA (p = 1) initializations, simulated with the Qrisp sparse state-vector simulator, the authors compare energy trajectories, normalized excess energy, fidelity, and CZ gate counts.

4. A quantified trade-off between convergence and circuit depth. QCGD gives larger per-iteration energy reduction and fidelity but requires deeper circuits per update; the authors argue this may still be favorable because circuit depth in these schemes grows exponentially with iteration count, and they report the regime where QCGD matches or exceeds DB-QITE fidelity with shorter circuits.

Main Findings

• Faster per-iteration convergence: QCGD achieves a larger energy reduction per iteration than DB-QITE in the tested trajectories, and the advantage accumulated at an early step is retained at later steps.

• Regular improvement for the singlet initialization: Across all six system sizes, the percentage of initial excess energy removed improves by ΔR₂ between 23.0% and 24.1% at the second update, and ΔR₃ between 22.6% and 30.5% at the third update.

• Nonzero conjugate contribution is adaptive, not universal: On the L = 20 Heisenberg model with HVA initialization, the restricted grid (μ, γ) ∈ [0, 0.5]² produced minima on the boundary γ = 0.5, indicating the search range was limiting. Extending to [0, 1.5]² selected γ_opt = 1.11 at the second update but γ_opt = 0 at the third—so the memory term is not always selected, yet the earlier gain persists.

• Reaching below the first excited state: For the singlet initialization, L = 14 is the largest tested system size for which QCGD reaches E_k < λ₁ within three updates.

• Higher cost per update: QCGD's line search evaluates 400 candidate updates per iteration (20 × 20 grid over μ and γ), versus 20 for DB-QITE; the reported resource counts describe the selected state-preparation circuit and exclude this search overhead. Each QCGD update also has greater circuit depth than the corresponding DB-QITE update.

• Fidelity versus circuit size: When plotted against CZ count, QCGD's improved search direction matches or exceeds the fidelity obtained by DB-QITE with shorter circuits in the cases shown.

• Notable qualitative contrast with classical CGD: Figure 4 (classical Riemannian GD vs. CGD on the same Heisenberg model for L = 8, 10, 12) shows CGD consistently reaching lower energy, with the gap widening as GD plateaus at larger L—the behavior the quantum construction aims to retain.

Methodology in Plain English

The authors treat state preparation as a walk on the space of unitary operations, where each step is a short "geodesic" move in some direction, and the energy is the cost being pushed down. In the existing DB-QITE method, that direction is simply the steepest downhill direction (the commutator of the Hamiltonian with the current state), and the step length is picked by a one-dimensional search. The new method instead builds each direction from the current downhill direction plus a scaled version of the previous direction, exactly as classical conjugate gradient does—this is what suppresses the zig-zagging of plain gradient descent.

Making this work on a quantum device requires care: the ideal update is an exponential of a commutator, which is not directly implementable. The authors reuse the group-commutator trick (a product of four simple evolutions that approximates the commutator exponential to order O(μ^{3/2})) and, because the new direction is a sum of many past projectors, they approximate the sum's exponential with a Trotter–Suzuki product, keeping the four-factor commutator structure intact. Conveniently, the last factor only contributes a global phase on the current state and can be dropped, which is what yields the final recursive circuit. Each iteration then does a small grid search over the step size μ and the memory weight γ to pick the lowest-energy candidate.

Numerics use short antiferromagnetic Heisenberg chains (10 to 20 qubits) and two starting states: a product of nearest-neighbour singlets (which has an analytic preparation circuit and scales cleanly) and a single-layer Hamiltonian Variational Ansatz warm start on top of it. Hamiltonian evolution is done with a second-order Trotter–Suzuki formula with two Trotter steps, and both algorithms share identical simulation and compilation settings so that any difference comes from the update rule.

Why This Matters

Impact on research: The paper makes the case that decades of work on memory-accelerated Riemannian optimization can be transferred into quantum algorithm design, not just the steepest-descent case that current geometry-aware methods use. It also reframes the practical question for near-term/early-fault-tolerant algorithms: since circuit depth grows exponentially with iteration count in these recursive schemes (the paper cites O(3^k) query complexity for DB-QITE), reducing the number of iterations may matter more than reducing the depth of any single step.

Real-world applications:

• Quantum chemistry: ground-state energies of molecules, the canonical target of ground-state preparation.
• Materials science: computing ground states of model Hamiltonians such as the antiferromagnetic Heisenberg chain studied here.
• Combinatorial optimization: Max-Cut, graph partitioning, scheduling, and resource allocation, all cited as problems addressed through ground-state preparation.
• Machine learning and computer science tasks that map onto Hamiltonian ground-state problems.

Industry relevance: The work targets the early fault-tolerant era, where circuit depth budgets are tight but error correction is beginning to be available. A method that can serve as a warm-start strategy—or be layered on top of established block-encoding approaches and heuristic variational methods—is directly relevant to groups building end-to-end quantum workflows and to compiler/framework developers (the resource counts here come from Qrisp gate counts).

Future Directions

• Scaling the benchmark: tests stop at 20 qubits with state-vector simulation; whether the per-iteration advantage persists for larger L and for chemically relevant Hamiltonians is untested.
• Smarter parameter search: the reported advantage uses a brute-force 20 × 20 grid over (μ, γ); the sensitivity of the result to grid range (seen in the boundary minima at γ = 0.5) suggests better line-search or analytic step-size rules are needed, and the search overhead itself is excluded from the reported gate counts.
• Higher-order variants: the appendices describe higher-order product formulas reducing the commutator-approximation error to O(μ²) for both DB-QITE and QCGD; their end-to-end resource impact is an open comparison.
• Interplay with other methods: the authors propose QCGD as a warm start for, or in synergy with, established fault-tolerant and heuristic ground-state-preparation algorithms—an integration that remains to be demonstrated.

Target Audience

Researchers and graduate students in quantum algorithms and quantum information, particularly those working on ground-state preparation, quantum imaginary-time evolution, and geometric/optimization-based circuit design. It will also interest applied mathematicians working on Riemannian optimization who want to see manifold methods translated into quantum circuits, and quantum software/compiler engineers concerned with gate-count and depth trade-offs. Readers should be comfortable with Lie algebras, product formulas, and fidelity/energy benchmarking; the paper is not an introductory treatment.

Authors’ abstract

Riemannian optimization provides a natural geometric framework for designing quantum algorithms for ground-state preparation, most notably through quantum imaginary-time evolution. However, existing geometry-aware approaches primarily employ steepest-descent updates, leaving more advanced methods from classical Riemannian optimization largely unexplored. In this work, we introduce quantum conjugate gradient descent (QCGD), a quantum-compatible implementation of Riemannian conjugate gradient that combines the steepest descent direction with information retained from previous search directions. In our numerical experiments, the proposed approach achieves faster convergence per iteration than the baseline double-bracket quantum imaginary-time evolution (DB-QITE) algorithm, and we quantify the associated circuit cost with gate counts produced by Qrisp. This improvement, however, comes at the cost of increased circuit depth for each update step, revealing a trade-off between convergence rate and implementation complexity. Nevertheless, since the circuit depth for those algorithms grows exponentially with the number of iterations, the proposed method may offer practical advantages, particularly in the early fault-tolerant regime.