The FLuid Allocation of Surface code Qubits (FLASQ) cost model for early fault-tolerant quantum algorithms

TL;DR

The paper introduces FLASQ, a fluid-ancilla resource model for early fault-tolerant quantum algorithms on 2D surface-code architectures. By modeling ancilla space as a navigable resource and incorporating lattice-surgery costs, magic-state cultivation, and reaction-time constraints, FLASQ provides time and spacetime-volume estimates that better reflect hardware realities than traditional T-count metrics. Case studies on 2D TFIM Ising dynamics and Hamming weight phasing demonstrate that modern advances—magic-state cultivation, walking surface codes, and quantum error mitigation—can dramatically reduce resources, while also revealing nontrivial tradeoffs in layout, ancilla usage, and routing. Overall, FLASQ offers a tractable, architecture-aware framework to guide EFT algorithm design and hardware planning, enabling more realistic assessments of the move from NISQ to fault-tolerant quantum advantage.

Abstract

Holistic resource estimates are essential for guiding the development of fault-tolerant quantum algorithms and the computers they will run on. This is particularly true when we focus on highly-constrained early fault-tolerant devices. Many attempts to optimize algorithms for early fault-tolerance focus on simple metrics, such as the circuit depth or T-count. These metrics fail to capture critical overheads, such as the spacetime cost of Clifford operations and routing, or miss they key optimizations. We propose the FLuid Allocation of Surface code Qubits (FLASQ) cost model, tailored for architectures that use a two-dimensional lattice of qubits to implement the two-dimensional surface code. FLASQ abstracts away the complexity of routing by assuming that ancilla space and time can be fluidly rearranged, allowing for the tractable estimation of spacetime volume while still capturing important details neglected by simpler approaches. At the same time, it enforces constraints imposed by the circuit's measurement depth and the processor's reaction time. We apply FLASQ to analyze the cost of a standard two-dimensional lattice model simulation, finding that modern advances (such as magic state cultivation and the combination of quantum error correction and mitigation) reduce both the time and space required for this task by an order of magnitude compared with previous estimates. We also analyze the Hamming weight phasing approach to synthesizing parallel rotations, revealing that despite its low T-count, the overhead from imposing a 2D layout and from its use of additional ancilla qubits will make it challenging to benefit from in early fault-tolerance. We hope that the FLASQ cost model will help to better align early fault-tolerant algorithmic design with actual hardware realization costs without demanding excessive knowledge of quantum error correction from quantum algorithmists.

Figures (31)

• Figure 1: A visualization of a simple situation where rearranging ancilla space is much faster using walking surface codes. The squares represent logical qubits arranged in a $2 \times 11$ rectangle. All qubits but the top right are in use and we wish to move the ancilla space to the top left by shifting the top row over to the right. Using standard lattice surgery techniques, each qubit would have to be moved sequentially. These movement operations can be performed in one logical timestep, so moving the entire row of qubits would take $10$ logical timesteps. Walking surface codes allow for all of the qubits to be shifted together in $2$ logical timesteps.
• Figure 2: A cartoon that shows how the FLASQ model functions when we are spacetime-limited. We visualize space horizontally and time vertically. Left and right are two cartoons representing the same computation with varying amounts of fluid ancilla space. The orange rounded rectangles represent algorithmic qubits and the blue rounded rectangles represent fluid ancilla qubits. The fluid ancilla spacetime volume (blue fill) is conserved between the two scenarios, although the overall spacetime volume is not (sum of blue fill and orange fill).
• Figure 3: FLASQ estimates of the total time required to estimate a diagonal observable with unit norm to within $.01$ after $20$ second-order Trotter steps for an $11\times11$ two-dimensional Ising model as a function of the physical error rate and the number of physical qubits. This task is challenging for existing classical methods in certain parameter regimes Haghshenas2025-kdMandra2025-sa. These estimates assume a surface code cycle time of $\qty{1}{\us}$ and a reaction time of $\qty{10}{\us}$. Each square of the heatmap is colored and annotated according to the total amount of time required (in hours).
• Figure 4: An overview of our compilation strategy for implementing time evolution by the $2D$ Ising model Hamiltonian using the mixed fallback protocol of Kliuchnikov2023-vm for rotation synthesis (see also \ref{['app:rotation_synthesis_details']}).
• Figure 5: A heatmap showing the logarithm of the runtime ratio between an optimized fault-tolerant (FT) approach and a noisy, intermediate-scale (NISQ) approach to a specific Ising model simulation task as a function of the number of physical qubits (x axis) and the noise strength (y axis). The NISQ approach applies error mitigation (specifically, probabilistic error cancellation) to many parallel simulations to address noise. The FT approach applies error mitigation to a single error-corrected simulation. In both cases, the goal is to measure a diagonal observable with unit norm after performing $20$ second-order Trotter steps of an $11 \times 11$ Ising model Hamiltonian with open boundary conditions. Blue regions (negative values) indicate where the FT approach is faster, while red regions (positive values) indicate where the NISQ approach is faster. The white area marks the crossover frontier where performance is comparable. For the NISQ simulations, the error rate is the strength of the single-qubit depolarizing noise applied after each layer of two-qubit gates, whereas for the FT simulations, we use a simple phenomenological error model detailed in \ref{['app:resource_estimates']}. A more comprehensive analysis would likely shift the crossover.