open-standards/wai/wai-quantum/docs/published-architectures.md

# Published architectures, re-estimated

This page puts published fault-tolerant resource estimates through this crate's
estimators. For each quantity it gives the published figure, ours, the delta
between them, and why they differ. Each estimator gets the source's stated
assumptions (its code, distances, error rates, cycle and reaction times,
factories and logical counts). Nothing is fitted to the figures it is compared
with, with one exception its row names: which end of the line the Ising
program's T factory sits at, which the source does not print.

Every row has one of six classes:

- **agrees**: equal to the digits the source prints;
- **assumption**: we were given, or chose, a different assumption, and the row
  states it;
- **their model**: the source models it differently, and the row says how;
- **their numbers**: the source's own figures disagree with each other or with
  the method it states, and the row says where;
- **our limit**: our estimator does not model this, and the row says what it
  leaves out;
- **open**: not resolved, and the row says what is known.

The published figures are kept apart from the code that computes ours, in
`tests/data/published_figures.tsv`: each with where it is printed, as printed,
its value and its rule. A row that agrees agrees to the digits the source
prints: exactly, to the nearest printed unit, rounded up or down where the
source rounds so, or, for a figure ours takes from the source's fits, within
the range the fits' printed parameters allow. Every other row carries a guard,
our figure to four digits. A test holds every row to its rule, and another holds
the rows below to the example's output, so a change to an estimator that moves
a figure fails until its guard, its reason and this page are updated together.
The resource-estimation workflow runs them in a release build.

```text
cargo run --release --example published_architectures --features full                 # columns
cargo run --release --example published_architectures --features full -- --markdown   # this page's rows
cargo run --release --example published_architectures --features full -- --guards     # ours, for the guards
```

## The sources

A row's source names the section, table or figure where its published figure
is printed. `source files` means the figure is quoted from the paper's arXiv
source (its TeX tables and plot data), which keeps more digits than its PDF
prints; every other figure is quoted with the digits the PDF prints.

- **The bicycle architecture**, arXiv:2506.03094 (2025): the gross `[[144,12,12]]`
  and two-gross `[[288,12,18]]` codes, its Tables 1–3, 5, 6, 9 and 10, §§1.2,
  3.2 and 4, Fig. 9, Fig. 10, Fig. 17 and Appendices A.1, A.2, A.7 and A.10.
  Our model of it is `quantum_bicycle`. Beside it, the same codes' memory
  figures in arXiv:2308.07915, Table 1. Its authors' compiler is released as
  `bicycle_compiler`, `bicycle_cliffords` and `bicycle_common` on crates.io
  (0.1.0 of 2025-07-31); one row below cites its source.
- **RSA-2048 on the surface code**, arXiv:1905.09749 (Quantum 5, 433, 2021): its
  Tables 1 and 3, §§2.10–2.14, and the cost script in its ancillary files. Our
  model of it is `quantum_arch::windowed_factoring_estimate`, and its counts go
  through the estimate job as well.
- **FeMoCo on the surface code**, arXiv:2011.03494 (PRX Quantum 2, 030305,
  2021): its Table III, §IV.C and Fig. 10, on the same factory and clock.
- **RSA-2048 on yoked surface codes**, arXiv:2505.15917 (2025): §3.2, through
  `quantum_arch::factoring_estimate`.
- **The planar model's own source**, arXiv:2211.07629 (2022): Appendix F,
  through `quantum_resource`.

## What it finds

**The bicycle architecture.** Our model reproduces the paper's physical- and
logical-qubit counts exactly, the 24 fitted rates of its Table 10 (each
within the range its fits' printed parameters allow), every failure probability
of its Table 10 from its instruction counts, and its error-rate bounds for the
Ising program. Its other differences are explained in their rows:

- Its four mean compile costs (Fig. 9) come out to every printed digit when a
  shift's action is taken as A on X̄ and A⁻¹ on Z̄, on both halves of a module.
  That is what its authors' released compiler did in `bicycle_cliffords` 0.1.0
  (`src/measurement.rs`). A CNOT circuit |x⟩ → |Ax⟩ takes Z̄ by A⁻ᵀ, which is
  how the operators move, and ours follows the operators; its version 0.2.1
  takes X̄ by A⁻¹ and Z̄ by Aᵀ, a consistent pair. (On the printed basis a shift
  acts as A on the first half and Aᵀ on the second, where the paper says A on
  both; taken as the paper says, with Z̄ by A⁻ᵀ, every cost comes out as ours.)
- Its idle and shift rates are the simulated circuit's failure, undivided,
  where its text says they are divided by the circuit's C cycles. Ours divides,
  as the text says, and that choice is about a third of a point of the gross
  capability at 10⁻³ (its own row).
- Its Ising program takes 15,542,400 T gates in its tables and 19,036,800 in
  its text and Fig. 1. pygridsynth 1.0.1, the version it cites, gives the
  15,542,400 exactly. Our synthesiser also searches the rotations one global
  phase away and takes 6.1% fewer, and no more than pygridsynth on any of the
  angles and precisions its tests compare.
- Its gross Ising machine of 4,817 qubits takes the adapter of the 10⁻³
  factory beside the 10⁻⁴ factory it names (4,801).
- The Ising program's inter-module measurements match its 946,800 with the
  factory after the last module; before the first, 781,200. The paper prints
  neither: this is the one choice here made to fit a published figure.

Two differences are open. Its gross capabilities at 10⁻⁴ need a failure per
rotation of 8.3·10⁻⁷ that does not depend on the machine's size, where its
factory's printed error is 4·10⁻⁸; its released compiler's capability estimate
at those machines would settle it, and this check does not run third-party
code. And the earlier paper's memory rate for the same codes, arXiv:2308.07915,
is about 1,250 times the later's fit at the same p: their decoders, circuits and
fitting differ, and which accounts for it is not found here.

**RSA-2048 (2021).** The re-run of its cost script reproduces every row of its
Table 3 to the digits it prints, which it takes up to two, and its Table 1's
Toffoli count. Its title's 8 hours is the re-run's 7.31 hours expected across
retries, taken up to one digit. Its hand-worked §2.14 (23 million qubits)
rounds as it goes and says so. Its §2.12 reads a 6.4% distillation error from
an earlier paper's spreadsheet where its own script's formula gives 0.6%. Our
estimate job, given the same counts, finds the same code distance on its
default step clock, three logical steps of `d` cycles a Toffoli as the planar
model of arXiv:2211.07629 has it, and takes 12 times as long. On its
reaction-limited clock at the paper's 10 µs, the rule `quantum_arch` takes, it
takes 7.50 hours at d = 25: every Toffoli after the one before. The paper does
not run them so, and counts alone do not carry how it does (**our limit**): its
5.1 hours and its §2.11 "approximately 7 hours" are one parallel basis, 37 ms a
lookup addition, with its two runway pieces' additions side by side and its
lookups at half a beat an entry. §2.11 reaches 7 by rounding its lookup additions
up to 0.1·n_e·n and then 3.7·n_e·n ms up to 4·n_e·n; 37 ms on the unrounded count
is 5.18 hours. The paper prints no serial figure. Its equations, at 10 µs a
Toffoli one after another, give 7.3 hours, a figure of ours, not the paper's. The
job's 20.05 million qubits are near the paper's 20 million by chance: 129 T
factories at d = 25, not its CCZ factories at d = 27.

**FeMoCo.** Its floorplan, factory, Toffoli rate and 3 days come back on the
same clock; its §IV.C.5 says 3.5 days where §IV.C.4 says 3. The estimate job
runs at the beat on its step clock; on its reaction-limited clock it keeps
enough T factories to tick at 10 µs, 0.78 days on 10.8 million qubits, where the
paper's four CCZ factories set its pace at 38.75 µs. Most of that factory count
is the kind of factory, not the tick: at the paper's 38.75 µs the job keeps 41
of its 15-to-1 units, each about ten times slower to a CCZ state than the
paper's.

**RSA-2048 (2025).** As `quantum_arch` documents: its stated durations give
10.6 hours a shot where it prints 12.07, its hot-storage counts disagree with
its own formula, and so on. Its Toffoli count comes back.

**The planar model's source** comes back whole.

## What this does not do

- **The estimate job runs every Toffoli after the one before.** On either
  clock it reads no Toffoli depth, so a program whose Toffolis run side by side
  takes less time than it gives.
- **The bicycle machine is not scheduled.** A rotation's time is the mean of
  its parts, a few percent under the paper's compiled critical path, and
  repeated in-module measurements are not removed.
- **The bicycle rates are the paper's.** No decoder here has run its
  instructions; its fits extrapolate far below what any simulation reaches,
  and its two-gross measurement rates are assumed without data.
- **No third-party code runs here.** The paper's released compiler would
  settle the open gross rows.

## The rows

<!-- the rows: written by `--example published_architectures --markdown`; a test holds them -->

### The bicycle machine: its parts

| Quantity | Source | Published | Ours | Delta | Class | Why |
|---|---|---:|---:|---:|---|---|
| gross: code block `c`, by `2n` | arXiv:2506.03094 Table 1 | 288 | 288 | 0 | agrees |  |
| gross: processing unit `u`, as tallied | arXiv:2506.03094 Table 1 | 90 | 90 | 0 | agrees |  |
| gross: adapter `a`, by `2(d−1)` | arXiv:2506.03094 Table 1 | 22 | 22 | 0 | agrees |  |
| two-gross: code block `c`, by `2n` | arXiv:2506.03094 Table 1 | 576 | 576 | 0 | agrees |  |
| two-gross: processing unit `u`, as tallied | arXiv:2506.03094 Table 1 | 158 | 158 | 0 | agrees |  |
| two-gross: adapter `a`, by `2(d−1)` | arXiv:2506.03094 Table 1 | 34 | 34 | 0 | agrees |  |
| 10⁻³ gross factory: adapter `a′`, by `2d−1` | arXiv:2506.03094 Table 3 | 29 | 29 | 0 | agrees |  |
| 10⁻³ two-gross factory: adapter `a′`, by `2d−1` | arXiv:2506.03094 Table 3 | 29 | 29 | 0 | agrees |  |
| 10⁻⁴ gross factory: adapter `a′`, by `2d−1` | arXiv:2506.03094 Table 3 | 13 | 13 | 0 | agrees |  |
| 10⁻⁴ two-gross factory: adapter `a′`, by `2d−1` | arXiv:2506.03094 Table 3 | 49 | 49 | 0 | agrees |  |
| logical qubits in 5,000 physical qubits, gross, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a) | 121 | 121 | 0 | agrees |  |
| logical qubits in 50,000 physical qubits, two-gross, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a) | 704 | 704 | 0 | agrees |  |
| logical qubits in 5,000 physical qubits, gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a) | 110 | 110 | 0 | agrees |  |
| logical qubits in 50,000 physical qubits, gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a) | 1,342 | 1,342 | 0 | agrees |  |
| logical qubits in 50,000 physical qubits, two-gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a) | 440 | 440 | 0 | agrees |  |
| logical qubits in 500,000 physical qubits, two-gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a) | 6,886 | 6,886 | 0 | agrees |  |

