Gap-Priced $|T\rangle$-States: Dynamic $|T\rangle$ Post-Selection and Budget-Aware Factory Provisioning

AI summary

Overview

Research area: Fault-tolerant quantum computing (FTQC) — surface-code architectures, magic-state preparation, lattice-surgery scheduling, and resource allocation for Clifford+$T$ workloads.

Technical level: Advanced. The paper assumes familiarity with surface codes, Pauli-based computation, lattice surgery, cultivation, and distillation.

Scope: The paper presents GP$|T\rangle$-S, a scheduler and factory allocator that jointly tunes cultivation post-selection and distillation-factory configuration under a user-supplied total $T$-error budget, evaluated on sixteen benchmarks at budgets of $10^{-3}$ and $10^{-5}$.

What This Paper Is About

On surface-code architectures, preparing magic $|T\rangle$-states dominates both qubit cost and runtime, yet existing tools fix the cultivation gap cutoff and the distillation-factory layout before execution, leaving part of the program's error budget unused. The authors argue that the right cutoff depends on which factories are present, the right factories depend on the cutoff, and both depend on the program's $T$-count and error budget — so these choices should be optimized together rather than set by hand. GP$|T\rangle$-S does this co-optimization, dynamically converting leftover fidelity budget into speed while staying under the total $T$-error budget.

Key Contributions

1. Gap-to-fidelity estimation for cultivation. A lookup table mapping the decoder's complementary gap to the logical error rate of the states a given cutoff would accept, built from the publicly available Stim simulation data of Gidney et al., letting the scheduler estimate a cultivated state's fidelity in constant time.

2. A budget-aware dynamic lattice-surgery scheduler. Instead of a static gap cutoff, the scheduler allocates each $T$ gate a share of the remaining budget, $\varepsilon_{T_i} = \varepsilon_{rem}/(n_T - i)$, and scans gap suffixes to pick the lowest cutoff whose aggregate error rate fits, accepting states a static cutoff would discard and rejecting ones it would pass.

3. A dynamic-programming factory allocator over a characterized catalog. Factories are catalogued by size, $|T\rangle$-state production rate, and budget slack; the allocator returns configurations targeting minimum space-time volume, minimum execution time, or minimum space overhead, then a greedy placement algorithm maps the chosen configuration onto the surface-code topology.

4. Cultivating 15-to-1 factories. A PureMagic-inspired design that runs cultivation inside the factory's ten routing ancilla tiles, reaching fidelities otherwise requiring two-level distillation at a single-level footprint, plus a distance-resolved characterization showing the standard $p_{out} \approx 35p^3$ figure can misestimate output fidelity by orders of magnitude.

Main Findings

• Aggregate speedups across all benchmarks: Across sixteen benchmarks with $T$-counts from $1.4 \times 10^{4}$ to $8.2 \times 10^{5}$ and budgets of $\varepsilon = 10^{-3}$ and $10^{-5}$, GP$|T\rangle$-S beat cultivation-only and single-factory baselines on every benchmark without exceeding the budget, with a 5.5× geometric-mean speedup in logical cycle count and a 3.4× geometric-mean reduction in space-time volume.

• Static cutoffs are expensive: For the default $d_{cult}=5$, $d_{esc}=15$, $p=10^{-3}$ configuration, medians across 11 benchmarks rise 3–9% in cycle count by cutoff $G=60$, 22–48% by $G=80$, and 6.8–9.3× at $G=116$, which corresponds to 59.7 cycles per accepted state versus 6.2 cycles at $G=53$. PureMagic and Gidney et al. use $G=104$.

• Suffix aggregation handles non-monotonicity: Gap and fidelity are not perfectly monotone — the data contain gap values at which no shot errored plus small dips and bumps, likely from finite shot counts at large gaps — so the scheduler scores each candidate cutoff by the aggregate error rate of the whole suffix at or above it rather than by per-gap error rate.

• $35p^3$ is only a large-factory approximation: At $p=10^{-3}$ with $d_m = d_x$, simulated 15-to-1 output infidelity spans nearly five orders of magnitude, from $10^{-3}$ to $1.5 \times 10^{-8}$. The $35p^3 = 3.5 \times 10^{-8}$ figure is approached only for $d_x \geq 17$ and $d_z \geq 7$, where factories land at $1.5$–$4.5 \times 10^{-8}$; at $d_z = 3$, increasing $d_x$ does not improve output at all.

• Many programs are infeasible with cultivation alone: A constrained space-minimizing optimization over nine protocols — cultivation, 15-to-1, 20-to-4, 8-to-CCZ, and cultivation-fed hybrids — shows the space-optimal route to a target fidelity typically mixes several methods at once.

• Cultivating factories reach two-level fidelity at single-level footprint: Table 1 lists cultivating 15-to-1 entries reaching $1.70 \times 10^{-9}$ at $(d_x, d_z, d_{cult}, G) = (19, 11, 3, 40)$ in 372.6 SE cycles over 7167 qubits, down to $2.14 \times 10^{-14}$ at $(29, 13, 3, 60)$ in 537.2 cycles over 14079 qubits. Bare cultivators reach $2.29 \times 10^{-8}$ at $G=100$ in 1522.6 cycles over 449 qubits and $6.78 \times 10^{-9}$ at $G=110$ in 2739.2 cycles.

• Feeding better states into a factory buys little: Cultivate-then-distill output saturates near $10^{-9}$ regardless of how far the input gap cutoff is raised, because at $p=10^{-3}$ idling error inside the factory dominates once inputs are good enough. Within a fixed factory size, extra cutoff should be spent on speed, not fidelity.

