Probabilistic imaginary-time evolution via compiled diagonal representations

AI summary

Overview

Research area: Quantum computing — quantum algorithms for quantum simulation, specifically probabilistic imaginary-time evolution (PITE) for ground-state and thermal-state preparation.

Technical level: Advanced. The paper assumes familiarity with Pauli-string Hamiltonians, Kraus operators, ancilla-assisted postselection, product formulas, and variational unitary compilation.

Scope: The paper introduces and benchmarks FITE (fast imaginary-time evolution), a PITE variant that replaces termwise Pauli filters with filters built on an offline-compiled approximate diagonal representation of the Hamiltonian, and compares its accuracy, success probability, and gate cost against three established PITE baselines on small Hubbard, XY, and XYZ models.

What This Paper Is About

Imaginary-time evolution prepares low-energy states by applying the nonunitary operator e^(−βH), which cannot be run directly on a quantum computer. Probabilistic ITE handles this by coupling the system to ancillas and postselecting on measurement outcomes, but for noncommuting Hamiltonians the standard approach breaks the evolution into many short Pauli-term steps, and each step's normalization lowers the chance that postselection succeeds. The authors ask whether compiling the Hamiltonian into an approximate diagonal form — whose terms commute, so each filter can cover the full imaginary time β in one shot — can lower the online circuit cost per accepted output while keeping accuracy at a fixed threshold.

Key Contributions

1. A compiled-diagonal PITE scheme (FITE). A basis circuit W is optimized offline so that H ≈ W ℋ W†, where ℋ is a sum of K commuting Pauli-Z strings. Because these terms commute, e^(−βH̃) factorizes into one filter per retained term covering the full β, so the online circuit structure and CX count per attempt do not depend on β, and the same representation is reused across input states and evolution times.

2. A coefficient-recovery procedure that avoids energy-branch ambiguity. Optimized real-time phases only determine energies up to branches ξ_k^(m_k) = (φ_k^wrap + 2πm_k)/(2Δt). Instead of selecting a branch, the authors fix W and project the physical Hamiltonian onto each retained Z string, ξ_k^proj = (1/N)Tr[W†HW 𝒵_k], estimating each normalized trace with a Hadamard-style test on 2n+1 qubits using n Bell pairs.

3. An analytic condition for enhanced success probability. For exact diagonalization, the log-ratio of success probabilities relative to termwise PITE is ln(P_FITE/P_PITE) = 2β(λ − Λ), where λ = Σ|c_j| and Λ = Σ|ξ_k|. Thus Λ < λ gives an exponential relative gain in β, independent of the input state; the predicted slopes are checked numerically.

4. Benchmarks at a common accuracy threshold including retries. FITE is compared with first-order Pauli PITE (P1), symmetric second-order Pauli PITE (P2), and symmetric second-order grouped two-site filtering (G2) at an empirical 1% mean-infidelity threshold, counting CX gates per full attempt and per accepted output with early abort and repeated attempts.

Main Findings

• Accuracy stays near the 1% level over 0.05 ≤ β ≤ 1.1. FITE mean infidelity at β = 1.1 is 0.00245 (Hubbard), 0.00158 (XY), and 0.00408 (XYZ), close to P1, while P2 and G2 reach lower infidelity at the fixed step τ = 0.05.

• Success probability is substantially higher than termwise PITE. At β = 1.1, FITE mean success is 0.317, 0.0641, and 4.09×10^(−4) for Hubbard, XY, and XYZ — approximately 21, 263, and 123 times the corresponding P1 values, with similar gains over P2.

• The success gain follows the predicted normalization mechanism. Table 1 gives λ = 5, 8, 10.5 and Λ = 3.6, 5.46, 8.3 for Hubbard, XY, XYZ; theoretical slopes 2(λ − Λ) are 2.7972, 5.0757, 4.3941 versus fitted slopes 2.7789, 5.0649, 4.3708, with maximum absolute deviations from 2β(λ − Λ) of 0.0199, 0.0115, and 0.0235.

• Gate count per attempt is flat in β. FITE uses 12, 58, and 50 CX per full attempt for Hubbard, XY, and XYZ regardless of β, since only filter angles change. Baseline P1/P2 counts grow with the number of steps needed to meet the threshold.

• Lower cost per accepted output than P1 and P2 at every sampled time. With retries and early abort included, FITE beats P1 and P2 from β = 0.25 to 5, and also beats G2 for XY. At β = 1.1 the Hubbard FITE and G2 costs are both approximately 41 CX per accepted output.

• Grouped filtering can win despite larger circuits. For XYZ at β = 1.1, G2 costs 3.3×10^3 CX per accepted output versus 2.36×10^5 for FITE, even though G2 uses slightly more gates per attempt (56 versus 50), because its success probability is higher.

• Small absolute success can dominate at long times. For XYZ at β = 5, FITE's cost per accepted output reaches 7.21×10^14 CX even though each full attempt still costs only 50 CX.

• Target bias, not fit residual, drives the residual error. Reducing Δt from 0.05 to 0.0125 lowers phase-route mean infidelity at β = 1.1 to 1.53×10^(−4), 9.91×10^(−5), and 2.92×10^(−4) for Hubbard, XY, and XYZ, tracking controls built from the exact effective Hamiltonian H_eff = (i/Δt) log U_T(Δt).

