Skip to main content
Introducing The Quantum Infrastructure Cloud Learn more

QCOS™ QEC Stack

Quantum Error Correction for production clouds

From stabilizer algebra to fault-tolerant certification — validated on the QCOS CPU state-vector simulator.

  • Validated on CPU state-vector simulator
  • QLDPC-ready

Opening film: a SoftQuantus render of a rotated surface code, showing syndrome measurement and decoding as an illustration. It is not footage of hardware.

A satin aluminium chip carrying a rotated surface code of distance 7: light and dark check plaquettes in a checkerboard, qubit pins at the corners, inside a stippled frame

A complete QEC middleware that implements generalized bicycle QLDPC codes targeting sub-10⁻¹² logical error rates, BP+OSD decoding, Pauli-based computation compilation, and SHA-256-sealed fault-tolerant isolation certificates — all tested end-to-end on the QCOS CPU state-vector simulator.

Qubits SimulatedQCOS CPU state-vector simulator
≤ 24
Content HashSeal on each certificate record
SHA-256
qec_certificate.jsonIllustrative sample, not a real execution record
{
  "code": "GB [[8, 2, 2]]",
  "backend": "cpu_state_vector",
  "syndrome": "clean",
  "decoder": "bp_converged",
  "bp_iterations": 1,
  "isolation_verified": true,
  "certificate_id": "<uuid>",
  "certificate_hash": "<sha256>"
}
An exploded stack of three plates: physical qubits at the bottom, a surface-code layer edged in cyan in the middle, and three logical qubits on top, one of them violet

A QEC layer between quantum backends and fault-tolerant computing

Raw qubit access does not include the QEC middleware needed for fault tolerance. Without it, there is no tenant isolation, no transparent error correction, and no verifiable certification that a computation ran within FT guarantees.

  1. 01

    No tenant isolation

    Errors in one logical computation can propagate to another tenant's qubits on shared hardware.
  2. 02

    No transparent QEC

    Application developers shouldn't need to manage syndrome extraction, decoding, and correction manually.
  3. 03

    No certification

    No sealed record of the conditions under which a computation executed.

Use case

From a physical error to a sealed certificate record

What the stack does with one fault, from the moment it appears to the record it leaves.

A metal tile carrying a surface-code lattice: two neighbouring qubits glow amber and the two checks at the ends of the error chain light cyan
Illustration of the pipeline. It runs on the QCOS CPU state-vector simulator, not on quantum hardware.
  1. The syndrome circuits measure the X and Z checks around it. The checks that touch the faulty qubit fire.

Six white modules seen from above, numbered 01 to 06 and joined in order by dashed traces, the decoder module dark with a violet face

Six modules. One integrated stack.

~4,200 lines of Python covering the full pipeline from symplectic Pauli algebra to SHA-256-sealed fault-tolerant certificate records.

  1. 01

    Stabilizer Algebra

    stabilizer.py — 803 lines

    Symplectic Pauli operator representation over GF(2). CHP-style stabilizer tableau for efficient state simulation. Commutation checking, tensor products, and GF(2) row reduction — no external finite-field libraries.

    PauliOperator (frozen, symplectic) · StabilizerGroup (commutativity validation) · StabilizerTableau (CHP simulation) · GF(2) row reduction & null-space

  2. 02

    Code Library

    codes.py — 721 lines

    Repetition, Surface, generalized bicycle (GB) and bivariate bicycle (BB) QLDPC codes — a code family targeting logical error rates below 10⁻¹² (analytical design target, not a hardware measurement). Catalog includes codes up to [[288, 12, 18]].

    RepetitionCode [[n, 1, n]] · SurfaceCode [[d², 1, d]] · GeneralizedBicycleCode (QLDPC) · BB catalog: [[72,12,6]] → [[288,12,18]] (Bravyi et al., 2024)

  3. 03

    BP+OSD Decoder

    decoder.py — 621 lines

    Two-stage decoder pipeline: belief propagation (min-sum or sum-product) on the Tanner graph, with ordered-statistics decoding (OSD-0/w) fallback. Converges in 1–2 iterations for all tested codes.

    Min-sum & sum-product BP · OSD-0 and OSD-w fallback · 1–2 iteration convergence · Tanner-graph message passing

  4. 04

    Syndrome Extraction

    syndrome.py — 347 lines

    Automated Qiskit circuit synthesis for any QuantumCode. Builds X-check and Z-check sub-circuits with ancilla allocation, measurement, and majority-vote syndrome decoding from shot statistics.

    Automatic circuit synthesis · X/Z check sub-circuits · Ancilla management · Majority-vote decoding

  5. 05

    PBC Compiler

    pbc.py — 865 lines

    Pauli-based computation compiler that separates Clifford operations (tracked classically via symplectic frame) from non-Clifford T gates (requiring quantum execution).

    Clifford frame tracking (Sp(2n,F₂)) · Magic state injection · Classical Clifford tracking · T-count preservation (100%)

  6. 06

    FT Isolation Certifier

    ft_isolation.py — 762 lines

    Fault-tolerant isolation certification with 6 levels (physical → logical → sealed). Issues a certificate record per execution, sealed with a SHA-256 content hash, with syndrome leakage rates and logical error bounds.

    6 isolation levels · SHA-256 content hash · Syndrome leakage tracking · Tamper-evident seal

