PaperlayerView exact revision on arXiv

Source-linked AI summary

Partially Fault-Tolerant Quantum Computation for Megaquop Applications

Ming-Zhi Chung, Ali H. Z. Kavaki, Artur Scherer, Abdullah Khalid, Xiangzhou Kong, Toru Kawakubo, Namit Anand, Gebremedhin A Dagnew, Zachary Webb, Allyson Silva, Gaurav Gyawali, Tennin Yan, Keisuke Fujii, Alan Ho, Masoud Mohseni, Pooya Ronagh, John Martinis

arXiv:2603.13093v1quant-ph

TL;DR

The paper asks whether partial FTQC can reduce the resource burden of megaquop-scale computation while remaining viable for useful applications. It uses realistic superconducting-hardware QRE and code-growth analysis to compare STAR with full FTQC, finding a circuit-size window where STAR is effective and identifying Fermi–Hubbard simulation as a promising application.

  • Problem

    Utility-scale surface-code FTQC often requires more than a million physical qubits, creating a need to assess lower-overhead partially fault-tolerant architectures for practical computation.

  • Method

    The paper benchmarks STAR using realistic superconducting hardware specifications, resource-state preparation and growth protocols, and QRE comparisons with fully fault-tolerant implementations.

  • Results

    STAR is most effective for roughly 10^5–10^6 small-angle rotation gates, while error-mitigation overhead makes it rapidly impractical beyond this Goldilocks scale.

  • Takeaways & Limitations

    Partial FTQC is particularly promising for applications naturally dominated by small-angle rotations, with 2D Fermi–Hubbard simulation identified as a strong candidate.

Abstract

from arXiv · show

Partially fault-tolerant quantum computing (FTQC) has recently emerged as a promising approach for the execution of megaquop-scale circuits with millions of logical operations. In this work, we demonstrate the strengths and the limitations of this approach by conducting quantum resource estimation (QRE) of the space--time-efficient analog rotation (STAR) architecture using realistic hardware specifications for superconducting processors, and compare it against the QRE of the full FTQC architecture. We show how the performance of the STAR architecture's protocols is affected by hardware improvements. We also reduce the space requirements for partial FTQC by developing a procedure leveraging code growth to decrease the size of a factory producing analog rotation states. Our results reveal a non-trivial dependence of the optimal pre-growth code distance on the rotation angle with respect to post-growth infidelity. Further, we analyze space--time trade-offs between the factory size and the error-mitigation overhead, and observe that in an application-agnostic setting, there is a Goldilocks zone for circuits in the regime of roughly $10^5$--$10^6$ small-angle rotation gates. We show that quantum simulation of 2D Fermi--Hubbard model systems is a particularly well-suited application for the STAR architecture, requiring only hundreds of thousands of physical qubits and runtimes on the order of minutes for modest system sizes. Due to its favourable algorithmic scaling to larger system sizes, utility-scale simulation of the 2D Fermi--Hubbard model could potentially be attained using partial FTQC.

I. INTRODUCTION

The paper evaluates partially fault-tolerant STAR architectures as a lower-overhead route to megaquop-scale computation, focusing on realistic superconducting hardware, resource-state preparation, and application-dependent trade-offs. It finds that STAR performance depends strongly on hardware quality, code-growth choices, circuit size, and workload structure.

  • More than a million physical qubits are typically required for utility-scale quantum advantage with surface-code FTQC, motivating partially fault-tolerant alternatives.
  • Partial FTQC is especially relevant to applications dominated by small-angle rotations, including Hamiltonian simulation and the 2D Fermi–Hubbard model.The paper benchmarks molecular electronic spectra and 2D Fermi–Hubbard simulations as representative high-utility applications.
  • STAR combines surface-code Clifford operations with directly prepared analog rotation states, error mitigation, and optimized compilation.
  • Realistic superconducting-hardware emulations benchmark resource-state preparation and quantify sensitivity to target versus desired hardware specifications.The desired specifications correspond to a noise model with twice the error suppression rate of the target specifications.
  • Resource states are prepared at smaller code distances and then grown because preparation success decreases sharply at the larger distances required by deep computations.Growth reduces factory pressure but can increase the final logical error rate and error-mitigation overhead.
  • For circuits with roughly 10^5–10^6 small-angle rotation gates, STAR can outperform fully fault-tolerant approaches, while its mitigation overhead becomes prohibitive at larger scales.For fewer than roughly 10^5 gates, magic-state cultivation can require smaller factories; beyond the Goldilocks range, STAR rapidly becomes impractical.