### The bicycle machine: logical error rates

| Quantity | Source | Published | Ours | Delta | Class | Why |
|---|---|---:|---:|---:|---|---|
| gross `P_I` at p = 10⁻³ | arXiv:2506.03094 Table 10 | 1.6·10⁻⁹ | 1.61e-9 | +0.36% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_U` at p = 10⁻³ | arXiv:2506.03094 Table 10 | 4.0·10⁻⁷ | 4.01e-7 | +0.22% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_M` at p = 10⁻³ | arXiv:2506.03094 Table 10 | 1.1·10⁻⁵ | 1.11e-5 | +0.72% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_C` at p = 10⁻³ | arXiv:2506.03094 Table 10 | 2.0·10⁻³ | 2.01e-3 | +0.66% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_I` at p = 10⁻⁴ | arXiv:2506.03094 Table 10 | 1.4·10⁻¹⁵ | 1.44e-15 | +2.93% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_U` at p = 10⁻⁴ | arXiv:2506.03094 Table 10 | 6.1·10⁻¹³ | 6.07e-13 | -0.45% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_M` at p = 10⁻⁴ | arXiv:2506.03094 Table 10 | 1.0·10⁻⁹ | 1.01e-9 | +1.43% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_C` at p = 10⁻⁴ | arXiv:2506.03094 Table 10 | 4.8·10⁻⁸ | 4.81e-8 | +0.24% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_I` at p = 5·10⁻⁵ | arXiv:2506.03094 Table 10 | 4.5·10⁻¹⁷ | 4.46e-17 | -0.99% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_U` at p = 5·10⁻⁵ | arXiv:2506.03094 Table 10 | 2.2·10⁻¹⁴ | 2.16e-14 | -1.63% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_M` at p = 5·10⁻⁵ | arXiv:2506.03094 Table 10 | 5.7·10⁻¹¹ | 5.74e-11 | +0.70% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_C` at p = 5·10⁻⁵ | arXiv:2506.03094 Table 10 | 2.8·10⁻⁹ | 2.79e-9 | -0.41% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_I` at p = 3·10⁻⁵ | arXiv:2506.03094 Table 10 | 3.5·10⁻¹⁸ | 3.54e-18 | +1.02% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_U` at p = 3·10⁻⁵ | arXiv:2506.03094 Table 10 | 1.9·10⁻¹⁵ | 1.92e-15 | +0.92% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_M` at p = 3·10⁻⁵ | arXiv:2506.03094 Table 10 | 5.9·10⁻¹² | 5.90e-12 | +0.07% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_C` at p = 3·10⁻⁵ | arXiv:2506.03094 Table 10 | 3.2·10⁻¹⁰ | 3.18e-10 | -0.73% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_I` at p = 10⁻⁵ | arXiv:2506.03094 Table 10 | 1.5·10⁻²⁰ | 1.51e-20 | +0.62% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_U` at p = 10⁻⁵ | arXiv:2506.03094 Table 10 | 9.5·10⁻¹⁸ | 9.53e-18 | +0.29% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_M` at p = 10⁻⁵ | arXiv:2506.03094 Table 10 | 3.3·10⁻¹⁴ | 3.29e-14 | -0.28% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross `P_C` at p = 10⁻⁵ | arXiv:2506.03094 Table 10 | 2.1·10⁻¹² | 2.10e-12 | +0.03% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| two-gross `P_I` at p = 10⁻³ | arXiv:2506.03094 Table 10 | 8.2·10⁻²¹ | 8.13e-21 | -0.84% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| two-gross `P_U` at p = 10⁻³ | arXiv:2506.03094 Table 10 | 3.3·10⁻¹⁵ | 3.24e-15 | -1.71% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| two-gross `P_I` at p = 10⁻⁴ | arXiv:2506.03094 Table 10 | 5.4·10⁻³⁹ | 5.39e-39 | -0.23% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| two-gross `P_U` at p = 10⁻⁴ | arXiv:2506.03094 Table 10 | 1.3·10⁻³⁷ | 1.34e-37 | +3.07% | agrees | Ours evaluates Table 6's fits by Eq. (83); the band is ours with their parameters at the ends of their last printed digit. |
| gross idle, one syndrome cycle, p = 10⁻³ | arXiv:2506.03094 §A.7 against Table 2 | 10^−8.8 | 1.61e-10 | ×0.101 | their numbers | §A.7 says an idle's or a shift's rate is the simulated circuit's failure divided by its C cycles. Table 2 and Table 10 print the circuit's failure undivided: Table 6's fits give them so. Ours divides, as the text says, and is lower by C (10 for gross, 18 for two-gross). |
| two-gross idle, one syndrome cycle, p = 10⁻³ | arXiv:2506.03094 §A.7 against Table 2 | 10^−20.1 | 4.52e-22 | ×0.057 | their numbers | §A.7 says an idle's or a shift's rate is the simulated circuit's failure divided by its C cycles. Table 2 and Table 10 print the circuit's failure undivided: Table 6's fits give them so. Ours divides, as the text says, and is lower by C (10 for gross, 18 for two-gross). |
| gross automorphism, p = 10⁻³ | arXiv:2506.03094 §A.7 against Table 2 | 10^−6.4 | 4.01e-8 | ×0.101 | their numbers | §A.7 says an idle's or a shift's rate is the simulated circuit's failure divided by its C cycles. Table 2 and Table 10 print the circuit's failure undivided: Table 6's fits give them so. Ours divides, as the text says, and is lower by C (10 for gross, 18 for two-gross). |
| gross memory per cycle, p = 10⁻³ | arXiv:2308.07915 Table 1, against arXiv:2506.03094 §A.7 | 2·10⁻⁷ | 1.61e-10 | ×8.0e-4 | open | Two papers on the same code at the same p. The earlier (decoded by BP-OSD) measures 2·10⁻⁷ a syndrome cycle for the gross code at 10⁻³; the later's fits (Relay-BP) give a circuit of C idle cycles, divided by C as its text says, 1.61e-10: a factor of about 1,246 (about 125 undivided). Their decoders, circuits and fitting differ, and which accounts for the factor is not found here. Ours takes the later's fits. |
| gross memory per cycle, p = 10⁻⁴ | arXiv:2308.07915 Table 1, against arXiv:2506.03094 §A.7 | 8·10⁻¹³ | 1.44e-16 | ×1.8e-4 | open | Two papers on the same code at the same p. The earlier (decoded by BP-OSD) measures 2·10⁻⁷ a syndrome cycle for the gross code at 10⁻³; the later's fits (Relay-BP) give a circuit of C idle cycles, divided by C as its text says, 1.61e-10: a factor of about 1,246 (about 125 undivided). Their decoders, circuits and fitting differ, and which accounts for the factor is not found here. Ours takes the later's fits. |
| two-gross memory per cycle, p = 10⁻³ | arXiv:2308.07915 Table 1, against arXiv:2506.03094 §A.7 | 2·10⁻¹² | 4.52e-22 | ×2.3e-10 | open | Two papers on the same code at the same p. The earlier (decoded by BP-OSD) measures 2·10⁻⁷ a syndrome cycle for the gross code at 10⁻³; the later's fits (Relay-BP) give a circuit of C idle cycles, divided by C as its text says, 1.61e-10: a factor of about 1,246 (about 125 undivided). Their decoders, circuits and fitting differ, and which accounts for the factor is not found here. Ours takes the later's fits. |
| two-gross memory per cycle, p = 10⁻⁴ | arXiv:2308.07915 Table 1, against arXiv:2506.03094 §A.7 | 1·10⁻²² | 2.99e-40 | ×3.0e-18 | open | Two papers on the same code at the same p. The earlier (decoded by BP-OSD) measures 2·10⁻⁷ a syndrome cycle for the gross code at 10⁻³; the later's fits (Relay-BP) give a circuit of C idle cycles, divided by C as its text says, 1.61e-10: a factor of about 1,246 (about 125 undivided). Their decoders, circuits and fitting differ, and which accounts for the factor is not found here. Ours takes the later's fits. |