• The Heisenberg-36 benchmark motivates the hybrid: It requires $O(10^{5})$ $T$ gates at gridsynth tolerance $10^{-8}$, so even at $\varepsilon = 10^{-3}$ each state may contribute at most roughly $10^{-9}$, an order of magnitude below where standalone 15-to-1 factories saturate (near $10^{-8}$) and reachable by cultivation only at high, slow cutoffs.

• Small-program caveat: The suffix-averaging argument is reliable for $n_T \geq 10^{6}$, but for smaller programs or near the end of execution it may overspend; the authors resolve this by restricting any single consumption that would render the remaining budget infeasible.

Methodology in Plain English

The authors treat magic-state supply as a budgeting problem. Cultivation produces states with a decoder confidence score called the complementary gap; a high gap means the decoder is confident the state is clean. Rather than committing to one cutoff in advance, the scheduler watches how much of the total allowed $T$-error has been spent. It divides the remaining budget evenly over the remaining $T$ gates, looks up the smallest cutoff that meets that per-gate allowance, and accepts any cultivated state clearing it. If early states come in better than needed, the budget drains slowly, the per-gate allowance grows, the cutoff drops, and states arrive faster.

Because cultivation alone tops out around $10^{-10}$ infidelity and needs high cutoffs to get there, the scheduler can also attach 15-to-1 distillation factories to the edges of the layout. The authors first simulate these factories across many code distances to record what each size actually delivers in fidelity and production rate, rather than trusting the $35p^3$ rule of thumb. They add a new factory variant that cultivates its own input states inside the routing channels the factory already has, so no extra ancilla space is needed provided the escape distance does not exceed $\min(d_x, d_z)$. Given this catalog, a dynamic-programming allocator considers each entry, prunes configurations dominated on production rate, budget slack, and size, and returns the best configuration for the chosen objective. A greedy placement step then lays the chosen factories onto the surface-code grid.

Why This Matters

Impact on research: The paper reframes the gap cutoff and factory layout as a single joint optimization instead of two separate design decisions, and shows that the widely quoted $35p^3$ distillation figure is unreliable at the small sizes allocators must actually compare. It also gives a concrete recipe for moving post-selection out of the cultivation protocol and into the scheduler.

Real-world applications (as framed by the paper's benchmarks and scope):

• Quantum chemistry and condensed-matter simulation, represented by the Heisenberg-36 Hamiltonian evolution benchmark requiring $O(10^{5})$ $T$ gates.
• General Clifford+$T$ workloads with $T$-counts between $1.4 \times 10^{4}$ and $8.2 \times 10^{5}$.
• Resource estimation for hardware roadmaps, since the allocator can target minimum space overhead as well as minimum time or space-time volume.
• Architectures using other block-code switching schemes, which the authors state the approach generalizes to via arbitrary factory catalogs.

Industry relevance: Any organization budgeting qubits and logical cycles for a surface-code machine needs to know how many factories to build, how large, and where. This work turns that from a hand-tuned decision into a solver output, and the dynamic-programming allocator reports infeasibility rather than silently overrunning the budget. The paper does not report hardware demonstrations or end-to-end application runs; all results are simulation and modeling.

Future Directions

• Beyond 15-to-1: The catalog in this paper is built around cultivation, 15-to-1, 20-to-4, 8-to-CCZ, and cultivation-fed hybrids; the authors state the allocator supports arbitrary catalogs and other block-code switching schemes, but those catalogs are not evaluated here.

• Budget control for small programs: The suffix-averaging policy is justified for $n_T \geq 10^{6}$ and may overspend for small programs or late in execution; a tighter online policy for those regimes remains open.

• Noisier gap statistics: Finite shot counts at large gaps produce dips and bumps in measured logical error rate, so the gap-to-fidelity lookup table is itself a noisy estimate; how estimation error propagates into scheduling decisions is not reported.

• Placement and physical validation: Placement uses a greedy algorithm, and the paper does not report how far greedy placement falls from optimal, nor how the scheduler behaves against real decoder latency and hardware noise.

Target Audience

Quantum architecture and compilation researchers working on surface-code FTQC, resource-estimation and scheduler developers, and graduate students already comfortable with lattice surgery, Pauli-based computation, cultivation, and distillation. Readers new to magic-state preparation will find the background section useful but should expect the contributions to require prior familiarity with the fault-tolerance literature.

Authors’ abstract

Magic $|T\rangle$-state preparation dominates the cost of fault-tolerant quantum computation on surface codes, yet cultivation and distillation are typically provisioned statically, leaving much of the program's error budget unused. We present Gap-Priced $|T\rangle$ States (GP$|T\rangle$-S), a lattice surgery scheduler and factory allocator that co-optimizes both methods under a total $T$-error budget. GP$|T\rangle$-S uses the complementary gap of each cultivated state as a fidelity estimate and dynamically adjusts the cultivation gap cutoff, converting budget slack into speed by giving the scheduler control over the cultivation post-selection. GP$|T\rangle$-S also characterizes distillation factories by size, $|T\rangle$-state production rate, and budget slack, and introduces cultivating factories that embed cultivation within routing channels, achieving fidelities otherwise requiring two-level distillation at a single-level footprint. GP$|T\rangle$-S organizes these characterizations into a factory catalog, and performs distillation factory allocation over this catalog in tandem with the gap cutoff using dynamic-programming to achieve one of i) minimum spacetime volume, ii) minimum execution time, or iii) minimum space overhead, all within a user-provided $T$-error budget. Across sixteen benchmarks under high and low $T$-error budgets of $10^{-3}$ and $10^{-5}$ respectively, GP$|T\rangle$-S consistently outperforms cultivation-only and single-factory baselines without exceeding the budget, achieving a 5.5$\times$ geometric mean speedup in logical cycle count and a 3.4$\times$ geometric mean reduction in space-time volume.