A. STAR: A space–time-efficient analog-rotation partially fault-tolerant quantum computing architecture

STAR avoids magic-state distillation by directly preparing and teleporting arbitrary-angle rotation states, while using repeat-until-success and error mitigation to control finite ancilla errors. Its resource-state protocols trade fidelity and success probability against circuit overhead, with particular relevance to small-angle quantum simulation.

  • STAR replaces magic-state distillation with direct preparation and gate teleportation of arbitrary-angle rotation resource states.The rotation states are consumed through multi-Pauli measurements, with software corrections when required.
  • Gate teleportation can under-rotate by 2θ, so repeat-until-success applies the intended rotation with an average of two attempts.Ancilla states retain finite error rather than being distilled to arbitrarily small infidelity.
  • Ancilla preparation determines rotation fidelity, logical error rate, success probability, and the resulting circuit resource overhead.The reviewed protocols span subsystem-code preparation, transversal rotations, and transversal multi-rotation with post-selection.
  • The multi-Pauli protocol’s success probability is evaluated noise-free at θ∗ = 10^-3 across different Pauli-generator weights.The figure compares how generator weight affects protocol success for this target angle.
  • RUS error scaling uses α_RUS ≈ 0.4k for fixed weight and α_RUS ≈ 1.5 for hybrid use of the three protocols.The factor captures the additional error contribution from combining multiple rotations.
  • Small-angle rotations are especially useful for quantum simulation because their error-corrected implementation can reduce the space and time overhead associated with magic-state-based approaches.The paper contrasts this with more sophisticated block-encoding and QSVT approaches in the EFTQC regime.

B. Phase estimation algorithms for EFTQC architectures

EFTQC phase-estimation algorithms trade maximum evolution time against total runtime under limited physical resources. The paper selects QCELS for subsequent resource estimation because it can retain Heisenberg scaling while allowing a small maximum evolution time.

  • EFTQC phase estimation balances maximum evolution time T_max against total evolution time T_total under constrained physical resources.T_max tracks the deepest-circuit runtime, whereas T_total tracks the full algorithm runtime.
  • Gaussian SPE minimizes T_max with scaling O(Δ^-1), typically below the O(ϵ^-1) scaling associated with standard fault-tolerant estimation.Its Gaussian filter width is controlled by the Hamiltonian spectral gap.
  • QCELS has T_max = O(δϵ^-1) and T_total = O(δ^-1ϵ^-1), with δ scaling as O(√(1 − p_0)).The maximum evolution time can become arbitrarily small when the input state is the exact ground state, while total runtime retains Heisenberg scaling.
  • QCELS is selected as the target EFTQC algorithm for the paper’s subsequent resource estimations.

III. SIMULATION OF THE TRANSVERSAL MULTI-ROTATION PROTOCOL AND CODE GROWTH

The transversal rotation protocol is simulated using Stim and PyMatching on rotated surface codes with odd distances, including validation against prior results and hardware-specific resource-estimation scenarios.

  • Stim and PyMatching are used to simulate transversal rotation protocols and decode the resulting Clifford circuits.The framework is first validated against prior simulations using an odd-distance rotated surface code and a uniform depolarizing model.

A. Sensitivity of resource state preparation to hardware improvements