### The bicycle machine: the compile

| Quantity | Source | Published | Ours | Delta | Class | Why |
|---|---|---:|---:|---:|---|---|
| native measurements | arXiv:2506.03094 §3.2 | 540 | 540 | 0 | agrees |  |
| any shift, in generators, at most | arXiv:2506.03094 §1.2 | 2 | 2 | 0 | agrees |  |
| native rotations | arXiv:2506.03094 §3.2 | 510 | 245 | ×0.480 | their numbers | §3.2 defines a native rotation by a native measurement Q ⊗ R with Q one of X, Y, Z on the pivot: there are 245 such R. Over all the native measurements there are 510 distinct R ≠ I: 284 occur with Q = I, 19 of them also with Q ≠ I. That its 510 counts those is our inference from the matching count. Fig. 9's first bin holds 245. |
| mean in-module measurements per Pauli, pivot basis chosen, gross | arXiv:2506.03094 Fig. 9 caption, right | 18.48 | 18.526 | +0.25% | their numbers | Our search runs from the printed polynomials, basis and native set, over the 4¹¹ − 1 Paulis (4¹² − 1 with the pivot fixed). The authors' released compiler, bicycle_cliffords 0.1.0 (crates.io, 2025-07-31), takes a shift's action in src/measurement.rs as A on X̄ and A⁻¹ on Z̄, on both halves of a module; taken so, our search gives the source's four means to every printed digit (a test in quantum_bicycle holds this). A CNOT circuit |x⟩ → |Ax⟩ takes Z̄ by A⁻ᵀ, which is how the operators move and what ours follows; its version 0.2.1 takes X̄ by A⁻¹ and Z̄ by Aᵀ, a consistent pair. The difference moves a capability here by under 0.6%. |
| the same, two-gross | arXiv:2506.03094 Fig. 9 caption, right | 18.58 | 18.482 | -0.53% | their numbers | Our search runs from the printed polynomials, basis and native set, over the 4¹¹ − 1 Paulis (4¹² − 1 with the pivot fixed). The authors' released compiler, bicycle_cliffords 0.1.0 (crates.io, 2025-07-31), takes a shift's action in src/measurement.rs as A on X̄ and A⁻¹ on Z̄, on both halves of a module; taken so, our search gives the source's four means to every printed digit (a test in quantum_bicycle holds this). A CNOT circuit |x⟩ → |Ax⟩ takes Z̄ by A⁻ᵀ, which is how the operators move and what ours follows; its version 0.2.1 takes X̄ by A⁻¹ and Z̄ by Aᵀ, a consistent pair. The difference moves a capability here by under 0.6%. |
| mean in-module measurements per Pauli, pivot basis fixed, gross | arXiv:2506.03094 Fig. 9 caption, left | 18.55 | 18.593 | +0.23% | their numbers | Our search runs from the printed polynomials, basis and native set, over the 4¹¹ − 1 Paulis (4¹² − 1 with the pivot fixed). The authors' released compiler, bicycle_cliffords 0.1.0 (crates.io, 2025-07-31), takes a shift's action in src/measurement.rs as A on X̄ and A⁻¹ on Z̄, on both halves of a module; taken so, our search gives the source's four means to every printed digit (a test in quantum_bicycle holds this). A CNOT circuit |x⟩ → |Ax⟩ takes Z̄ by A⁻ᵀ, which is how the operators move and what ours follows; its version 0.2.1 takes X̄ by A⁻¹ and Z̄ by Aᵀ, a consistent pair. The difference moves a capability here by under 0.6%. |
| the same, two-gross | arXiv:2506.03094 Fig. 9 caption, left | 18.67 | 18.561 | -0.58% | their numbers | Our search runs from the printed polynomials, basis and native set, over the 4¹¹ − 1 Paulis (4¹² − 1 with the pivot fixed). The authors' released compiler, bicycle_cliffords 0.1.0 (crates.io, 2025-07-31), takes a shift's action in src/measurement.rs as A on X̄ and A⁻¹ on Z̄, on both halves of a module; taken so, our search gives the source's four means to every printed digit (a test in quantum_bicycle holds this). A CNOT circuit |x⟩ → |Ax⟩ takes Z̄ by A⁻ᵀ, which is how the operators move and what ours follows; its version 0.2.1 takes X̄ by A⁻¹ and Z̄ by Aᵀ, a consistent pair. The difference moves a capability here by under 0.6%. |

### The bicycle machine: what a machine of a given size can run

