How KetQat estimates resources

1. Logical resources

The starting point is a count of logical qubits and logical operations. It comes from one of three places, and which one it came from is recorded on the figure rather than inferred: a circuit you supply, counts you state directly, or a published resource model evaluated at your problem size.

A gate that is neither Clifford nor T and has not been synthesised is counted as unsupported, not as zero. If any such gate is present, the magic-state demand is reported as undetermined and every quantity downstream of it — factory footprint, total physical qubits, runtime — is reported as unknown rather than computed from a demand of zero.

2. Code distance

The surface code's logical error rate per patch per round is modelled as

p_L = A · (p / p_th)^((d + 1) / 2)

with physical error rate p, threshold p_th, distance d, and a prefactor A. KetQat uses p_th = 0.01 and lets you choose A = 0.03 (Fowler et al.) or A = 0.1 (Gidney–Fowler, and the value Qualtran uses). The distance is the smallest d for which the total logical error across all patches and rounds stays inside your stated error budget.

The prefactor is a choice, not a constant of nature, and it is one of the parameters the sensitivity analysis varies. Two tools disagreeing on it is a definitional difference, not a bug in either.

3. Layout

Each logical qubit occupies a patch of 2d² physical qubits. A lattice-surgery layout for n logical qubits needs

2n + ⌈√(8n)⌉ + 1

patch-equivalents, from Beverland et al., arXiv:2211.07629. The routing overhead is not a rounding allowance; it is where the ancilla space for the surgery lives.

4. Magic-state distillation

Non-Clifford operations consume distilled states. KetQat models 15-to-1 distillation: fifteen input states per output, with output infidelity

p → 35 p³

A round improves the state only below the fixed point 1/√35 ≈ 0.169. Above it, rounds make the state worse and no number of them helps — so the estimator refuses rather than adding levels until the arithmetic looks acceptable.

On most workloads the factory dominates both the footprint and the runtime. That is why the results page names the binding constraint instead of leading with a qubit count: the qubit count is usually not what stops you.

5. Conditions, not predictions

KetQat does not forecast when a quantum computer will beat a classical one. It computes what would have to be true: the largest surface-code cycle time that would meet your runtime target, the largest physical error rate the error budget tolerates, the smallest machine that could hold the computation.

A condition is only computed when everything it depends on is present. Where a baseline, a capacity or a cost model is absent, the corresponding conclusion is refused by name rather than computed from an assumed denominator. Crossing a threshold makes something not ruled out by that constraint — never feasible.

6. Evidence classes

Every quantity carries how it was obtained: MEASURED, USER_PROVIDED, DERIVED, MODELLED, or UNKNOWN. These are kinds, not grades. There is no function that ranks or averages them, because a measurement and a model are not two amounts of the same thing.

A quantity with no value must be UNKNOWN, and an UNKNOWN quantity must have no value. The contract rejects any other combination, so a missing measurement cannot enter the arithmetic as a zero.

7. Reproducibility

An assessment is published as a bundle carrying the inputs, the assumptions and the conclusions under one hash. ketqat-engine intelligence verify recomputes the estimates and decisions from the inputs and compares them; it does not check that the file is internally consistent with itself.

A matching hash means the bytes are unchanged. It is not a scientific verification, and this product never presents it as one.

8. Where the model has been checked against others

The layout rule is verified against Microsoft's Azure Quantum Resource Estimator (qdk 1.30.0). On the RSA-2048 reference case, KetQat's physical-qubit total sits within 8% of the 20 million reported by Gidney and Ekerå. The runtime differs by roughly a factor of 3.6, which is carried as a named definitional difference in what the two count as a cycle — not tuned away.

Agreement with another estimator is evidence that two models agree. It is not evidence that either describes a machine that exists.

Every comparison in the latest run, including the one where the tools disagree and why that is a modelling choice rather than a defect.