Most circuits that look like they need a QPU are classically tractable — measured.

The market is saturated with quantum hype and quantum threat. Atlas separates signal from noise on the one question that precedes the spend: does this circuit actually need a quantum computer, or does a classical method reproduce it? Every headline number below is traceable to a file, a script, or a hardware job-id — in our self-generated corpus of 2,517 circuits, the route distribution comes out "classical" far more often than the circuits look, i.e. most of the ones we generated to look hard were classically tractable. Three layers: a 2,517-circuit oracle-certified corpus (its confusion matrix + a held-out Wilson bound), real-QPU validation on public Heron-r2 hardware, and an honest table of what Atlas does that the surveyed tools do not.

1 The corpus — 2,517 oracle-certified circuits

Atlas's routing is checked against a classical oracle (Stim for Clifford, exact non-truncated MPS, and statevector) that can only certify the classically-tractable regime — the only regime where a classical ground truth exists. This is the honest scope of every number in this section.

Oracle route distribution: cpu 2,431 · tensor 61 · hpc_first 25 · escalate 0. The escalate (genuinely quantum-hard) class has 0 certified circuits by construction — there is no classical ground truth there (the BQP≠BPP wall), so it is declined as out-of-distribution, never certified. The corpus is evaluation-only: Atlas is not tuned to it.

What the corpus is made of — stated up front, so the "are these synthetic?" objection is answered with the composition, not a defense. Yes, the circuits are generated, not harvested from production — and they are fully specified, hash-pinned, and regenerable, which is the point: the oracle can only certify what it can exactly simulate. The families are structural-topology generators spanning the regimes where the classical/quantum frontier actually lives:

Each family is crossed with n = 8 … 44, multiple depths, 4 T-gate densities (stabilizer → magic-heavy), and 8 seeds. The point of the spread is to walk a circuit across the simulability frontier — low T-count + area-law stays CPU, magic + 2D-dense pushes toward the wall — so the route distribution above is earned by structure, not by cherry-picking easy cases. (m = moat slice, e = ext slice.)

Source: three CSVs under benchmarks/results_scaled/ (scaled_results.csv 800 · _ext 90 · _moat 1627 = 2,517; family column in the 800-slice, id-prefix in ext/moat), benchmark_manifest.json (sha256 66f9d6…, split=evaluation-only), reproduced by oracle.py. Per-slice manifests, each pinning its slice CSV by sha256: core-800 (served live at /api/benchmark-manifest) · ext-90 · moat-1627 · aggregate-2517 — so "hash-pinned" now holds for all three slices, not just the core. CLAIMS C6/C13; SELF_ASSESSMENT #1. Conceded honestly: these are 2,517 variants over ~7 structural families, not 2,517 independent families — variants within a family are correlated, and exchangeability across families is assumed, not proven. We do not claim the corpus spans every circuit a user might submit; that is exactly why OOD decline exists.

Done — see §6 below: this corpus is self-generated — circuits we built to look hard. The honest complement is validating against circuits others assumed hard: published quantum-advantage circuits later classically simulated (Sycamore random-circuit sampling; IBM 127-qubit utility / kicked-Ising) and community suites (QASMBench, MQT Bench). That external-validation run is now done and reported in §6 (115 circuits: 108 classical · 7 escalated · 0 timed out) — including the honest result that Atlas escalated the genuine advantage frontier rather than rubber-stamping it. None of the numbers above generalize beyond our own corpus.

2 Confusion matrix — the 11 disagreements, not zero

We do not present a perfect score. There are 11 measured disagreements with the oracle; here is where they fall. Rows = Atlas route, columns = oracle route, on the tractable corpus.

The 11 disagreements: 10 cpu→tensor under-routes (Atlas said CPU, oracle said tensor — the safe direction, you over-trust the laptop on a circuit a workstation handles) and 1 tensor→hpc, the single false-safety. Every off-diagonal cell is below the diagonal: Atlas never over-routes (0 false-alarm), and never lands two tiers off.

The single false-safety is moat_ladder_n28_t8_s3: Atlas routes it TENSOR via treewidth 2²⁸ (≈4 GB, genuinely workstation-feasible); the oracle routes it HPC because its statevector cutoff is n=27 < 28. Both methods agree the cost is ~2²⁸ ≈ 4 GB — it is a route-class boundary artifact between two oracle threshold tables on different scales (qubit-count vs log₂-cost), not a "said classical when you truly need a QPU" error. We report it rather than retune the thresholds to force the count to zero.

