Quantum error correction · Noise characterisation

Every quantum chip has its own noise. We measure it from the chip's own syndromes.

Syndromics turns the error-correction signals a processor already produces into a physical model of its real, current noise. Decoders get better weights, and engineers see which gate, qubit or measurement has drifted.

0.40% → 0.20%logical error on IBM's ibm_kingston: published calibration vs Syndromics model, on held-out shots
6 of 6train/test splits where the measured model beat the calibration, including a time-ordered split
q128–q129localised as the main excess error, consistent with IBM's own coherence data
The problem

Decoders are only as good as the noise model they are given.

A quantum error-correction decoder has to guess which errors happened. To guess well it needs to know how likely each error is. Today that usually comes from the published calibration: measured hours or days earlier, with different circuits, and averaged.

Noise drifts

Qubits and couplers change between calibrations. A gate that was fine yesterday can be several times worse today.

Calibration measures something else

Published readout error is measured at the end of a circuit. Error correction measures and resets qubits mid-circuit, every round, and that is often much worse.

Every chip is different

Each processor, and each region of it, has its own pattern of errors. One average model fits none of them exactly.

First hardware result · 18 November 2026

On IBM's ibm_kingston, the measured model halved logical errors.

We ran a distance-5 repetition code (9 qubits, 10 rounds, 30,000 shots) through IBM's free Open Plan. Each noise model was fitted on half the shots and tested on the other half, which it never saw. Six different splits; the same PyMatching decoder every time.

Bar chart of logical error for six train/test splits. Syndromics and correlation re-weighting are near 0.2 percent; IBM calibration near 0.4 percent; uniform near 0.45 percent.
Logical error on held-out shots for each split. Job dbukcjvf8rhs73bmf9l0.
Noise model given to the decoderLogical error
No decoding2.22%
Uniform (no device data)0.447%
IBM published calibration0.396%
Standard correlation re-weighting0.199%
Syndromics0.198%
We say this plainly: the standard model-free correlation method from the literature matches our decoding gain on this small code. What Syndromics adds is a physical model: it names the component responsible, so the same measurement can guide qubit placement and recalibration, and potentially be reused across circuits.
Map of the nine-qubit line on the ibm_kingston heavy-hex lattice, with the q128 to q129 gate highlighted in red.
The 9-qubit line on the 156-qubit heavy-hex lattice. Red: the q128–q129 gate, the largest excess (at least 4× its calibrated error). Orange: a second gate and three measurements 2–4× worse than calibrated.
Heatmap of detection-event rate per measure qubit and round. q129 is highest in every round, around 3.5 to 3.9 percent.
Raw detection-event rate, no model involved. q129, next to q128, fires most often in every round. IBM's own data shows q128 with the lowest T2 on the line (53 µs).
Scope. One run, one 9-qubit line, one day, a repetition code (bit-flip errors only). These are first results, not a characterisation of the processor. The next experiments are listed below.
How it works

From syndromes to a physical noise model in seconds.

1

Run a short code

One job: a small error-correction circuit plus a few reference circuits on the qubits you care about. Minutes of QPU time.

2

Fit the components

Starting from the calibration, Syndromics fits one factor per measurement, idle and two-qubit gate, so the model reproduces the measured detection rates and correlations. It moves a component only when the data clearly disagree.

3

Use the model

Hand the corrected model to any decoder, flag the components that have drifted, and steer circuits away from them with noise-aware qubit placement.

Check it yourself

Every number above reproduces on your laptop.

The demo kit includes the raw shots from our ibm_kingston job. Reproducing the result needs no IBM account and no QPU time. With an IBM Quantum account, the same kit runs the experiment on any Heron backend, on a line it chooses.

# Python 3.10–3.13
git clone https://github.com/wishapples/syndromics.git
cd syndromics
pip install -e ".[ibm,dev]"

# reproduce our ibm_kingston result (seconds, no QPU)
pytest tests/test_decodecheck_real.py -q

# run it on your own IBM backend
syndromics-ibm-demo check
syndromics-ibm-demo validate --backend ibm_kingston --yes
What's next

From one run to a repeatable record.

Done · Nov 2026

First hardware run

ibm_kingston: logical error halved vs calibration; fault localised.

Next

Transfer test

Fit on one circuit, decode a different one on the same qubits: the test the standard method cannot pass.

Then

Across lines and days

Does the gain repeat? A chip-wide health check of what has drifted since calibration.

Later

Surface and qLDPC codes

Codes that see both error types; measured priors for belief-propagation decoders.