Two qubit grids on dark tiles: the left one wired only to its neighbours, the right one with long violet and cyan arcs linking distant qubits

Next-Generation QLDPC

Bicycle QLDPC Codes

Generalized bicycle (GB) and bivariate bicycle (BB) codes are quantum low-density parity-check codes; the BB codes in the catalog are those of Bravyi et al., Nature 627, 778 (2024), including the [[144, 12, 12]] gross code. They target logical error rates below 10⁻¹² with fewer physical qubits than traditional surface codes. These are analytical design targets, not hardware measurements.

The surface code bottleneck

  • Surface codes require d² physical qubits per logical qubit — 1,000+ for useful error rates
  • No built-in Clifford optimization — every gate runs on hardware
  • No cryptographic certification of fault-tolerant execution

The QCOS QEC approach

  • Bicycle QLDPC codes encode k logical qubits in one block: [[144, 12, 12]] holds 12 at distance 12
  • BP+OSD decoder: belief propagation with an ordered-statistics fallback
  • PBC compiler tracks Cliffords classically — only non-Clifford T gates need quantum execution
  • Every execution receives a fault-tolerance certificate record sealed with a SHA-256 content hash
Traditional approach compared with the QCOS QEC Stack
CapabilityTraditional ApproachQCOS QEC StackAdvantage
Code familySurface codes (high overhead)GB QLDPC (low-density parity-check)Up to 10× fewer physical qubits
Qubit overheadd² physical per logical qubit2m physical for k logical qubitsSub-linear scaling with distance
Logical error rate~10⁻⁶ at d=5Target <10⁻¹² at [[144,12,12]] (analytical, not measured)Up to 6 orders of magnitude lower, as a design target
Clifford executionRun on quantum hardwareTracked classically via PBCOnly non-Clifford T gates need quantum execution
FT certificationNot providedSHA-256 content hash per executionAudit-ready records built in

QCOS QLDPC Code Catalog

QCOS QLDPC Code Catalog
CodeParametersn/2Qubits (+ anc)Status
gb_8_2_2[[8, 2, 2]]416Simulator validated (test fixture)
gb_10_2_3[[10, 2, 3]]520Simulator validated (test fixture)
bb_72_12_6[[72, 12, 6]]36144Unit tested
bb_144_12_12[[144, 12, 12]]72288Unit tested
bb_288_12_18[[288, 12, 18]]144576Unit tested

Bicycle codes take H_X = [A | B] and H_Z = [Bᵀ | Aᵀ] with A, B in a commutative group algebra: F₂[Z_m] for GB codes, F₂[Z_ℓ × Z_m] for BB codes. Then H_X · H_Zᵀ = AB + BA = 0, so the CSS condition holds by construction.

A threshold plot made as an object: lines for code distances 3 to 11 on an upright panel cross at one point on a dashed threshold line, the distance-11 line in violet

Simulator Validated

End-to-end simulator validation

The full pipeline — circuit synthesis → CPU state-vector execution → syndrome extraction → BP decoding → PBC compilation → FT certification — runs on the QCOS CPU state-vector simulator (≤ 24 qubits).