• Deeper compilation is not automatically more accurate. In the XYZ depth scan at n = 3, Δt = 0.05, the d = 8 fit has lower compilation cost than d = 5 but a higher mean infidelity at β = 5 (0.00226 versus 4.83×10^(−4)); the effective-target ground-state error is also 0.00226.

• Scaling is not established. Four- and five-qubit XYZ fits remain above 1% mean infidelity under the chosen ansatz and finite optimization budget, and the authors state that their results do not demonstrate efficient scaling.

Methodology in Plain English

The workflow has four stages.

First, compile a basis offline. The authors use variational fast forwarding: because a Hamiltonian and its real-time propagator share an eigenbasis, they fit a short-time Trotter step U_T(Δt) with the structured form W(θ) D(φ) W†(θ), where D is a product of commuting Z-string rotations. The fit minimizes the local Hilbert–Schmidt test cost C_LHST, which vanishes when the two unitaries agree up to a global phase. The basis ansatz is a layered circuit of Ry and Rz rotations with nearest-neighbor CZ gates.

Second, recover physical coefficients. The optimized angles are ambiguous up to multiples of 2π in energy, so the authors keep W fixed and extract each diagonal coefficient from the physical Hamiltonian by Pauli orthogonality, estimating the required normalized traces with a small ancilla test. This makes the coefficients independent of energy-branch choices.

Third, build the filters. Each retained Z string gets one ancilla-assisted filter: CX gates compute the parity onto one qubit, a conditional Ry rotation with angle γ_k = 2 arccos(e^(−2β|ξ_k|)) on an ancilla, and postselection on the ancilla outcome zero. All K outcomes must be zero; otherwise the attempt is aborted, ideally at the first failed measurement, and the same input is prepared again. One ancilla is reused across filters.

Fourth, benchmark. The authors test a two-qubit Hubbard model, an open XY chain, and an open XYZ chain with main configurations (n, d, K) = (2, 2, 3), (5, 6, 5), and (3, 8, 6) at Δt = 0.05. They average fidelity over 16,384 complex-Haar inputs per model, compute mean success exactly, and compare gate counts at a 1% mean-infidelity threshold, selecting the smallest passing step count M from 1 to 400 for each baseline. Counts exclude input preparation, offline compilation, coefficient estimation, and hardware routing.

Why This Matters

The work isolates a concrete mechanism — reducing normalization loss by making filter terms commute — that converts into an exponential-in-β advantage in postselection probability, and it quantifies when that advantage actually reduces the cost of producing an accepted state rather than only the cost of a single attempt. The distinction between gates per attempt and gates per accepted output, and the demonstration that grouped filtering can beat a smaller circuit, give a template for realistic resource accounting in probabilistic quantum algorithms.

Potential application areas:

• Ground-state preparation for quantum many-body simulation, the primary use case for ITE cited in the paper.
• Thermal-state preparation and finite-temperature observable estimation, where ITE serves as a subroutine.
• Interacting fermion and spin-chain models, represented here by the Hubbard, XY, and XYZ benchmarks.
• Pre-fault-tolerant algorithm design, where postselection probability and circuit reuse dominate practical cost.

Industry relevance: The authors are affiliated with Arclight Quantum Computing Inc. and the Institute of Software, Chinese Academy of Sciences, and the emphasis on amortizing offline compilation across many inputs and evolution times speaks directly to how quantum-software teams budget compilation and runtime. The paper is explicit that hardware noise, routing, and finite-shot training are outside its benchmarks, so the reported savings are logical-gate projections rather than hardware-validated results.

Future Directions

• Designing basis circuits that preserve Hamiltonian symmetries, which the authors name as a direction for extending the method, since the common default layered ansatz does not impose model-specific structure.
• Quantifying and reducing offline preparation cost, including compilation and finite-shot coefficient estimation; the paper states it has not quantified the full offline cost, so the reuse needed for an overall advantage remains undetermined.
• Establishing scaling beyond small systems, given that four- and five-qubit XYZ fits stayed above 1% mean infidelity under the chosen ansatz and optimization budget.
• Input-dependent accuracy checks, motivated by the reported case where symmetry leakage can populate a lower-energy sector absent from the input and distort the normalized output.

Target Audience

Quantum-algorithm researchers and graduate students working on state preparation, quantum simulation, and probabilistic or postselection-based circuits; quantum-software engineers evaluating compilation-versus-runtime trade-offs; and readers who already know the PITE/QITE/VITE landscape and want a careful accounting of when a compiled diagonal representation pays off. Beginners will find the core idea accessible but will need background in Pauli-string Hamiltonians and ancilla postselection to follow the derivations.

Authors’ abstract

We introduce a probabilistic imaginary-time evolution scheme based on a compiled approximate diagonal representation of the Hamiltonian. A basis transformation is optimized offline. For a fixed compiled representation, the online circuit structure and gate count per attempt are independent of the imaginary time, and the same representation can be reused across different input states and evolution times. We derive a condition for enhanced success probability. Numerical tests show reduced online cost relative to termwise Pauli-based methods at a common accuracy threshold. We also examine how approximation errors and offline preparation costs affect the overall benefit.