Source: the three CSVs under benchmarks/results_scaled/ (direct count of atlas_route_class vs oracle_route); SELF_ASSESSMENT #1. Every cell here is the exact per-cell count: diagonal 2,431 / 51 / 24, off-diagonal 10 cpu→tensor + 1 tensor→hpc (the false-safety). 0 above the diagonal = 0 false-alarm.

Why no single estimator achieves this →

3 Held-out Wilson bound — the defense against overfit

The advertised number is computed on data the acceptance threshold never saw. atlas_conformal.py splits the certified set 50/50, picks the threshold τ on the selection half only, and reports a one-sided Wilson upper bound on the error of the held-out validation half.

Calibration quality after isotonic recalibration (held-out): Brier 0.103 → 0.0076, ECE 0.255 → 0.007. We never show "100%" — the ceiling is the Wilson bound, and all 11 errors sit at confidence ≤ 34, i.e. the calibrated confidence behaves as an error detector. The reliability diagram is public.

Source: engine/atlas_conformal.py + atlas_recalibrate.py + calibration_report.json + reliability_diagram.svg. CLAIMS C13/C14; SELF_ASSESSMENT #1. Caveat (conceded): the corpus is template-family-bounded — 2,517 variants, not 2,517 independent structural families; exchangeability across families is assumed, not proven.

4 Real QPU — public-access superconducting hardware (Heron r2)

Real QPU. Run on public-access superconducting hardware, Heron r2 architecture (backend ibm_kingston, open plan), 2026-06-22/24. We report only what we measured; the genuinely quantum-hard regime (n>24, no classical oracle) remains unmeasurable by construction and we do not over-promise it.

4a · Depth-resolved 3-regime sweep — 19 (n,depth) points. In the fixed-width pt_n12 family, TVD(ideal, QPU) rises with depth because the device decoheres (real hardware noise grows with depth), not because Atlas is wrong: at n≤12 the ideal distribution is classically tractable (exact statevector) and is the ground truth. Mirror-RB fidelity (independent, readout-corrected, K=6 error bars) falls in mirror.

The outlier, read honestly: disc_n20_d2 (TVD 0.999 at depth 2) is width and shot budget, not depth — its ideal distribution is exactly uniform over 2²⁰ outcomes (an H-wall followed only by CX/T phase gates, no further interference), so with 1,024 shots even a perfect noiseless device would score TVD = 1 − 1024/2²⁰ ≈ 0.999: the number sits at the finite-shot floor and carries no depth-decoherence information. The same construction at n=12 (ramp_n12, floor 0.75) reads flat ≈ 0.78 from depth 2 to 32 for the same reason. Depth-scaling claims in this section rest on the fixed-width pt_n12 family, whose ideal distribution is concentrated (TVD 0.135 → 0.60 as depth 2 → 18), and on mirror-RB.

Mirror-RB exponential fits: r_per_layer = 6.7% (n=8, R²=0.996), 11.2% (n=12, R²=0.944); additional n=8 point d8/16/32 → F = 0.655±0.010 / 0.415±0.039 / 0.126±0.031. Every value traceable by job_id in qpu_jobs.json; tables in qpu_regime_results.json + qpu_mirror_results.json. 1024 shots (TVD) / 500 shots (mirror-RB); 0 new QPU time (retrieved from completed jobs). The "—" gaps are honest (not interpolated). CLAIMS C1/C2.

4b · Embedding A/B — hardness depends on the physical layout. Same logical GHZ, two physical mappings. A deliberately bad layout (real TLS cluster) collapses the output — measured contrast 9.7× at n=6, robust and growing with n.

Contrast 9.7× (ghz6) vs 7.3× (ghz4). The bad layout is the documented real TLS cluster, not an adversarial worst case. This validates that Atlas's hardware-aware lens (recommend_embedding_offline / exclude_qubits) is actionable on metal. Source: QPU_RESULTS.md §2/§4.