Resource-state preparation is evaluated under target hardware specifications for rotation weights w = 2 and w = 3. Higher weight improves success rates but worsens infidelity, while rapidly falling success rates require code growth.

  • Resource estimates simulate odd-distance rotated surface codes for w = 2 and w = 3 under target hardware specifications.When w does not divide d, a smaller-weight rotation is used for the final part of the row.
  • w = 3 has better success rates than w = 2 but worse infidelity because its longer rotation circuit introduces more errors.
  • At a one-percent success-rate tolerance, d = 13 is the largest directly creatable state, so smaller states must be grown to the core processor’s required distance.Success rate falls rapidly with code distance, preventing direct use at the required target distance.

B. Growing rotation resource states

The paper uses code growth to prepare rotation resource states on small patches and expand them to required distances, reducing factory demands while introducing growth errors and time overhead. A two-step protocol lowers logical error rates relative to direct growth, with larger initial patches performing better.

  • Growth protocol: Code growth expands rotation resource states from initial distance d_i to target distance d_f while requiring O(d_f) rounds of error correction.The expansion zone is initialized in |0⟩ or |+⟩ states before error-correction rounds resolve its stabilizers.
  • Growth protocol: Success rates for transversal multi-rotation preparation decrease significantly at larger code distances, motivating growth from smaller patches.The protocol separates resource-state preparation from the larger patch distance required by the core processor.
  • Growth errors: Larger initial patches produce lower logical error rates even when they grow to similar final distances.Growth is not fault tolerant, so the process necessarily injects additional errors into the logical state.
  • Two-step growth: Increasing the initial distance by 2 in a two-step protocol typically reduces logical error rate by nearly an order of magnitude.The intermediate patch adds at least d_i + 2 stabilization rounds, creating a time trade-off.
  • Two-step growth: Simulations closely match the analytical prediction obtained by summing the logical error rates of the two individual growth steps.Asymptotic fits provide tight upper bounds for logical error rates when directly simulating resource-estimation distances is infeasible.
  • Resource estimation: The final fidelity of a resource state initially prepared at d_i and grown to d_f is used in the quantum resource estimates.The paper models this fidelity as the combined outcome of preparation and subsequent code-patch growth.

C. Rotation gate error evaluation

The paper evaluates logical rotation errors by combining resource-state infidelity, growth infidelity, and error accumulation across repeat-until-success trials. The resulting error model scales linearly with the rotation-angle magnitude, while the multi-rotation protocol trades higher success rates for worse infidelity.

  • Error model: Rotation-state infidelity and growth error accumulate across multiple repeat-until-success trials, determining the logical R_Z(θ*) error.Probabilistic coherent error cancellation is applied to the coherent over-rotation contribution at the cost of doubling the infidelity-related overhead.
  • Error model: The rotation angle is constrained within π/8; larger angles are replaced by an S gate and a rotation of |π/4 − φ|.The growth contribution is included separately through the growth infidelity term.
  • Scaling: The estimated R_Z rotation error scales as O(θ*), with the α_RUS factor kept explicit for later probabilistic error-cancellation overhead comparisons.The fitting equation is shown in the Figure 10 legends.

IV. RESOURCE ESTIMATION STUDIES

The resource-estimation studies assess ground-state energy estimation for molecular spectra and Fermi–Hubbard simulations using physical-qubit counts and physical wall-clock times. They use success-rate and infidelity estimates from the preceding protocol analysis.

  • Applications: The studies target two representative applications: quantum computation of molecular electronic spectra and quantum simulation of the Fermi–Hubbard model.These applications are evaluated within ground-state energy estimation.
  • Resource metrics: Resource estimates report physical qubit count and physical wall-clock time for executing the associated quantum circuits.The estimates use success-rate and infidelity models developed for the resource-state protocols.

A. Runtime estimation

