Fault-tolerant algorithms, run end to end

Shor's algorithm and molecular phase estimation, compiled to Clifford + T + Toffoli and run end to end on a simulated surface-code quantum computer whose every logical error rate was measured by circuit-level simulation. The results are success probabilities as functions of code distance, physical error rate and magic-state source, with error budgets that say which operations make the algorithm fail, and the same error model extrapolated to RSA-2048 and FeMoco.

• Explainer site with a live demo (Shor for N = 15 and H₂ phase estimation running in your browser on WebAssembly): ft.jaspersands.com (source in site/).
• Technical report: report/report.html · PDF. Every number in it is computed from the committed data by tools/report.py.

What is in it

Results

Calibration: 316 circuit-level experiments, 0.82 billion shots. Whole surgery experiments predicted from calibrated parts: 0.93–1.26× the measured failure rate (median 1.04×). Stim + PyMatching cross-check: 36 of 36 within 2.2σ.

Shor (Textbook Cuccaro) (p = 0.1%, cultivated magic states; peak probability = share of runs on one of the r ideal peaks):

Shor (Modern Windowed + MBU) (p = 0.1%, cultivated magic states; 2.6–3.0× fewer Toffolis):

Phase estimation (p = 0.1%, cultivated magic states; success = energy within chemical accuracy, 1.6 mHa, of the exact ground state of the Hamiltonian simulated):

H₂ and HeH⁺ in STO-3G are simulated whole (tapered to 2 qubits). LiH is a deliberately small active space: Li 1s² frozen, two electrons in two CASSCF orbitals, 9 Pauli terms on 2 qubits; its exact energy is 1.3 mHa above full STO-3G FCI at R = 1.595 Å.

RSA-2048, this work's circuits (p = 0.1%, cultivated magic states, E[faults] ≤ 0.1; operation counts exact, schedule fitted on compiled instances, error rates extrapolated):

Published estimates under the measured model (p = 0.1%; each at its authors' failure budget; distances only, since their qubit totals use layouts this model does not include):

Gidney 2025 picks d = 25 because his projection of surface-code memory reaches 1e-15 errors per patch per round there. The measured model (SD6 noise, correlated matching) reaches it at d = 29 (d = 27–29 within the fit's 1σ band). At the measured distances its rates are already 3.4–6.5× his projection, and the gap widens with d because the fitted suppression per two units of distance (Λ = 10.1 and 10.9 for the two bases) is below the projection's 12.25; at d = 25 the fit extrapolates to 1.30e-14 per patch-round (1σ: 9.95e-15–1.70e-14). One shot of his algorithm through the estimator needs d = 29 at his budget (d = 27 at 90%); the same estimator with his projection in place of the measured model returns d = 25. The table below shows how much of that gap is the circuit and noise model rather than his design.

Which memory model? Memories at p = 0.1% under other circuits and noise models, each decoded by correlated matching and fitted the same way (per-round rates from d and 3d rounds), against the projection:

The distance that reaches 1e-15 per patch-round at p = 0.1% runs from d = 23 to d = 29 across these circuit-level models, and Gidney's d = 25 lies inside that range. SI1000, the noise model of the yoked-surface-code paper's simulations (arXiv:2312.04522), has the projection's slope here (Λ = 11.6–12.3) but a 2.1× higher rate at d = 9, and needs d = 27. Gidney 2025 labels the projection uniform depolarizing; Stim's generated circuit with every parameter at p, one reading of that which leaves qubits idle during gate layers noiseless, is below it. The calibration's circuit is the most pessimistic of the four: it depolarizes idle qubits in every layer and measures and resets the ancillas in separate layers, so data qubits idle through two of them each round. Merging them alone lowers the d = 9 rates 1.7–2.0× and raises Λ to ≈ 12, so every result here leans pessimistic by about that. (The SD6 row is the calibration's own memories fitted like the others, over d ≤ 9; with all its memory lengths and d = 11 the calibrated model needs d = 29.)

Recalibrated with one measure-and-reset layer. Every calibration experiment was rerun on the same circuits with each reset layer folded into the measurement layer before it (tools/calibrate.py --mr; data/calibration/raw_mr/, model_mr.json). Idling then has Λ = 11.6–12.5, reaches 1e-15 per patch-round at d = 27 (d = 27 at either 1σ edge), and one shot of Gidney's algorithm needs d = 27 at his budget. The tables above show both calibrations; the simulated algorithm runs (Shor, phase estimation) use the original one.

How it is checked

• ftsim against Qiskit Aer (100 random circuits' amplitudes; exact noisy distributions, plain and stratified), dense against sparse, WebAssembly against native.
• Arithmetic verified on every input by an independent bit-level simulator; Shor's noiseless output against the exact phase-estimation distribution; every synthesized rotation as a matrix.
• Windowed arithmetic verified on every input the same way, including the measurement-based carry uncomputation and its feed-forward CZ fixups.
• Scaling: the Toffoli and qubit counts used at RSA-2048 equal the compiled circuits' for every simulated N; the estimator, given Gidney 2025's own error projection and budget, returns his d = 25.
• Chemistry against PySCF (integrals, HF and FCI to 1e-8 Ha) and Szabo & Ostlund; the LiH active-space Hamiltonian's ground energy equals PySCF's CASSCF(2, 2) to 1e-9 Ha.
• Calibration against Stim + PyMatching; the reference-qubit experiment against plain memories; composition: whole surgery experiments predicted from their parts vs measured.

cargo test --lib --features parallel     # engine
.venv/bin/python -m pytest -q tests      # everything else
node tools/wasm-smoke.mjs                # WebAssembly = native

Reproduce

python3 -m venv .venv && .venv/bin/pip install maturin numpy scipy matplotlib pytest hypothesis \
    stabilizer-qec stim pymatching qiskit qiskit-aer pygridsynth pyscf
tools/build.sh                           # Rust engine → python/ftalgo/_ftsim.abi3.so
.venv/bin/python tools/calibrate.py      # circuit-level experiments (resumable, ~hours)
.venv/bin/python tools/fit_model.py      # data/calibration/model.json
.venv/bin/python tools/compose_check.py && .venv/bin/python tools/xcheck.py
.venv/bin/python tools/noise_models.py && .venv/bin/python tools/noise_models.py --summary   # SI1000, uniform (~1 h)
.venv/bin/python tools/run_shor.py && .venv/bin/python tools/run_shor_modern.py
.venv/bin/python tools/run_qpe.py && .venv/bin/python tools/run_lih.py
.venv/bin/python tools/scale.py && .venv/bin/python tools/sensitivity.py
.venv/bin/python tools/site_data.py && .venv/bin/python tools/report.py && .venv/bin/python tools/readme_tables.py
cargo build --release --target wasm32-unknown-unknown --lib && cp target/wasm32-unknown-unknown/release/ftsim.wasm site/wasm/

Every dataset records its seed and the versions that produced it.

Assumptions

Magic-state error rates and factory footprints (Litinski 2019; Gidney, Shutty & Jones 2024; Gidney 2025), the H and S operation model of the fast-block layout, 1 µs rounds and a 10 µs decoder reaction time are cited inputs, not measured here. Logical channels are measured up to d = 11 (idling) and d = 9 (surgery) at p = 0.1%; runs at larger distances use extrapolated channels and are marked as such, and every RSA-2048 and FeMoco number is an extrapolation. The calibrated circuit is stabilizer-qec's SD6 memory, which measures and resets ancillas in separate layers; with one measure-and-reset layer the same noise errs about half as often at d = 9 (see "Which memory model?"), so results lean pessimistic. See the report's Limitations.

MIT licensed. To cite it, see CITATION.cff.