4c · Independent-method corroboration — attempted on real hardware, honestly declined (no number claimed). The headline figure is self-consistency: cheap routing vs. an exact same-formalism (tensor-network / stabilizer) oracle. A genuinely non-circular check needs an arbiter from outside that formalism — a physical QPU. We ran it on real ibm_kingston hardware. Result: no circuit cleared our own F ≥ 0.90 mirror-fidelity window, so Atlas claims no QPU corroboration and abstains. The deeper n=10–12 batch fell to mirror-F 0.30–0.55; the shallow n=6 batch collapsed to mirror-F ≈ 0 (and its exact distribution was near-uniform, where any agreement is uninformative by construction). Reporting an agreement number there would be exactly the kind of overclaim this project exists to avoid. What a valid corroboration requires (the roadmap): a non-uniform, structured classical target, reproduced by an in-window (F ≥ 0.90) circuit, scored by cross-entropy fidelity (F_xeb), not 1−TVD. The genuinely hard regime has no possible arbiter at all (BQP≠BPP). We corroborate where physics allows — and so far, honestly, it has not. Source: benchmarks/qpu_arbiter*_*.json (real job IDs, open plan).

4d · Non-circular ground truth by execution — where it IS measurable (n ≤ 26): 247/247 confirmed. The QPU arbiter above is one outside-formalism check (it abstained). A second, orthogonal one is exact statevector execution. For 256 circuits at n ≤ 26 (both corpora) we build the full 2ⁿ complex amplitude vector and evolve it gate-by-gate — brute-force execution, independent of the MPS-bond / treewidth estimators that make the headline figure "self-consistent." If it runs, the circuit is provably classically tractable by having been simulated. Result: 247/247 executable classical verdicts confirmed (100%), 0 disagreements — 9 honest exclusions (mid-circuit measure/reset, malformed QASM, wall-time), never routing errors; our engine cross-checks against qiskit.Statevector at fidelity 1.0. Notably, several TENSOR-routed circuits where Atlas's own estimators reported "all methods exceed budget" were still confirmed tractable by execution — independent vindication exactly where the same-formalism oracle was inconclusive. Honest scope: this validates small n only; above the statevector ceiling (n ≳ 28) there is no classical ground truth — which is precisely why circularity bites in the hard regime — and Atlas handles that by ESCALATE/abstain, which this does not validate. Source: benchmarks/noncircular_groundtruth/ (open, reproducible).

