ShayManor/ising-sim2real-results

Ising sim2real — Decoder Benchmark Results

Evaluation results for a panel of open surface-code decoders run on real Google Willow hardware data and on synthetic circuit-level noise of rising fidelity. The question these results answer: does the cheap synthetic benchmark predict the real-hardware result?

This repo holds the outputs (LERs, per-shot outcomes, fitted noise models, figures). The inputs — ingested Willow detection events, circuits, and shipped DEMs — live in ShayManor/willow-surface-code-detection-events.

The core idea

Decoder papers benchmark on synthetic circuit-level noise, then report a winner. Real hardware carries leakage, crosstalk, drift, soft readout, and rare high-energy events that no Pauli simulator produces. So: rows = data sources, columns = decoders, cell = that decoder's logical error rate (LER). Rows are ordered by how close the synthetic noise is to the device:

rung	what it is
uniform	uniform depolarizing noise
si1000	the standard SI1000 circuit-level noise model
fit	a 25-parameter circuit-level model fitted to the device
syndrome	a DEM estimated directly from syndromes (arXiv:2606.11496)
real	real Willow data — the reference every synthetic rung is scored against, not a rung

Same circuit on every rung; only the noise model used to simulate detection events changes.

Decoder panel: mwpm (PyMatching), mwpm-rl (real only — uses the shipped RL-optimized DEM), tesseract, bposd, bplsd, beliefmatching, and ising (NVIDIA's Ising pre-decoder in front of PyMatching, model column = fast R=9 or accurate R=13).

Data: rotated surface code, distances 3/5/7, X and Z memory, 14 code patches, round counts r1–r250. Real source: Google Willow below-threshold dataset (10.5281/zenodo.13273331).

Quick start

from datasets import load_dataset

ladder = load_dataset("ShayManor/ising-sim2real-results", "ladder")
real = ladder["real"].to_pandas()

Or straight from the CSVs, which is usually what you want for analysis:

import pandas as pd

rungs = ["willow_real", "willow_synth_uniform", "willow_synth_si1000",
         "willow_synth_fit", "willow_synth_syndrome"]
df = pd.concat([
    pd.read_csv(f"hf://datasets/ShayManor/ising-sim2real-results/results/{r}/eval_all.csv")
      .assign(source=r.replace("willow_", ""))
    for r in rungs
])

# Decoder ranking per source, at matched distance/rounds:
cell = df.query("distance == 7 and rounds == 30")
cell.groupby(["source", "decoder"]).ler_per_cycle.mean().unstack()

Schema

Every eval_all.csv (and every per-config shard) uses one schema, so any two are directly comparable. One row = one (config x decoder).

column	meaning
distance	code distance d (3, 5, 7)
basis	X or Z memory
orientation	code patch label on the chip (e.g. q6_7)
rounds	number of QEC cycles
decoder	mwpm, mwpm-rl, tesseract, bposd, bplsd, beliefmatching, ising
model	Ising model variant (fast / accurate), else -
shots	shots decoded
n_errors	raw logical-error count — makes LER exact and enables binomial bootstrap
ler	logical error rate = n_errors / shots
ler_per_cycle	LER normalized per QEC cycle — the comparable number across round counts
decode_seconds	wall-clock decode time (latency analysis)
note	e.g. skipped: rounds<2, or Ising's R=9,rot=XV

ler is nan where a config was skipped (see note). Compare ler_per_cycle, not ler, unless you have matched rounds.

Layout

results/
  willow_real/            REAL Willow row — the reference.  (+ outcomes/, 492 npz)
  willow_synth_uniform/   ladder rung: uniform depolarizing   (+ outcomes/, 446 npz)
  willow_synth_si1000/    ladder rung: SI1000                 (+ outcomes/, 448 npz)
  willow_synth_fit/       ladder rung: 25-param fitted        (+ outcomes/, 448 npz)
  willow_synth_syndrome/  ladder rung: syndrome-estimated DEM (+ outcomes/, 448 npz)
  ladder.png              the central deliverable figure

  willow_real_evalset/       REAL Willow, extended long-round tail (r110-r250)  (+ outcomes/, 178 npz)
  willow_synth_fit_evalset/  FIT rung, extended/held-out run (r1-r250)          (+ outcomes/, 474 npz)

  fitted_noise_models/    the 25-param fits, one JSON per patch (d{D}_q{loc}.json)

  sensitivity/            RQ3: per-parameter sweep, each of 23 params overestimated 2x
    baseline/             unperturbed fitted model, for comparison
    p_<param>/            one dir per perturbed parameter
    models/ models_under/ the perturbed noise models themselves
    sensitivity.png
  sensitivity_under/      same sweep, 0.5x UNDERestimate
  sensitivity_r10/        same sweep at r10
  sensitivity_r50/        same sweep at r50
  twobytwo/               2x2 decomposition: S-<sampled>__P-<prior> separates
                          "wrong noise sampled" from "wrong prior given to decoder"

  bootstrap/              correlated-perturbation eval, 40 refit draws (draw_00..draw_39)
    eval/draw_NN/         each draw's full panel eval
    models/draw_NN/       each draw's refitted noise models
    covariance.png

  t4_checkpoints/         pre-decoder finetune checkpoints (see "negative result" below)
  t4_ladder.png

outcomes/*.npz are bit-packed per-shot logical-error indicators, keyed d{D}|{basis}|{patch}|r{rounds}|{decoder}|n{shots} (Ising's fast/accurate variant is in the filename, not the key). Unpack with np.unpackbits(arr)[:n]; the sum equals that row's n_errors. All five rungs ship outcomes/, so a joint / rank bootstrap against real data is reproducible from this repo — not just a per-cell binomial one. Verified end-to-end: for every rung and every decoder, the unpacked per-shot sum equals the published eval_all.csv n_errors (1790/1790 keys on the real row, 0 mismatches; both *_evalset dirs also 0 mismatches against their own merged CSV).

The *_evalset dirs

willow_real_evalset/ and willow_synth_fit_evalset/ are separate eval campaigns, kept out of the main rungs on purpose — they use different shot counts (5,000 / 20,000, not 50,000) and mostly cover the long-round tail (r110–r250) that the main run doesn't decode. Same 12-column schema, own merged eval_all.csv, own outcomes/. Do not concatenate them into willow_real / willow_synth_fit: willow_real_evalset is entirely new (distance, decoder, round) cells, but willow_synth_fit_evalset overlaps the fit rung on some cells with different shot counts, so a blind merge would put two logical-error counts on one cell. Use them for long-round scaling curves; use the main rungs for the ladder ranking.

What the data shows

Headline numbers, so you know what you're looking at. Kendall tau between each rung's decoder ranking and real Willow's:

rung	d3	d5	d7
uniform	0.619 (p=.07)	0.714 (p=.03)	0.733 (p=.06)
si1000	0.905	0.905	1.000
fit	0.905	0.905	0.810
syndrome	1.000	0.905	0.905

1. Uniform depolarizing noise is a clear, often not-significant outlier. Any circuit-level structure (si1000/fit/syndrome) lifts agreement to tau >= 0.81. The fix is "have a real circuit," not necessarily "fit the noise precisely."
2. The ladder is not monotonic — the more interesting result. At d7, generic si1000 (tau=1.000) beats both data-calibrated rungs despite being ~70x off in absolute LER. Fit/syndrome get the magnitude right and lose the rank check. Root cause: d7 has only 1 real patch, so fit/syndrome are weakly conditioned — estimation ill-conditioning, not a ladder-design flaw.
3. The flip is always the same pair: mwpm <-> bposd/bplsd (near-tied mid-pack). tesseract and beliefmatching show zero rank drift anywhere.
4. RQ3: rankings are robust. Overestimating any single noise parameter 2x causes at most one adjacent swap (tau >= 0.80); 10/23 params cause zero reordering. Only Y-containing / off-diagonal Pauli channels (p_idle_spam_Y, p_idle_cnot_Y, p_cnot_ZY) move anything; diagonal / dephasing channels including p_meas_Z are inert.
5. RQ4: Ising loses to classical MWPM on real hardware by ~3x per-cycle at d7 (Z: 0.0121 vs 0.0038 at r70), while matching or beating MWPM on synthetic data. A genuine sim2real gap, not a bug — the signature is a round-independent error floor that synthetic data lacks. One caveat remains open: the Willow XZZX -> CSS mapping could produce a similar fixed offset.
6. Negative result (t4_checkpoints/): a same-size pre-decoder finetuned via device-distillation does not beat stock NVIDIA Ising (0.0184 vs 0.0164). Structural — the observable isn't a function of the syndrome alone.

Caveats — read before drawing conclusions

• The top-level results/*.csv files are STALE and should not be used. classical_d{3,5}_*.csv, ising_*_d{3,5}_*.csv are from Jun 28 2026, before a pipeline bug was fixed, and report Ising near chance (d3/Z ising_fast LER=0.371 vs the correct 0.128). They also predate the n_errors column (11 cols, not 12). They're kept only for provenance. Use willow_real/ and the willow_synth_*/ rungs, which were all re-run on the fixed pipeline.
• Shot counts vary by decoder on the real row. Most decoders decode 50,000 shots; beliefmatching decodes 10,000. Both the CSV n_errors and the outcomes/ npz reflect this consistently (the npz key self-encodes n{shots}), but a joint per-shot bootstrap across decoders must align on the common shot count (10,000) or handle beliefmatching separately.
• bplsd has no shard at uniform/d7 (a 446-vs-448 coverage gap), so that cell's tau is computed over 6 shared decoders rather than 7 and is not strictly comparable to the d3/d5 numbers beside it. This is why uniform's tau appears to improve with distance.
• The sweep CSVs do not name their own perturbation. Every eval_all.csv under sensitivity*/, twobytwo/, and bootstrap/eval/ uses the same 12 columns with no column identifying which parameter was perturbed (or which draw it is) — the directory name is the only carrier. So don't blind-glob them together; tag as you load:

  import glob, pandas as pd
  sens = pd.concat([
      pd.read_csv(f).assign(param=f.split("/")[-2])
      for f in glob.glob("results/sensitivity/*/eval_all.csv")
  ])   # compare param="baseline" against each perturbed param
  

  This is also why only the ladder config is declared for the dataset viewer: there, the split name carries the rung, so nothing is lost.
• Match your comparisons. Rungs are only comparable at matched (distance, basis, rounds) and matched-prior decoding (each rung decodes with the DEM it sampled from). The headline table uses rounds 2–30.
• mwpm-rl exists only on real (no synthetic rung has an RL-optimized DEM), so exclude it from cross-rung comparisons.
• Always report code distance d alongside the Ising receptive field R (in note). The public Ising models were trained for larger R than d=3/5/7.

Reproducing

Harness: github.com/ShayManor/Ising-sim2real. Jobs produce raw data only; all statistics (Kendall tau, Spearman, bootstrap CIs) are computed locally from these CSVs via scripts/build_ladder.py, scripts/build_sensitivity.py, scripts/build_bootstrap.py, scripts/build_2x2.py, and scripts/build_selection.py.