| Quantity | Source | Published | Ours | Delta | Class | Why |
|---|---|---:|---:|---:|---|---|
| T count at failure ⅓, 5,000 physical qubits, gross, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), source files | 13.5958 | 1.365e1 | +0.42% | assumption | Ours divides P_I and P_U by C, as §A.7's text says (the rates section); with them undivided, as Table 10 prints them, ours is 1.361e1 (next row). That choice is +0.30% of the difference, and the sampling below +0.12%. |
| the same, P_I and P_U undivided, as Table 10 prints them, 5,000 physical qubits, gross, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), source files | 13.5958 | 1.361e1 | +0.12% | their model | Theirs samples eight random circuits of up to 10⁵ rotations and extends a straight-line fit (Fig. 17); ours is the expected count, at the rates as the tables print them. |
| timesteps per T, 5,000 physical qubits, gross, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), source files | 3367.15 | 3190.77 | -5.24% | our limit | Theirs is the critical path of a compiled schedule; ours adds the mean time of a rotation's parts, with no scheduling. Ours runs a few percent low, more where a compiler takes more shifts than the fewest. |
| T count at failure ⅓, 50,000 physical qubits, two-gross, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), source files | 3.4712·10⁶ | 3.478e6 | +0.21% | their model | Theirs samples eight random circuits of up to 10⁵ rotations and extends a straight-line fit (Fig. 17); ours is the expected count, at the rates as the tables print them. Our division of P_I and P_U by C, as §A.7's text says, is +0.00% of it (next row: undivided). |
| the same, P_I and P_U undivided, as Table 10 prints them, 50,000 physical qubits, two-gross, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), source files | 3.4712·10⁶ | 3.478e6 | +0.20% | their model | Theirs samples eight random circuits of up to 10⁵ rotations and extends a straight-line fit (Fig. 17); ours is the expected count, at the rates as the tables print them. |
| timesteps per T, 50,000 physical qubits, two-gross, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), source files | 7057.34 | 7060.97 | +0.05% | our limit | Theirs is the critical path of a compiled schedule; ours adds the mean time of a rotation's parts, with no scheduling. Ours runs a few percent low, more where a compiler takes more shifts than the fewest. |
| T count at failure ⅓, 5,000 physical qubits, gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 2.2209·10⁵ | 4.701e5 | ×2.117 | open | Its two gross rows at this p need a failure per rotation of 6.70·10⁻⁸ per module (ours: 6.69·10⁻⁸) plus 8.3·10⁻⁷ whatever the machine's size. Ours has 4·10⁻⁸ there: Table 3's factory, an injection's inter-module measurement and one link fewer. Nothing the paper prints accounts for the other 7.9·10⁻⁷. Its authors' compiler is released (bicycle_compiler 0.1.0 on crates.io): its capability estimate at these two machines would settle it; this check does not run it. |
| the same, P_I and P_U undivided, as Table 10 prints them, 5,000 physical qubits, gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 2.2209·10⁵ | 4.700e5 | ×2.116 | open | Its two gross rows at this p need a failure per rotation of 6.70·10⁻⁸ per module (ours: 6.69·10⁻⁸) plus 8.3·10⁻⁷ whatever the machine's size. Ours has 4·10⁻⁸ there: Table 3's factory, an injection's inter-module measurement and one link fewer. Nothing the paper prints accounts for the other 7.9·10⁻⁷. Its authors' compiler is released (bicycle_compiler 0.1.0 on crates.io): its capability estimate at these two machines would settle it; this check does not run it. |
| timesteps per T, 5,000 physical qubits, gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 3090.55 | 2912.77 | -5.75% | our limit | Theirs is the critical path of a compiled schedule; ours adds the mean time of a rotation's parts, with no scheduling. Ours runs a few percent low, more where a compiler takes more shifts than the fewest. |
| T count at failure ⅓, 50,000 physical qubits, gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 3.7033·10⁴ | 4.064e4 | +9.73% | open | Its two gross rows at this p need a failure per rotation of 6.70·10⁻⁸ per module (ours: 6.69·10⁻⁸) plus 8.3·10⁻⁷ whatever the machine's size. Ours has 4·10⁻⁸ there: Table 3's factory, an injection's inter-module measurement and one link fewer. Nothing the paper prints accounts for the other 7.9·10⁻⁷. Its authors' compiler is released (bicycle_compiler 0.1.0 on crates.io): its capability estimate at these two machines would settle it; this check does not run it. |
| the same, P_I and P_U undivided, as Table 10 prints them, 50,000 physical qubits, gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 3.7033·10⁴ | 4.063e4 | +9.71% | open | Its two gross rows at this p need a failure per rotation of 6.70·10⁻⁸ per module (ours: 6.69·10⁻⁸) plus 8.3·10⁻⁷ whatever the machine's size. Ours has 4·10⁻⁸ there: Table 3's factory, an injection's inter-module measurement and one link fewer. Nothing the paper prints accounts for the other 7.9·10⁻⁷. Its authors' compiler is released (bicycle_compiler 0.1.0 on crates.io): its capability estimate at these two machines would settle it; this check does not run it. |
| timesteps per T, 50,000 physical qubits, gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 3135.16 | 2912.77 | -7.09% | our limit | Theirs is the critical path of a compiled schedule; ours adds the mean time of a rotation's parts, with no scheduling. Ours runs a few percent low, more where a compiler takes more shifts than the fewest. |
| T count at failure ⅓, 50,000 physical qubits, two-gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 7.0154·10¹⁵ | 7.033e15 | +0.26% | their model | Theirs samples eight random circuits of up to 10⁵ rotations and extends a straight-line fit (Fig. 17); ours is the expected count, at the rates as the tables print them. Our division of P_I and P_U by C, as §A.7's text says, is +0.00% of it (next row: undivided). |
| the same, P_I and P_U undivided, as Table 10 prints them, 50,000 physical qubits, two-gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 7.0154·10¹⁵ | 7.033e15 | +0.26% | their model | Theirs samples eight random circuits of up to 10⁵ rotations and extends a straight-line fit (Fig. 17); ours is the expected count, at the rates as the tables print them. |
| timesteps per T, 50,000 physical qubits, two-gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 5435.87 | 5300.97 | -2.48% | our limit | Theirs is the critical path of a compiled schedule; ours adds the mean time of a rotation's parts, with no scheduling. Ours runs a few percent low, more where a compiler takes more shifts than the fewest. |
| T count at failure ⅓, 500,000 physical qubits, two-gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 4.4830·10¹⁴ | 4.494e14 | +0.25% | their model | Theirs samples eight random circuits of up to 10⁵ rotations and extends a straight-line fit (Fig. 17); ours is the expected count, at the rates as the tables print them. Our division of P_I and P_U by C, as §A.7's text says, is +0.00% of it (next row: undivided). |
| the same, P_I and P_U undivided, as Table 10 prints them, 500,000 physical qubits, two-gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 4.4830·10¹⁴ | 4.494e14 | +0.25% | their model | Theirs samples eight random circuits of up to 10⁵ rotations and extends a straight-line fit (Fig. 17); ours is the expected count, at the rates as the tables print them. |
| timesteps per T, 500,000 physical qubits, two-gross, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), source files | 5436.91 | 5300.97 | -2.50% | our limit | Theirs is the critical path of a compiled schedule; ours adds the mean time of a rotation's parts, with no scheduling. Ours runs a few percent low, more where a compiler takes more shifts than the fewest. |
| surface code: logical qubits, 5,000 qubits, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), §A.10 | 45 | 45 | 0 | agrees |  |
| surface code: T count, its formula, 5,000 qubits, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), §A.10 | 7 | 7 | 0 | agrees | §A.10's formula for the surface-code row, evaluated as it states it: the largest whole T count. |
| surface code: T count, our code model, 5,000 qubits, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), §A.10 | 7 | 1.23e2 | ×17.637 | their model | Our planar model takes `0.03·(p/p*)^((d+1)/2)` per patch per `d` cycles, as arXiv:2211.07629 does. §A.10 takes `0.03·(p/p*)^(d/2)` per cycle, times `d` cycles: higher by `d·√(p*/p)`. |
| surface code: timesteps per T, 5,000 qubits, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a) | 381 | 381 | 0 | agrees | §A.10: the factory's timesteps (Table 3) and the lattice surgery's 6d. |
| surface code: logical qubits, 50,000 qubits, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), §A.10 | 42 | 42 | 0 | agrees |  |
| surface code: T count, its formula, 50,000 qubits, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), §A.10 | 2.5·10⁶ | 2.46e6 | -1.58% | agrees | §A.10's formula for the surface-code row, evaluated as it states it: the largest whole T count. |
| surface code: T count, our code model, 50,000 qubits, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a), §A.10 | 2.5·10⁶ | 1.32e8 | ×52.910 | their model | Our planar model takes `0.03·(p/p*)^((d+1)/2)` per patch per `d` cycles, as arXiv:2211.07629 does. §A.10 takes `0.03·(p/p*)^(d/2)` per cycle, times `d` cycles: higher by `d·√(p*/p)`. |
| surface code: timesteps per T, 50,000 qubits, p = 10⁻³ | arXiv:2506.03094 Fig. 10(a) | 2,269 | 2,269 | 0 | agrees | §A.10: the factory's timesteps (Table 3) and the lattice surgery's 6d. |
| surface code: logical qubits, 5,000 qubits, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), §A.10 | 21 | 21 | 0 | agrees |  |
| surface code: T count, its formula, 5,000 qubits, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), §A.10 | 377,928 | 377,928 | 0 | agrees | §A.10's formula for the surface-code row, evaluated as it states it: the largest whole T count. |
| surface code: T count, our code model, 5,000 qubits, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a), §A.10 | 377,928 | 2.65e7 | ×70.000 | their model | Our planar model takes `0.03·(p/p*)^((d+1)/2)` per patch per `d` cycles, as arXiv:2211.07629 does. §A.10 takes `0.03·(p/p*)^(d/2)` per cycle, times `d` cycles: higher by `d·√(p*/p)`. |
| surface code: timesteps per T, 5,000 qubits, p = 10⁻⁴ | arXiv:2506.03094 Fig. 10(a) | 115 | 115 | 0 | agrees | §A.10: the factory's timesteps (Table 3) and the lattice surgery's 6d. |
| surface code: logical qubits, 50,000 qubits, p = 10⁻⁴, d = 7 | arXiv:2506.03094 Fig. 10(a), §A.10 | 250 | 250 | 0 | agrees |  |
| surface code: T count, its formula, 50,000 qubits, p = 10⁻⁴, d = 7 | arXiv:2506.03094 Fig. 10(a), §A.10 | 31,746 | 31,746 | 0 | agrees | §A.10's formula for the surface-code row, evaluated as it states it: the largest whole T count. |
| surface code: T count, our code model, 50,000 qubits, p = 10⁻⁴, d = 7 | arXiv:2506.03094 Fig. 10(a), §A.10 | 31,746 | 2.22e6 | ×70.000 | their model | Our planar model takes `0.03·(p/p*)^((d+1)/2)` per patch per `d` cycles, as arXiv:2211.07629 does. §A.10 takes `0.03·(p/p*)^(d/2)` per cycle, times `d` cycles: higher by `d·√(p*/p)`. |
| surface code: timesteps per T, 50,000 qubits, p = 10⁻⁴, d = 7 | arXiv:2506.03094 Fig. 10(a) | 115 | 115 | 0 | agrees | §A.10: the factory's timesteps (Table 3) and the lattice surgery's 6d. |
| surface code: logical qubits, 50,000 qubits, p = 10⁻⁴, d = 17 | arXiv:2506.03094 Fig. 10(a), §A.10 | 27 | 27 | 0 | agrees |  |
| surface code: T count, its formula, 50,000 qubits, p = 10⁻⁴, d = 17 | arXiv:2506.03094 Fig. 10(a), §A.10 | 1.2·10¹⁵ | 1.21e15 | +0.86% | agrees | §A.10's formula for the surface-code row, evaluated as it states it: the largest whole T count. |
| surface code: T count, our code model, 50,000 qubits, p = 10⁻⁴, d = 17 | arXiv:2506.03094 Fig. 10(a), §A.10 | 1.2·10¹⁵ | 2.06e17 | ×1.7e2 | their model | Our planar model takes `0.03·(p/p*)^((d+1)/2)` per patch per `d` cycles, as arXiv:2211.07629 does. §A.10 takes `0.03·(p/p*)^(d/2)` per cycle, times `d` cycles: higher by `d·√(p*/p)`. |
| surface code: timesteps per T, 50,000 qubits, p = 10⁻⁴, d = 17 | arXiv:2506.03094 Fig. 10(a) | 509 | 509 | 0 | agrees | §A.10: the factory's timesteps (Table 3) and the lattice surgery's 6d. |
| surface code: logical qubits, 500,000 qubits, p = 10⁻⁴, d = 17 | arXiv:2506.03094 Fig. 10(a), §A.10 | 416 | 416 | 0 | agrees |  |
| surface code: T count, its formula, 500,000 qubits, p = 10⁻⁴, d = 17 | arXiv:2506.03094 Fig. 10(a), §A.10 | 7.9·10¹³ | 7.86e13 | -0.56% | agrees | §A.10's formula for the surface-code row, evaluated as it states it: the largest whole T count. |
| surface code: T count, our code model, 500,000 qubits, p = 10⁻⁴, d = 17 | arXiv:2506.03094 Fig. 10(a), §A.10 | 7.9·10¹³ | 1.34e16 | ×1.7e2 | their model | Our planar model takes `0.03·(p/p*)^((d+1)/2)` per patch per `d` cycles, as arXiv:2211.07629 does. §A.10 takes `0.03·(p/p*)^(d/2)` per cycle, times `d` cycles: higher by `d·√(p*/p)`. |
| surface code: timesteps per T, 500,000 qubits, p = 10⁻⁴, d = 17 | arXiv:2506.03094 Fig. 10(a) | 509 | 509 | 0 | agrees | §A.10: the factory's timesteps (Table 3) and the lattice surgery's 6d. |