5 Per-layer hardware ceiling — κ̂ correction (self-correction #10)

Our own Porter-Thomas conformal calibration on real metal flips the sign of the first-order correction. The honest direction is conservative: first-order estimates overestimate reachable depth.

From 7 PT-valid points (n=12, 2D-random), median per-layer ratio κ̂ = 2.62 (>1): on real ibm_kingston, fidelity falls ≈2.6× faster than a first-order inference predicts (the simulator underestimates correlated/non-Markovian noise — crosstalk, TLS, leakage). Impact: Atlas's realistic depth ceiling becomes ≈11 layers (vs an optimistic first-order 29–49). The correction tightens the ceiling (safety), it does not extend it. Held-out (LOO conformal) MAE 29% → 12%, 80% band ±0.21.

Source: qpu_pt_calib.json + atlas_conformal_hardware + qualify_offline; CLAIMS C2. Honest scope: 7 PT-valid points (not 9 → ~80% conformal coverage, 90% needs ≥9); worst-case 2D-random family (κ̂ applies to high-magic ESCALATE candidates — the relevant family); each circuit had its own transpiled layout, so embedding variance is inside the band.

5b The noise model — exactly what is measured vs. approximated

A fair question from anyone who reads carefully: there appear to be two noise models. There are — and conflating them would be dishonest, so here is the precise state of each.

The honest split: the measured model carries real per-edge heterogeneity — median CZ error ≈2.0×10⁻³ (best edge ≈8.2×10⁻⁴, with a long tail up to dead edges), median readout ≈7.9×10⁻³ (best ≈2.4×10⁻³), median T1 ≈241 µs. That is the model behind every hardware number on this page. The toy global depolarizing channel is a single-knob teaching envelope wired only to the UI slider; it does not model per-qubit T1/T2, readout, crosstalk, or topology, and is labeled as such. The measured per-edge model is not yet wired into the interactive panel — that connection is roadmap, and we say so rather than implying the slider is calibrated.

Source: benchmarks/kingston_calibration.json (per-edge CZ / readout / T1 / SX for 156 qubits / 176 edges, measured 2026-06-22) + noise_local_validation.csv (the measured local model reproduces the device: TVD(ideal vs noisy-local) ≈ 0.03–0.10 across the validation circuits); noise.py = the toy global channel. CLAIMS C7; SELF_ASSESSMENT #5 (toy noise conceded as a real gap for the slider; the measured model is what backs every hardware claim). The two layers are kept separate and labeled — never presented as one calibrated model.

6 External validation — circuits others assumed hard

The section above is our self-generated corpus. This one is the opposite test: Atlas run on the QASMBench suite (small→large) + MQT-Bench algorithm circuits + canonical quantum-advantage circuits (Sycamore random-circuit sampling; the IBM 127-qubit "utility" kicked-Ising, Kim et al., Nature 2023) — circuits others published or assumed hard, not our own generated corpus. Families span adder, multiplier, GHZ-127, cat, Bernstein–Vazirani, QFT, Quantum Volume, HHL, Shor/factoring, quantum walks, kNN/DNN, QuGAN, QAOA, Trotter and VQE/UCCSD. These were obtained / constructed to the cited sizes, not drawn from our own generators.

The result, stated honestly: of 115 external circuits, 108 routed to a classical tier, 7 escalated (the genuine advantage frontier), and 0 timed out. An earlier run reported 14 non-results caused by an engine estimator-budget bug (certain small-n circuits stalled a single estimator); with per-estimator wall-clock budgets + graceful abstain now in the engine, all 14 resolve — 10 to a classical tier, 4 to genuine ESCALATE (qb_QV_n100, qb_qft_n160, qb_bwt_n37, qb_square_root_n45 — real size/entanglement at n=37–160, re-probed at a 180 s budget, not a small-n artifact). This is a per-circuit result over named published suites — not a generalizable "X % of all circuits" claim.

Citations. Sycamore RCS = Arute et al., Nature 574, 505 (2019), with later classical simulation by Pan & Zhang, PRL 129, 090502 (2022) and Gordon-Bell 2021 work. IBM 127-qubit kicked-Ising = Kim et al., Nature 618, 500 (2023), classically reproduced by Tindall, Fishman, Stoudenmire & Sels, PRX Quantum 5, 020332 (2024) (and Begušić & Chan 2024). Algorithm circuits follow QASMBench / MQT Bench families. Clifford-point tractability: Aaronson–Gottesman (2004) via Stim.

Reproducible — full QASM, runner scripts and every results.json are public under benchmarks/external_corpus/ in the open repo. Recompute the consolidated counts directly from results.json, tier2_vqe/results.json, tier2_qaoa_trotter/results.json and batch2_published/results.json (dedup by circuit name → 115 unique). Engine: the same cost_atlas + route_adjudicator estimators used for the self-generated corpus.

7 What we have that the surveyed tools do not

Bounded novelty, stated honestly: this is of the tools we surveyed, not "nobody has X" in the absolute. Qiskit Aer's method='automatic' is prior art for multi-method routing and is cited here as the baseline. What Aer does not do is the rest of the row.

Source: COMPETITIVE.md §1–§2 (full per-tool, no-strawman comparison incl. AWS Braket cost estimator, Mitiq, TKET). Each competitor is excellent at its purpose; several (Stim, quimb, cotengra) are dependencies of Atlas. CLAIMS C11 — language: "productized first," never "category without competition."

8 Reproduce it

# corpus self-consistency + held-out conformal bound
PYTHONPATH=engine NUMBA_DISABLE_JIT=1 python3 engine/atlas_conformal.py
# -> held-out self-consistency ≥ 0.987 (α=0.05); 2506/2517 = 0.9956

# real-QPU depth-resolved validation (re-derives from completed jobs)
python3 benchmarks/qpu_validation.py     # end-to-end TVD
# tables: qpu_regime_results.json · qpu_mirror_results.json · qpu_jobs.json

Every figure on this page is re-derivable from the public repo — corpus, scripts and data all included: github.com/fomv9354lve/atlas-engine (Apache 2.0; see REPRODUCE.md). Clone it and run atlas_benchmark_bundle.py to recompute the confusion matrix yourself. Hardware language follows policy: public-access superconducting hardware, Heron r2 architecture, June 2026 — job result JSONs ship with the dataset.