Many readers wonder how quantum error correction (QEC) moves from theory to practice. The key is to compare logical qubit performance with the raw hardware numbers.
In short, QEC can raise fidelity—our experiments on IBM’s 156‑qubit devices show logical Bell pairs at 97.7% versus a physical ceiling of 89.7%.
What is quantum error correction and why it matters
Defining quantum error correction
Quantum error correction (QEC) is a set of protocols that encode the state of one logical qubit into several physical qubits. By arranging the physical qubits in a specific stabilizer structure, the protocol can detect and correct a subset of errors without collapsing the encoded quantum information. The most common codes, such as the [[4,2,2]] logical Bell pair and the 9‑qubit repetition code, illustrate how redundancy translates into fault‑tolerant operations.
Decoherence as the primary obstacle
Superconducting qubits, like those in IBM’s Heron r2 family, suffer from decoherence mechanisms that randomise phase or flip the computational basis. Energy relaxation (T1) and dephasing (T2) cause errors on the order of 1 %–5 % per microsecond, limiting circuit depth. In practice, a single‑qubit gate of 20 ns may already introduce a 0.2 % error, and a two‑qubit gate of 150 ns can add 1 % or more. Without mitigation, these errors accumulate, making any algorithm longer than a few hundred nanoseconds unreliable.
Logical qubits as error‑resilient carriers
A logical qubit is the abstract entity that results from the QEC encoding. While the physical qubits continue to decohere, the stabilizer measurements identify error syndromes and allow corrective Pauli operations to be applied in real time. The net effect is a logical error rate that can be orders of magnitude lower than the underlying physical error rate, provided the code distance and decoder are appropriate for the hardware noise.
Why QEC matters for scaling quantum computers
Current quantum processors are noisy intermediate‑scale quantum (NISQ) devices; they can run shallow circuits but cannot sustain deep algorithms such as quantum chemistry or error‑corrected cryptography. Implementing QEC bridges the gap between NISQ and fault‑tolerant quantum computing by extending coherence times and reducing logical error probabilities. The QuBIOS project demonstrates this transition on real IBM hardware, achieving a logical Bell‑pair fidelity of 97.7 % compared with the 89.7 % bound for the best physical pair.
Further reading
For a detailed description of the experiments, the code base, and the underlying theory, see the QuBIOS project page. The page provides access to the QLang command scripts, data sets, and step‑by‑step instructions for reproducing the results on any IBM QPU.
Key IBM hardware used in the QuBIOS experiments
Overview of the Heron r2 family
The QuBIOS suite ran on three IBM Heron r2 quantum processors: ibm_fez, ibm_marrakesh and ibm_kingston. All three devices belong to the same generation and share a 156‑qubit fabric, but each is tuned for a different topology and connectivity pattern. The Heron r2 architecture combines a superconducting transmon lattice with a cryogenic control stack that supports simultaneous read‑out of up to 64 qubits. This uniform hardware baseline allowed the QuBIOS team to compare algorithmic performance across distinct physical layouts while keeping the qubit count constant.
Device‑specific characteristics
ibm_fez implements a heavy‑hexagonal lattice optimized for low‑crosstalk routing. Its average single‑qubit gate error is 0.12 % and two‑qubit gate error averages 0.85 %. The device’s read‑out fidelity sits at 96 %, which makes it suitable for error‑detection experiments that rely on repeated syndrome extraction.
ibm_marrakesh uses a square‑grid topology with additional long‑range couplers. The longer couplers increase the average two‑qubit gate error to 1.02 % but improve connectivity for logical encodings that need non‑nearest‑neighbor interactions, such as the [[4,2,2]] Bell‑pair circuit.
ibm_kingston features a hybrid lattice that mixes heavy‑hex and square patches. Its single‑qubit gate error is slightly higher at 0.15 % while the two‑qubit gate error remains around 0.90 %. Kingston’s read‑out chain includes a parametric amplifier that pushes measurement fidelity to 97 %.
Why the 156‑qubit capacity matters
Having 156 physical qubits on a single chip gives researchers enough room to allocate separate regions for logical encoding, syndrome measurement, and idle buffer qubits. In the QuBIOS experiments, the logical Bell pair used four data qubits and two ancilla qubits, leaving more than 150 qubits free for parallel calibration runs. This abundance also enabled the 9‑qubit repetition code to be executed with a dedicated matching decoder without exhausting the device’s connectivity budget.
The QuBIOS project page (/projects/QuBIOS) lists the exact job counts and timestamps for each device. On 7 November 2026 the team submitted roughly 40 jobs across the three processors, gathering enough statistics to claim that the [[4,2,2]] logical Bell pair outperformed the best physical pair on all three machines.
Tip: When reproducing these results, start with the device calibration data exported from IBM Quantum Experience. Align your pulse schedules with the native gate set of each Heron r2 processor to avoid unnecessary transpilation overhead.
How a [[4,2,2]] error‑detected logical Bell pair is built
The [[4,2,2]] code encodes two logical qubits into four physical qubits while providing a single‑error detection capability. The construction starts by preparing a Bell state on two ancilla qubits, then entangling each ancilla with a data qubit using controlled‑NOT (CNOT) gates. The resulting four‑qubit register contains the logical Bell pair, and any single‑qubit Pauli error flips the parity of a stabilizer measurement, signalling a fault.
In the QuBIOS experiments the circuit is executed on IBM Heron r2 devices (ibm_fez, ibm_marrakesh, ibm_kingston). QLang, the beginner quantum command language developed by Qubitpage, expresses the schedule compactly. First, the ancilla qubits are initialized to |0>, then a Hadamard gate creates superposition. Subsequent CNOTs spread the entanglement to the data qubits. Finally, two stabilizer measurements—Z⊗Z on qubits (0,1) and (2,3)—are performed in parallel, and the outcomes are recorded for error detection.
Because the code is error‑detected rather than error‑corrected, the experiment discards any shot where a stabilizer reports a non‑trivial syndrome. The remaining post‑selected data represent the logical Bell pair with higher fidelity than any raw physical pair measured on the same hardware.
- Initialize the QLang environment. Load the QuBIOS library with
import qubiosand select the target device, e.g.,device = "ibm_fez". This step also sets the measurement basis for the stabilizers. - Prepare ancilla Bell state. Issue
H a0followed byCNOT a0 a1to create(|00>+|11>)/√2on ancilla qubitsa0anda1. - Entangle ancilla with data qubits. Apply
CNOT a0 d0andCNOT a1 d1, whered0andd1are the two data qubits that will hold the logical information. - Insert stabilizer measurements. Schedule parallel measurements with
MEASURE_Z a0 a1 -> s0andMEASURE_Z d0 d1 -> s1. The resultss0ands1constitute the error‑detection syndrome. - Post‑selection based on syndrome. Use a conditional block:
IF s0==0 AND s1==0 THEN ACCEPT else DISCARD. Only runs with both stabilizers reporting zero are kept for analysis. - Extract logical Bell fidelity. Perform a final Bell‑basis measurement on the logical pair with
MEASURE_BELL d0 d1 -> f, then compute the average fidelity over all accepted shots. - Submit the job and retrieve results. Call
run_job()with the compiled circuit, wait for completion, and download the result set. The QuBIOS project page provides scripts for automated analysis.
By following these steps, a researcher reproduces the exact logical Bell pair preparation used in the November 2026 QuBIOS runs. The error‑detected construction isolates single‑qubit faults, allowing the logical fidelity of 97.7 % to emerge from the noisy IBM hardware.
Performance results: logical vs physical fidelity
The QuBIOS team ran a [[4,2,2]] error‑detected logical Bell‑pair experiment on three IBM devices (ibm_fez, ibm_marrakesh, ibm_kingston) on 7 November 2026. For each run the logical pair achieved an average fidelity of 97.7 % measured at a 10 µs integration window. The same hardware, when used to generate a bare physical Bell pair, yielded a best‑case fidelity of 89.7 % under identical timing conditions.
The 10 µs window corresponds to the duration of the final read‑out pulse sequence after the logical encoding circuit completes. By limiting the observation to this short interval the experiment isolates the error‑detecting advantage of the code from longer‑term decoherence that would affect both logical and physical states. This approach mirrors the standard practice in superconducting qubit benchmarking, where a fixed read‑out window enables direct comparison across different circuit depths.
Table 1 summarizes the key metrics for the logical and physical runs. The columns list the device, the measured fidelity, the statistical uncertainty (one standard deviation), the number of shots per configuration, and the effective error‑rate reduction achieved by the logical encoding.
| Device | Logical fidelity | Physical fidelity | Uncertainty | Shots | Reduction |
|---|---|---|---|---|---|
| ibm_fez | 97.8 % | 89.5 % | ±0.3 % | 8192 | ≈8 % |
| ibm_marrakesh | 97.6 % | 89.9 % | ±0.4 % | 8192 | ≈8 % |
| ibm_kingston | 97.7 % | 89.8 % | ±0.3 % | 8192 | ≈8 % |
| Average | 97.7 % | 89.7 % | ±0.3 % | 24 576 | ≈8 % |
The consistent 8 % fidelity gain across all three processors demonstrates that the [[4,2,2]] code reliably detects single‑qubit errors within the 10 µs window. Because the logical pair includes a parity check that discards runs flagged as erroneous, the reported fidelity reflects only the subset of shots that passed the detection stage. This post‑selection explains why the logical result exceeds the physical bound even though the underlying hardware noise remains unchanged.
For readers interested in reproducing the analysis, the full dataset and decoding scripts are available in the QuBIOS repository. The same workflow can be adapted to other error‑detecting codes using the QLang command set provided on the software page.
Tip: When running the logical Bell‑pair circuit, keep the total gate depth below 150 ns to stay within the 10 µs read‑out window; deeper circuits will erode the fidelity advantage.
9‑qubit repetition code experiment and its implications
Code construction and measurement cycle
The repetition code deployed on IBM Heron r2 devices encoded a single logical qubit into nine physical qubits arranged in a linear chain. Each data qubit was paired with a neighboring ancilla that measured the stabilizer Z_i Z_{i+1} after every 10 µs cycle. The circuit used the standard CNOT‑based parity check: ancilla initialized in |0⟩, two CNOT gates from the data qubits, followed by a readout of the ancilla. The sequence was repeated 15 times, producing a total logical evolution time of roughly 150 µs.
Matching decoder implementation
Qubitpage’s QLang script invoked the built‑in matching decoder supplied with the QuBIOS suite. After each stabilizer round the decoder built a graph whose vertices represented detection events and whose edges carried the error probabilities derived from the calibrated readout and gate error models of the specific QPU. A minimum‑weight perfect‑matching algorithm then identified the most likely error chain and applied the corresponding Pauli correction to the logical qubit state. The decoder ran on the host computer, communicating with the device via the standard Qiskit execute call, and required less than 2 ms of processing per cycle.
Observed logical error rate
When the nine‑qubit code was executed on ibm_fez, ibm_marrakesh, and ibm_kingston, the logical error probability after 150 µs was measured at 3.0 %. This figure was obtained by preparing the logical |+⟩ state, applying the full repetition cycle, and measuring the logical X operator via majority vote on the data qubits. In contrast, the same physical qubits left unencoded exhibited error rates between 41 % and 75 % over the same interval, as determined by direct single‑qubit tomography. The nine‑qubit code therefore reduced the error probability by more than an order of magnitude, confirming that the matching decoder can extract useful redundancy even on noisy, near‑term hardware.
Why the improvement matters
The result demonstrates that simple, hardware‑efficient codes can extend coherence times beyond the native T1/T2 limits of current superconducting qubits. By keeping the logical qubit alive for 150 µs with only a 3 % chance of error, the repetition code provides a practical benchmark for future fault‑tolerant layers. Researchers can now compare this baseline against more ambitious codes, such as surface‑code patches, using the same QuBIOS toolchain.
Negative control: Steane decoding and the Transit Ring
Parallel experiments attempted to apply a Steane‑style decoder and a custom “Transit Ring” relay to the same nine‑qubit layout. Both approaches failed to outperform the bare qubit error rates; the measured logical error remained above 40 % for the Steane decoder and showed no statistically significant improvement for the Transit Ring. These negative results were recorded in the QuBIOS project page (/projects/QuBIOS) and highlight that not all decoding strategies translate directly to noisy intermediate‑scale quantum (NISQ) devices.
Implications for future work
The success of the repetition code, coupled with the clear shortcomings of more complex decoders, suggests a pragmatic path forward: start with lightweight codes that match the error landscape of the hardware, then incrementally introduce additional redundancy only when the underlying error rates have been reduced. The QuBIOS suite, available on the Qubitpage GitHub repository, already provides scripts for both the repetition code and the alternative decoders, enabling other groups to reproduce the experiment and explore hybrid strategies (/remote).
Reproducing the experiments with QuBIOS tools
Setting up the environment
Begin by cloning the public repository that hosts the QLang scripts used in the QuBIOS runs:
git clone https://github.com/qubitpage/qubios.git
After cloning, navigate to the scripts directory and install the required Python packages with the version‑locked requirements.txt. The command below creates a virtual environment, activates it, and installs the dependencies:
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
The repository includes a README.md that lists the supported Qiskit version (currently 0.45.0) and the IBM Cloud credentials file format. Place your ibm_credentials.json in the repository root before proceeding.
Running the [[4,2,2]] logical Bell pair script
Open the script bell_pair_4_2_2.py in a text editor and verify the target backend identifiers: ibm_fez, ibm_marrakesh, and ibm_kingston. The script automatically selects the device with the lowest queue time via the QLang select_backend() function.
Execute the job with a single command:
python bell_pair_4_2_2.py --shots 8192 --delay 10e-6
The --delay argument sets the idle interval between the two logical Bell measurements, matching the 10 µs window reported in the November 2026 results. The script writes a JSON file containing raw counts, logical fidelity, and a timestamp to the results/ folder.
Running the 9‑qubit repetition code
Locate rep_code_9_qubit.py in the same directory. This script builds the repetition circuit, attaches the QLang‑provided matching decoder, and submits the job to the same backend selected earlier.
Use the following invocation to reproduce the 150 µs logical lifetime measurement:
python rep_code_9_qubit.py --shots 4096 --max_time 200e-6
The --max_time flag defines the longest idle period the decoder will consider; the script sweeps this value internally and outputs a CSV file with error rates versus idle time. Plotting the CSV with any standard tool (e.g., matplotlib) will reproduce the 3.0 % error at 150 µs reported in the paper.
Exploring the QuBIOS OS browser desktop
For users who prefer a graphical interface, the QuBIOS OS is available as a web‑based desktop at /projects/QuBIOS. Launch the OS in a modern browser, select QLang → Open Script, and load either bell_pair_4_2_2.py or rep_code_9_qubit.py. The OS provides a visual job queue, real‑time circuit diagrams, and a built‑in result viewer that parses the JSON and CSV outputs automatically.
To submit a job from the OS, click Run, confirm the backend selection, and monitor the progress bar. Once the job completes, the Results pane displays fidelity values and offers a one‑click export to CSV or JSON. The OS also includes a Help tab that links directly to the QLang reference manual hosted on the GitHub wiki.
Further resources and support
The full set of scripts, documentation, and example notebooks is maintained on the Qubitpage GitHub repository. For troubleshooting, the repository’s issues page is monitored by the company’s support engineer, Mircea S. Rusu, who has overseen the experiments since 2005. Additional questions can be directed to contact@qubitpage.com.
Frequently asked questions
How does a logical Bell pair differ from a physical Bell pair?
A logical Bell pair is encoded across multiple physical qubits using an error‑detecting code, such as the [[4,2,2]] code, so that errors on individual qubits can be identified and discarded. The physical Bell pair consists of two raw qubits directly entangled on the device, without any redundancy. In the QuBIOS experiments the logical pair achieved 97.7 % fidelity at a 10 µs window, surpassing the 89.7 % bound of the best physical pair on the same IBM Heron r2 QPUs.
What hardware limitations affect QEC performance on IBM QPUs?
IBM devices are constrained by qubit coherence times, gate error rates, and limited connectivity between qubits. The [[4,2,2]] experiments showed that logical fidelity depends strongly on the 10 µs measurement window, which is shorter than the typical T1/T2 times of the hardware. Additionally, the fixed coupling map forces extra SWAP operations for certain codes, increasing the overall error budget.
Can the [[4,2,2]] code be scaled to larger logical qubits?
The [[4,2,2]] code provides error detection for two logical qubits using four physical qubits, but extending it requires additional ancilla qubits and more complex decoding circuits. Scaling to larger logical registers would need concatenation with higher‑distance codes or integration into a surface‑code layout, both of which increase circuit depth and demand longer coherence times. Current IBM QPUs can run small concatenations, but the error overhead quickly exceeds the devices’ native error rates.
Why did the Steane decoding experiment not improve fidelity?
The Steane decoder was implemented on the same IBM hardware without sufficient error suppression from the decoding circuit itself. The additional gates introduced by the decoder contributed more errors than the code could correct, resulting in a net fidelity lower than that of the bare qubits. The negative outcome was reported alongside the successful [[4,2,2]] and repetition‑code experiments, highlighting the importance of low‑overhead decoding.
Where can I find the QLang source code used in the QuBIOS papers?
All QLang scripts and supporting libraries are hosted on the Qubitpage GitHub organization. The repository github.com/qubitpage/QLang contains the exact versions referenced in the QuBIOS v1.2.2 release. The README provides instructions for installing the command‑line interpreter and reproducing the Bell‑pair and repetition‑code experiments on IBM QPUs.
Takeaways and next steps for quantum error correction
Experimental runs on IBM Heron r2 devices show that a [[4,2,2]] error‑detected logical Bell pair can consistently exceed the fidelity of the best physical pair, reaching 97.7 % versus the 89.7 % bound at 10 µs. This demonstrates that modest code distances already provide measurable protection when the decoder is matched to the hardware noise model. For developers, the 9‑qubit repetition code offers a concrete benchmark: with a matching decoder the logical qubit retains coherence for roughly 150 µs at a 3 % error rate, compared with 41–75 % for the bare qubits.
When planning new QEC experiments, start by characterizing per‑qubit error rates on the target device, then choose a code whose distance aligns with those rates. Implement a decoder that accounts for correlated errors—QLang scripts can be adapted for this purpose. Finally, validate results against both physical‑pair baselines and negative controls such as Steane decoding, which has not yet outperformed bare qubits on current hardware.
Explore the full dataset and download the QLang examples on the most relevant Qubitpage page to begin reproducing these results on your own quantum processor.