Simulation Setup

Platform
QCOS
Backend
CPU state-vector simulator
Qubit limit
≤ 24 qubits
Circuit SDK
Qiskit

Execution Paths

  • CPU state-vector≤ 24 qubits
  • Trapped-ionSoftquantus Cloud
  • SuperconductingSoftquantus Cloud
  • Neutral-atomSoftquantus Cloud

Simulator results — Illustrative sample, not a real execution record

Simulator results — Illustrative sample, not a real execution record
CodeParamsQubitsSyndromeDecoderFT Cert
Repetition-3[[3, 1, 3]]5CleanBP (1 iter)Verified
Surface-3[[9, 1, 3]]18CleanBP (1 iter)Verified
GB [[8,2,2]][[8, 2, 2]]16CleanBP (1 iter)Verified

Error Injection & Correction Validation

Error Injection and Correction Validation
CodeInjectedBeforeAfterCorrected
Rep-3X on q₁[0,0][1,0]Yes
Rep-5X on q₂[0,0,0,0][0,0,0,0]Yes
GB-8X on q₄[0,0,0,0][1,0,0,1]Yes
GB-10X on q₅[0,0,0,0,0][1,1,1,0,1]Yes
Six square plates stacked in steps, graphite and aluminium in turn, labelled L0 to L5 and rising to a green seal at the centre

Six levels of fault-tolerant isolation

From individual qubit separation to SHA-256-sealed logical isolation records. Each execution produces a certificate record with a SHA-256 content hash.

Sample certificate records — Illustrative sample, not real execution records

  • Repetition-3Verified
  • Surface-3Verified
  • GB [[8,2,2]]Verified
  1. L0

    PHYSICAL_QUBIT

    Individual qubit spatial separation
  2. L1

    PHYSICAL_ZONE

    Guard qubits between tenant zones
  3. L2

    PHYSICAL_DEVICE

    Separate cryostats / ion traps
  4. L3

    LOGICAL_BASIC

    QEC active, bounded error rate
  5. L4

    LOGICAL_CERTIFIED

    Syndrome verification passed
  6. L5

    LOGICAL_ATTESTED

    SHA-256 sealed, tamper-evident
Five metal rails on a dark bed carrying frosted glass cubes for Clifford gates and a few solid violet diamonds for T gates

Cliffords tracked classically, T gates executed

The PBC compiler tracks Clifford operations classically via a symplectic frame — only T gates and measurements require actual quantum execution. In FTQC architectures, Clifford gates are "free" but T gates cost magic state distillation. Our compiler makes this explicit.

T-count preservationNo T-count overhead
100%
Measurement depthAll T gates parallelized
1

Pauli-Based Computation Pipeline

  1. 01

    Input Circuit

    H, CNOT, S, T gates
  2. 02

    Clifford Frame Tracking

    Classical (free)

    Classical Sp(2n,F₂) simulation
  3. 03

    Magic State Injection

    Quantum (costly)

    T gates → distillation circuits
  4. 04

    PBC Program Output

    Certified output · FT

    Only measurements + corrections
Three modules plugged into one aluminium QCOS rail, the middle one dark with a green link

Built for QCOS integration

The QEC stack plugs directly into the QCOS operating system as the error correction middleware layer.

Multi-Tenant Isolation

Each tenant is assigned an isolated logical zone under a modelled physical qubit separation policy, with an FT certificate record carrying a SHA-256 content hash. Evaluated in simulation only.

Transparent QEC

Applications submit logical circuits. Code selection, syndrome scheduling, decoding, and correction happen automatically.

Pricing Metrics

T-count, Clifford savings and measurement depth are reported as resource metrics for each run.

Fault-tolerant quantum computing starts here

The QEC stack is built for fault-tolerant workflows. Validated on the QCOS CPU state-vector simulator (≤ 24 qubits).

Technical resources:

  • White paper (PDF)
  • API documentation
  • Illustrative sample certificate (JSON)

Stay updated on QCOS QEC

Get the latest on QEC stack releases, simulator validation results, and fault-tolerant computing research.

Back to QCOS™