Runtime estimation combines algorithmic error budgeting with architecture-dependent circuit depth, patch layouts, factory layouts, growth protocols, and lattice-surgery scheduling. The required final code distance is selected so total logical error remains below the target threshold.

  • Error budgeting: The QCELS error budget balances Trotter-decomposition error, QCELS error, and tolerable target energy error to minimize the required Trotter steps.The resulting runtime is then evaluated from the optimized algorithmic parameters.
  • Runtime components: Simulation results affect runtime through the PEC overhead factor γ²_n,j and the execution time of one Trotter step.Both quantities depend on the initial and final code distances of the growth protocol.
  • Code-distance selection: The final code distance is chosen by requiring logical space-time volume multiplied by surface-code memory error rate to remain below the total logical-error target.The core processor uses N_patch logical patches, while C denotes the circuit depth of one clock cycle.
  • Runtime components: N_clock depends on patch layout, factory layout, growth protocol, and lattice-surgery scheduling needed to maintain continuous resource-state supply.The corresponding equation accounts only for idling and lattice-surgery errors, not rotation-state-preparation errors.
  • Error mitigation: The PEC overhead term depends on rotation-gate errors accumulated across the Trotter slices used in each QCELS step.N_n,j counts the Trotter slices, and the relevant summation covers rotation-gate errors within one slice.

B. Electronic-structure quantum computations: ground-state energy estimation for small molecular active spaces

The p-benzyne QRE evaluates QCELS ground-state energy estimation across molecular active spaces using the STAR architecture, with resource-state growth used to address infeasible final code distances. Physical runtime can greatly exceed PEC-free runtime as Hamiltonian complexity increases.

  • The study estimates STAR-based QCELS resources for p-benzyne across molecular active spaces using the 6−31G basis and active-space choices from prior work.
  • QCELS uses one rotation gate at a time for molecular scheduling, while the layout permits one-cycle utilization of an analog rotation resource state.
  • The QCELS analysis compares empirical δ = 0.06 with the theoretically permitted δ = 0.001 for perfect input-state overlap.
  • Final code distances mostly exceed 15, making direct resource-state creation unlikely to succeed and motivating the two-step growth protocol.Smaller initial distances reduce factory size but increase PEC overhead through greater growth depth.
  • ∥H∥1 ≈ 6.6 for Norb = 6 and ∥H∥1 ≈ 45.1 for Norb = 14 correspond to physical times several orders of magnitude above PEC-free runtime.
  • The resource-state factory prepares states on small patches every four stabilization rounds and grows successful states into larger patches in di + 2 + df rounds.

C. Ground-state energy estimation for the Fermi–Hubbard model

The Fermi–Hubbard QRE applies STAR-based QCELS to a local model whose rotation-gate count scales linearly with lattice size. Modest systems require minutes, although feasible lattice sizes depend strongly on hardware specifications and target accuracy.

  • The 2D Fermi–Hubbard model has a linear relationship between lattice sites and rotation gates, making it a test of STAR scaling for larger systems.
  • The Fermi–Hubbard layout uses interior pink patches for resource-state preparation, growth, and bus functions, with exterior violet patches for computational data qubits.
  • The two-step growth simulation depends on di, df, and θ∗, with df found iteratively until the resource-state error condition is satisfied.
  • The resource estimates are reported for accuracies ϵ = 0.005L2 and ϵ = 0.01, using δ = 0.06.
  • Execution times are minutes for target and desired hardware specifications, but PEC overhead makes the estimates orders of magnitude larger than earlier estimates.
  • For ϵ = 0.01, the target device reaches L = 4, the desired device L = 6, and Ref. covers L = 4 through L = 10.

D. Factory size requirements, and viability assessment