### The bicycle machine: the 10 × 10 Ising model

| Quantity | Source | Published | Ours | Delta | Class | Why |
|---|---|---:|---:|---:|---|---|
| physical qubits, two-gross | arXiv:2506.03094 §4 | 8,138 | 8,138 | 0 | agrees |  |
| physical qubits, gross | arXiv:2506.03094 §4 | 4,817 | 4,801 | -0.33% | their numbers | §4 names the 10⁻⁴ gross factory, whose adapter is 13 qubits (Table 3). 4,817 takes the 29 of the 10⁻³ factory. |
| rotations | arXiv:2506.03094 §A.10 | 184,000 | 184,000 | 0 | agrees |  |
| inter-module measurements `N_C`, gross | arXiv:2506.03094 Table 9 | 9.4680·10⁵ | 946,800 | 0 | assumption | Sites in order and the factory after the last module give the paper's count; before the first module, 781,200. The paper prints neither, and this is the end chosen to match it: the one choice in this check made to fit a published figure. |
| the same on two-gross | arXiv:2506.03094 Table 9 | 9.4680·10⁵ | 946,800 | 0 | assumption | Sites in order and the factory after the last module give the paper's count; before the first module, 781,200. The paper prints neither, and this is the end chosen to match it: the one choice in this check made to fit a published figure. |
| in-module measurements `N_M`, gross | arXiv:2506.03094 Table 9, source files | 4,215,240 | 4,283,200 | +1.61% | our limit | Ours removes no repeated in-module measurement, which theirs does (§4), and takes sites in order, which it does not print. Its counts also carry the compile section's action of a shift on Z̄, which puts its gross below its two-gross; ours has them the other way round. |
| in-module measurements `N_M`, two-gross | arXiv:2506.03094 Table 9, source files | 4,238,828 | 4,148,800 | -2.12% | our limit | Ours removes no repeated in-module measurement, which theirs does (§4), and takes sites in order, which it does not print. Its counts also carry the compile section's action of a shift on Z̄, which puts its gross below its two-gross; ours has them the other way round. |
| automorphisms `N_U`, gross | arXiv:2506.03094 Table 9, source files | 2,270,400 | 2,728,800 | +20.19% | our limit | Ours takes the fewest shifts on a path of fewest measurements, and merges none; theirs is a compiler's. |
| automorphisms `N_U`, two-gross | arXiv:2506.03094 Table 9, source files | 2,294,400 | 2,368,000 | +3.21% | our limit | Ours takes the fewest shifts on a path of fewest measurements, and merges none; theirs is a compiler's. |
| T injections `N_T` | arXiv:2506.03094 Table 9, source files | 15,542,400 | 14,592,000 | -6.11% | their model | pygridsynth 1.0.1, the version the source cites, run on the program's four angles at ε = 5·10⁻⁹, gives 86, 80, 84 and 82 T gates, which make 15,542,400 exactly; it approximates the rotation itself. Ours, the same Ross–Selinger method, gives 79, 80, 79 and 82: it also searches the class one global phase e^(iπ/8) away, which a rotation of the pivot allows, and of the solver's solution of the norm equation and its unit multiples it keeps the one whose operator takes the fewest T gates. It takes no more than the reference on any of 1,192 angles and precisions (engine::synth::rz's tests). |
| T injections as §4 and Fig. 1(b) state | arXiv:2506.03094 §4; Fig. 1(b), source files | 1.9·10⁷ (Fig. 1(b): 19,036,800) | 14,592,000 | -23.35% | their numbers | §4 says N_T = 1.9·10⁷ and Fig. 1(b) plots 19,036,800. Table 9 and every failure probability of Table 10 take 15,542,400, which the row above compares ours with. |
| idles `N_I`, two-gross, from its `N_T` | arXiv:2506.03094 Table 9, source files | 41,636,714,298 | 42,100,476,000 | +1.11% | our limit | Ours: every module idles while the factory works, and otherwise never. Theirs counts the idles of its schedule. |
| failure probability, gross, p = 10⁻³, its counts | arXiv:2506.03094 Table 10 | 3.33·10⁴ | 3.331e4 | +0.03% | agrees | Table 9's counts at our evaluation of Table 6's fits (Eq. (26)); the band moves the fits' parameters by their last printed digit. |
| failure probability, gross, p = 10⁻⁴, its counts | arXiv:2506.03094 Table 10 | 7.97·10⁻¹ | 7.977e-1 | +0.09% | agrees | Table 9's counts at our evaluation of Table 6's fits (Eq. (26)); the band moves the fits' parameters by their last printed digit. |
| failure probability, gross, p = 5·10⁻⁵, its counts | arXiv:2506.03094 Table 10 | 4.62·10⁻² | 4.622e-2 | +0.05% | agrees | Table 9's counts at our evaluation of Table 6's fits (Eq. (26)); the band moves the fits' parameters by their last printed digit. |
| failure probability, gross, p = 3·10⁻⁵, its counts | arXiv:2506.03094 Table 10 | 5.27·10⁻³ | 5.263e-3 | -0.14% | agrees | Table 9's counts at our evaluation of Table 6's fits (Eq. (26)); the band moves the fits' parameters by their last printed digit. |
| failure probability, gross, p = 10⁻⁵, its counts | arXiv:2506.03094 Table 10 | 3.48·10⁻⁵ | 3.478e-5 | -0.07% | agrees | Table 9's counts at our evaluation of Table 6's fits (Eq. (26)); the band moves the fits' parameters by their last printed digit. |
| failure probability, two-gross, p = 10⁻³, its counts | arXiv:2506.03094 Table 10 | 1.65·10⁻² | 1.653e-2 | +0.19% | agrees | Table 9's counts at our evaluation of Table 6's fits (Eq. (26)); the band moves the fits' parameters by their last printed digit. |
| failure probability, two-gross, p = 10⁻⁴, its counts | arXiv:2506.03094 Table 10 | 1.65·10⁻¹¹ | 1.653e-11 | +0.19% | agrees | Table 9's counts at our evaluation of Table 6's fits (Eq. (26)); the band moves the fits' parameters by their last printed digit. |
| failure probability, two-gross, p = 10⁻³, a T injection at its factory | arXiv:2506.03094 Table 10 | 1.65·10⁻² | 3.274e-1 | ×19.841 | their model | Table 10 sets `P_T = P_C` ("the T factory can be chosen to distill states of sufficient fidelity") and §4 neglects the factory. At the factory it allocates, Table 3's 2·10⁻⁸, the T injections alone fail with 0.31. |
| physical error rate for failure 10⁻³, two-gross | arXiv:2506.03094 §A.10 | 7.32·10⁻⁴ | 7.322e-4 | +0.03% | agrees | Its power law through two of its points of Table 10, solved for a failure of 10⁻³; the band moves the fits' parameters by their last printed digit. |
| physical error rate for failure 10⁻³, gross | arXiv:2506.03094 §A.10 | 2.09·10⁻⁵ | 2.086e-5 | -0.20% | agrees | Its power law through two of its points of Table 10, solved for a failure of 10⁻³; the band moves the fits' parameters by their last printed digit. |
| surface code, d = 9: physical error rate, Eq. (96) | arXiv:2506.03094 §A.10, Eq. (96) | 5.48·10⁻⁵ | 5.476e-5 | -0.07% | agrees | With §4's N_T of 19,036,800. §4 prints it truncated to two digits. |
| surface code, d = 9: physical error rate, our code model | arXiv:2506.03094 §A.10, Eq. (96) | 5.48·10⁻⁵ | 1.430e-4 | ×2.610 | their model | As in the capability section: a patch's error per `d` cycles, not a cycle's times `d`, and `(d+1)/2`. |
| surface code, d = 9: physical qubits | arXiv:2506.03094 §4, Fig. 10(b) | 17,010 | 33,210 | +95.24% | their numbers | §4 and Fig. 10(b) count `2d²` a logical qubit. Eq. (96) puts `2n` patches in each rotation, and §A.10's capability comparison reserves half the patches for routing: `4d²`. Ours is `4d²`. |
| surface code, d = 17: physical error rate, Eq. (96) | arXiv:2506.03094 §A.10, Eq. (96) | 5.89·10⁻⁴ | 5.892e-4 | +0.03% | agrees | With §4's N_T of 19,036,800. §4 prints it truncated to two digits. |
| surface code, d = 17: physical error rate, our code model | arXiv:2506.03094 §A.10, Eq. (96) | 5.89·10⁻⁴ | 9.446e-4 | +60.38% | their model | As in the capability section: a patch's error per `d` cycles, not a cycle's times `d`, and `(d+1)/2`. |
| surface code, d = 17: physical qubits | arXiv:2506.03094 §4, Fig. 10(b) | 58,263 | 116,063 | +99.21% | their numbers | §4 and Fig. 10(b) count `2d²` a logical qubit. Eq. (96) puts `2n` patches in each rotation, and §A.10's capability comparison reserves half the patches for routing: `4d²`. Ours is `4d²`. |
| surface code, d = 19: physical error rate, Eq. (96) | arXiv:2506.03094 §A.10, Eq. (96) | 7.85·10⁻⁴ | 7.845e-4 | -0.06% | agrees | With §4's N_T of 19,036,800. §4 prints it truncated to two digits. |
| surface code, d = 19: physical error rate, our code model | arXiv:2506.03094 §A.10, Eq. (96) | 7.85·10⁻⁴ | 1.196e-3 | +52.36% | their model | As in the capability section: a patch's error per `d` cycles, not a cycle's times `d`, and `(d+1)/2`. |
| surface code, d = 19: physical qubits | arXiv:2506.03094 §4, Fig. 10(b) | 72,663 | 144,863 | +99.36% | their numbers | §4 and Fig. 10(b) count `2d²` a logical qubit. Eq. (96) puts `2n` patches in each rotation, and §A.10's capability comparison reserves half the patches for routing: `4d²`. Ours is `4d²`. |

### RSA-2048 on the surface code (arXiv:1905.09749, Quantum 5, 433, 2021)

| Quantity | Source | Published | Ours | Delta | Class | Why |
|---|---|---:|---:|---:|---|---|
| physical qubits, re-run on its layout | arXiv:1905.09749 Table 3 | 20 (megaqubits) | 19,248,768 | -3.76% | agrees | Its script takes each figure up to two digits. |
| hours per run, re-run | arXiv:1905.09749 Table 3 | 5.1 | 5.05 | -1.06% | agrees | Its script takes each figure up to two digits. |
| retry risk, re-run | arXiv:1905.09749 Table 3 | 31% | 0.3098 | -0.08% | agrees | Its script takes it up to a whole percent. |
| megaqubit-days per run, re-run | arXiv:1905.09749 Table 3 | 4.1 | 4.05 | -1.29% | agrees | Its script takes each figure up to two digits. |
| Toffolis, re-run | arXiv:1905.09749 Table 1 | 2.7 (billions) | 2.698e9 | -0.06% | agrees |  |
| factories in each piece, re-run | arXiv:1905.09749 §2.10 | 14 | 14 | 0 | agrees |  |
| hours, expected across retries | arXiv:1905.09749 title | 8 hours | 7.31 | -8.62% | agrees | The re-run's 5.05 hours a run at its 30.98% retry risk is 7.31 hours expected; the title takes that up to one digit. |
| physical qubits, its worked case, level-1 distance 17 | arXiv:1905.09749 §2.14 | "approximately 23 million" | 21,616,448 | -6.02% | their numbers | That section rounds as it goes, and says so: 226 × 63 patches, where the script's layout at these distances has 226 × 61. |
| distillation error of 3·10⁹ CCZ states, distances 17 and 27 | arXiv:1905.09749 §2.12 | 6.4% | 0.0060 | ×0.094 | their numbers | That section reads a spreadsheet of an earlier paper. Its own script's formula, which produced its tables, gives 0.6%. |
| code distance, job, assumed code model | arXiv:1905.09749 §2.13 (d = 27); its counts in the estimate job | 27 | 27 | 0 | agrees |  |
| code distance, job, code model fitted to our decoders | arXiv:1905.09749 §2.13 (d = 27); its counts in the estimate job | 27 | 27 | 0 | agrees | Our fit is `a = 0.0233, p* = 0.01004`, extrapolated from p = 0.002–0.005. |
| physical qubits, job, assumed code model | arXiv:1905.09749 Table 3; its counts in the estimate job | 20 (megaqubits) | 18,906,836 | -5.47% | our limit | The job lays out `2N + √(8N) + 1` tiles of `2d²` qubits and T factories from 15-to-1; the source a board of `2(d+1)²`-qubit patches and CCZ factories, placed by hand. |
| physical qubits, job, fitted code model | arXiv:1905.09749 Table 3; its counts in the estimate job | 20 (megaqubits) | 18,906,836 | -5.47% | our limit | The job lays out `2N + √(8N) + 1` tiles of `2d²` qubits and T factories from 15-to-1; the source a board of `2(d+1)²`-qubit patches and CCZ factories, placed by hand. |
| physical qubits, the planar model on the source's patch and error rule | arXiv:1905.09749 Table 3; its counts in the estimate job | 20 (megaqubits) | 27,571,456 | +37.86% | our limit | The job lays out `2N + √(8N) + 1` tiles of `2d²` qubits and T factories from 15-to-1; the source a board of `2(d+1)²`-qubit patches and CCZ factories, placed by hand. |
| hours per run, job, assumed code model | arXiv:1905.09749 Table 3; its counts in the estimate job | 5.1 | 60.71 | ×11.904 | assumption | On its default step clock the estimate job prices the planar architecture of arXiv:2211.07629: three logical steps of `d` cycles for each Toffoli. The source teleports a Toffoli's fixups away and runs it in one tick; the job does so on its reaction-limited clock (the rows below). |
| hours per run, the planar model on the source's patch and error rule | arXiv:1905.09749 Table 3; its counts in the estimate job | 5.1 | 69.71 | ×13.668 | assumption | On its default step clock the estimate job prices the planar architecture of arXiv:2211.07629: three logical steps of `d` cycles for each Toffoli. The source teleports a Toffoli's fixups away and runs it in one tick; the job does so on its reaction-limited clock (the rows below). |
| code distance, job, reaction-limited clock at 10 µs | arXiv:1905.09749 §2.13 (d = 27); its counts in the estimate job | 27 | 25 | -7.41% | our limit | The tiles wait out 7.50 hours here and 60.71 on the step clock, so a smaller distance meets the same budget. |
| hours per run, job, reaction-limited clock at 10 µs | arXiv:1905.09749 Table 3; its counts in the estimate job | 5.1 | 7.50 | +46.97% | our limit | The job runs each Toffoli in one 10 µs tick, all of them one after another, as its layout runs every step; the source does not, and counts alone do not carry how it does. Its 5.1 hours and its §2.11 "approximately 7 hours" are one parallel basis, 37 ms a lookup addition, with the two runway pieces' additions side by side and the lookups at half a beat an entry. §2.11 reaches 7 by rounding: eq. (1)'s 503,808 lookup additions as 0.1·n_e·n, then 3.7·n_e·n ms as 4·n_e·n, which is 6.99 hours; 37 ms on the unrounded count is 5.18. The source prints no serial figure. 5,207 Toffolis a lookup addition at 10 µs each would be 7.3 hours: that is our derivation from its equations, not its figure. |
| physical qubits, job, reaction-limited clock at 10 µs | arXiv:1905.09749 Table 3; its counts in the estimate job | 20 (megaqubits) | 20,050,780 | +0.25% | our limit | The job lays out `2N + √(8N) + 1` tiles of `2d²` qubits and T factories from 15-to-1; the source a board of `2(d+1)²`-qubit patches and CCZ factories, placed by hand. On this clock the job keeps enough factories (129) that a CCZ state comes every tick, at d = 25: near the source's count by chance, a different machine from its d = 27 and CCZ factories. |
| factories, job | arXiv:1905.09749 §2.10; its counts in the estimate job | 14 CCZ per piece, 28 in all | 16 T factories | — | our limit | A CCZ state costs four T states in the planar model. |
| 1024 bits: megaqubits, re-run | arXiv:1905.09749 Table 3 | 9.7 | 9.62 | -0.78% | agrees | Its script takes each figure up to two digits. |
| 1024 bits: hours per run, re-run | arXiv:1905.09749 Table 3 | 1.3 | 1.26 | -2.79% | agrees | Its script takes each figure up to two digits. |
| 3072 bits: megaqubits, re-run | arXiv:1905.09749 Table 3 | 38 | 37.90 | -0.27% | agrees | Its script takes each figure up to two digits. |
| 3072 bits: hours per run, re-run | arXiv:1905.09749 Table 3 | 12 | 11.61 | -3.28% | agrees | Its script takes each figure up to two digits. |
| 4096 bits: megaqubits, re-run | arXiv:1905.09749 Table 3 | 55 | 54.62 | -0.70% | agrees | Its script takes each figure up to two digits. |
| 4096 bits: hours per run, re-run | arXiv:1905.09749 Table 3 | 22 | 21.08 | -4.20% | agrees | Its script takes each figure up to two digits. |
| 8192 bits: megaqubits, re-run | arXiv:1905.09749 Table 3 | 140 | 133.32 | -4.77% | agrees | Its script takes each figure up to two digits. |
| 8192 bits: hours per run, re-run | arXiv:1905.09749 Table 3 | 86 | 85.54 | -0.53% | agrees | Its script takes each figure up to two digits. |
| 12288 bits: megaqubits, re-run | arXiv:1905.09749 Table 3 | 200 | 199.98 | -0.01% | agrees | Its script takes each figure up to two digits. |
| 12288 bits: hours per run, re-run | arXiv:1905.09749 Table 3 | 200 | 192.47 | -3.76% | agrees | Its script takes each figure up to two digits. |
| 16384 bits: megaqubits, re-run | arXiv:1905.09749 Table 3 | 270 | 266.64 | -1.25% | agrees | Its script takes each figure up to two digits. |
| 16384 bits: hours per run, re-run | arXiv:1905.09749 Table 3 | 350 | 342.54 | -2.13% | agrees | Its script takes each figure up to two digits. |

### FeMoCo on the surface code (arXiv:2011.03494, PRX Quantum 2, 030305, 2021)

| Quantity | Source | Published | Ours | Delta | Class | Why |
|---|---|---:|---:|---:|---|---|
| physical qubits, p = 10⁻³, its floorplan | arXiv:2011.03494 Fig. 10 | ≈ 4·10⁶ | 3,907,584 | -2.31% | agrees | 53 × 36 = 1,908 patches of 2(d+1)², as its caption works out. |
| days, p = 10⁻³, re-run on our clock | arXiv:2011.03494 §IV.C.4 | 3 | 3.01 | +0.22% | agrees |  |
| what sets the pace, p = 10⁻³ | arXiv:2011.03494 §IV.C.4 | the factories (a "tick" limit) | MagicStates | — | agrees |  |
| Toffoli rate, kHz | arXiv:2011.03494 §IV.C.4 | 25 | 25.81 | +3.23% | agrees | Four factories each finish a CCZ state every 5·31 cycles: 25.8 kHz, printed as 25. |
| distillation failure over 10¹⁰ Toffolis | arXiv:2011.03494 §IV.C.4 | "roughly 0.1%" | 0.00103 | +2.85% | agrees |  |
| physical qubits, p = 10⁻⁴ | arXiv:2011.03494 §IV.C.5 | "one million" | 976,896 | -2.31% | agrees |  |
| days, p = 10⁻⁴, re-run on our clock | arXiv:2011.03494 §IV.C.5 | 1.5 | 1.45 | -3.01% | agrees |  |
| days at p = 10⁻³, as §IV.C.5 states | arXiv:2011.03494 §IV.C.5 | 3.5 | 3.01 | -14.09% | their numbers | §IV.C.4 says 3 days; §IV.C.5 scales "3.5 days" by 15/31 and gets 1.5, which is 3 days scaled. Its abstract says under four. |
| Toffolis, Table III against its layout | arXiv:2011.03494 Table III against §IV.C.4 | 5.3·10⁹ (Table III); 6.7·10⁹ (§IV.C.4) | — | — | their numbers | The paper's own two figures: Table III costs the algorithm with its own QROM choices; the layout takes an output expansion factor of 1 for the select reads (§IV.C.2), which holds fewer qubits and takes more Toffolis. Ours takes each in turn below. |
| logical qubits, Table III against its layout's data | arXiv:2011.03494 Table III against §IV.C.4 | 2,142 (Table III); under 700 data qubits (§IV.C.4) | — | — | their numbers | The paper's own two figures: Table III costs the algorithm with its own QROM choices; the layout takes an output expansion factor of 1 for the select reads (§IV.C.2), which holds fewer qubits and takes more Toffolis. Ours takes each in turn below. |
| code distance, its layout's counts | arXiv:2011.03494 §IV.C.4; its counts in the estimate job | 31 | 29 | -6.45% | assumption | Its rule is `0.1·(100p)^((d+1)/2)` a cycle (§IV.C.5: "Λ of 10"); the planar model's `0.03·(p/0.01)^((d+1)/2)` a step of `d` cycles, lower by `d/0.3`, one step of distance at this size. |
| physical qubits, job, Table III's counts | arXiv:2011.03494 §IV.C.4; its counts in the estimate job | ≈ 4·10⁶ | 8,419,152 | ×2.105 | our limit | The job lays out `2N + √(8N) + 1` tiles of `2d²` qubits and T factories from 15-to-1; the source a board of `2(d+1)²`-qubit patches and CCZ factories, placed by hand. |
| physical qubits, job, its layout's counts | arXiv:2011.03494 §IV.C.4; its counts in the estimate job | ≈ 4·10⁶ | 3,529,152 | -11.77% | our limit | The job lays out `2N + √(8N) + 1` tiles of `2d²` qubits and T factories from 15-to-1; the source a board of `2(d+1)²`-qubit patches and CCZ factories, placed by hand. |
| days, job, Table III's counts | arXiv:2011.03494 §IV.C.4; its counts in the estimate job | 3 | 5.34 | +77.89% | assumption | On its default step clock the estimate job prices the planar architecture of arXiv:2211.07629: three logical steps of `d` cycles for each Toffoli. The source teleports a Toffoli's fixups away and runs it in one tick; the job does so on its reaction-limited clock (the rows below). |
| days, job, its layout's counts | arXiv:2011.03494 §IV.C.4; its counts in the estimate job | 3 | 6.75 | ×2.250 | assumption | On its default step clock the estimate job prices the planar architecture of arXiv:2211.07629: three logical steps of `d` cycles for each Toffoli. The source teleports a Toffoli's fixups away and runs it in one tick; the job does so on its reaction-limited clock (the rows below). |
| physical qubits, job, p = 10⁻⁴ | arXiv:2011.03494 §IV.C.5; its counts in the estimate job | "one million" | 968,200 | -3.18% | our limit | The job lays out `2N + √(8N) + 1` tiles of `2d²` qubits and T factories from 15-to-1; the source a board of `2(d+1)²`-qubit patches and CCZ factories, placed by hand. |
| days, job, p = 10⁻⁴ | arXiv:2011.03494 §IV.C.5; its counts in the estimate job | 1.5 | 3.49 | ×2.328 | assumption | On its default step clock the estimate job prices the planar architecture of arXiv:2211.07629: three logical steps of `d` cycles for each Toffoli. The source teleports a Toffoli's fixups away and runs it in one tick; the job does so on its reaction-limited clock (the rows below). |
| days, job, its layout's counts, reaction-limited clock at 10 µs | arXiv:2011.03494 §IV.C.4; its counts in the estimate job | 3 | 0.78 | ×0.259 | assumption | The job ticks at 10 µs where the source's four CCZ factories set a pace of 38.75 µs (25 kHz), and that ratio is this delta. It keeps 157 T factories to do so, and the two counts are different machines: each of the job's is a 15-to-1 unit taking 1,568 µs a CCZ state, each of the source's 155. At the source's own 38.75 µs the job keeps 41, so of the ×39 against four the tick is ×3.8 and the kind of factory ×10. The job's frontier slows the ticks to need fewer. |
| physical qubits, job, its layout's counts, reaction-limited clock at 10 µs | arXiv:2011.03494 §IV.C.4; its counts in the estimate job | ≈ 4·10⁶ | 10,799,568 | ×2.700 | assumption | The job lays out `2N + √(8N) + 1` tiles of `2d²` qubits and T factories from 15-to-1; the source a board of `2(d+1)²`-qubit patches and CCZ factories, placed by hand. As above: most of this is the T factories that keep up with the tick; at the source's own 38.75 µs the job needs 4,410,288 qubits. |

### RSA-2048 on yoked surface codes (arXiv:2505.15917, 2025)

| Quantity | Source | Published | Ours | Delta | Class | Why |
|---|---|---:|---:|---:|---|---|
| physical qubits | arXiv:2505.15917 §3.2 | 897,864 | 958,480 | +6.75% | their numbers | Ours keeps 152 logical qubits hot by its peak formula and buys whole grid blocks; its count keeps 131 and a fractional block. At its 131 and 430 qubits a logical qubit, our arithmetic gives its 897,864. |
| hours per shot | arXiv:2505.15917 §3.2 | 12.07 | 10.58 | -12.36% | their numbers | Its tallies at its stated durations give 10.62 hours, and its clock at whole milliseconds 10.58. |
| days per factoring | arXiv:2505.15917 §3.2 | 4.96 | 4.31 | -13.20% | their numbers | From the hours per shot above; it also multiplies by 9.1 shots where its table gives 9.2. It rounds 4.96 up to "less than a week". |
| logical qubits | arXiv:2505.15917 §3.2 | 1,409 | 1,432 | +1.63% | their numbers | §3.2 prints 1,409 for its peak formula `m + 3f + 2ℓ + len m`, which evaluates to 1,432; its Table 4 gives 1,399. |
| Toffolis per factoring, by its counting rule | arXiv:2505.15917 §3.2 | "6.5 billion" | 6.50e9 | -0.04% | agrees |  |

### The planar model's own source (arXiv:2211.07629, 2022)

| Quantity | Source | Published | Ours | Delta | Class | Why |
|---|---|---:|---:|---:|---|---|
| code distance, RSA-2048, (ns, 10⁻⁴) | arXiv:2211.07629 Appendix F | 13 | 13 | 0 | agrees |  |
| factories | arXiv:2211.07629 Appendix F | 18 | 18 | 0 | agrees |  |
| physical qubits | arXiv:2211.07629 Appendix F | 8.72M | 8,716,258 | -0.04% | agrees |  |
| run time, hours | arXiv:2211.07629 Appendix F | 17 hours 43 mins | 17.723 | +0.04% | agrees | Table IV prints 18 hours. |

<!-- end of the rows -->