Factory size and PEC overhead create a space–time trade-off in STAR architectures. Patch growth can reduce factory footprint, but increasing code distance eventually makes PEC prohibitive; cultivation is cheapest only for smaller circuits.

  • Increasing preparation distance raises overall gate error, limiting reliable circuit size as larger distances become necessary for Clifford protection.
  • Patch growth prepares resource states at lower initial distance and grows them to larger final distance, reducing factory footprint and sometimes lowering total error.The benefit occurs when gate error dominates the small, angle-independent growth error.
  • Cultivation is significantly cheaper than STAR and magic-state-distillation FTQC, but its approximately 10−9 T-state error supports circuits only up to roughly 10^5 rotation gates at ϵlog err = 0.01.
  • Without growth, success probability falls below 1% at d = 15 or higher for target hardware, making STAR impractical beyond d = 15 because PEC overhead becomes overwhelming.
  • For a fixed circuit size and tolerable PEC slowdown, Figure 10 identifies the smallest supporting factory, while the circuit-size upper bound depends on rotation angles.
  • The factory comparison measures physical-qubit cost across circuit sizes with θ∗ = 10−4 or smaller, including STAR protocols with and without growth.

V. CONCLUSION AND PERSPECTIVES

The paper finds that partially fault-tolerant STAR architectures can reduce resource requirements for suitable circuits, but their practicality is constrained by code-growth fidelity and error-mitigation overheads. The strongest application fit is Fermi–Hubbard simulation, while broader utility-scale use requires improved mitigation and architectural protocols.

  • Resource-state preparation: Very large code distances beyond d = 20 are required for the target hardware specifications, making direct resource-state preparation unlikely to succeed reliably.The transversal multi-rotation protocol’s success probability becomes very low at large distances, motivating preparation at lower distance followed by code growth.
  • Resource-state preparation: Naïve code growth dramatically increases logical error rates, producing astronomically large probabilistic error-cancellation overheads for initial distances di = 11 or di = 13.The reported growth simulations show that low-distance preparation alone does not solve the fidelity problem.
  • Scaling and trade-offs: STAR factory size and error-mitigation overhead trade off as circuit size increases, with the application-agnostic Goldilocks regime near 10^5–10^6 small-angle rotation gates.STAR is particularly effective in the slightly sub-megaquop regime but rapidly becomes impractical beyond that scale unless mitigation improves.
  • Future directions: The paper identifies improved growth protocols, error mitigation, patch layouts, and scheduling strategies as priorities for making STAR viable at utility scale.Candidate growth methods may improve post-growth fidelity and reduce PEC overhead, while alternative layouts could reduce preparation-region requirements.
  • Applications: Fermi–Hubbard simulation is well matched to STAR because its circuits consist largely of repeated small-angle rotations from Trotter–Suzuki formulas.The paper identifies standard Trotterization and related simulation methods as promising algorithmic settings for STAR.

Appendix B: Improved Trotter error factor for p-benzyne Hamiltonian

The appendix estimates the first-order Trotter error factor w for the p-benzyne Hamiltonian by directly diagonalizing exact and Trotter effective Hamiltonians, obtaining a fitted dependence on orbital count. The resulting model preserves O(dt^2) scaling and provides a tighter error bound for resource estimation.

  • Implication for resource estimation: The fitted coefficient is smaller than the empirical bound used in Ref. [1], yielding a tighter and more optimistic estimate of the required Trotter steps.The appendix attributes the tighter estimate to numerical evaluation rather than loose theoretical bounds.
  • Estimating the Trotter error factor: Direct diagonalization of the exact and Trotter effective Hamiltonians replaces looser theoretical or empirical error bounds when estimating w.The Hamiltonians are diagonalized at different dt values and fitted to the Trotter error model.
  • Estimating the Trotter error factor: w = (3 × 10^-5)N_orb^2 is the fitted relation obtained from limited diagonalization data over H_L ± 0, 1, 2.The fit provides w as a function of the number of orbitals for the resource estimation.
  • Error-scaling assumption: The first-order product formula follows O(dt^2) Trotter-error scaling for this real-valued Hamiltonian, matching the stated second-order scaling.The Hamiltonian contains Pauli strings with real coefficients, and the scaling was explicitly checked in Figure 19(a).
Loading 2603.13093v1…