Quantum Error Correction Methods

---
name: quantum-error-correction-methods
description: "Reusable patterns from quantum error correction research. Covers RL-controlled QEC, fault-tolerant architectures, neutral-atom systems, Bacon-Shor codes, and loss-biased codes. Use when analyzing QEC papers, designing fault-tolerant quantum systems, selecting error correction codes, or comparing QEC approaches."
---

# Quantum Error Correction Methods

## Related Skills
- [[permutation-invariant-qec-recovery]] — QER for permutation-invariant codes under correlated amplitude-damping noise; CAD code family (arXiv: 2607.02346)
- [[spatially-coupled-quantum-codes]] — Spatially coupled CSS codes achieving quantum erasure hashing bound via seeded BP (arXiv: 2606.32001)
- [[real-time-qec-system-stack]] — Six-layer real-time QEC system architecture, decoder benchmarking, and latency budgets (arXiv: 2605.30765)
- [[symmetry-protected-quantum-metamaterials]] — Symmetry-protected qubit architecture (arXiv: 2606.00254)
- `tensor-network-readout-error-mitigation` — MPO-based correlated readout error characterization and mitigation (arXiv: 2606.25974)
- `pauli-propagation-error-mitigation` — Hybrid Pauli propagation + quantum noise cancellation for observable estimation (arXiv: 2606.20441)
- `adaptive-syndrome-skipping-surface-gkp` — Syndrome adaptive gain control for surface and GKP codes (arXiv: 2606.24469)
- `monitored-clifford-purification` — Universal purification dynamics of monitored Clifford circuits reducing to exactly solvable Markovian death process, bypassing replica trick (arXiv: 2607.06683)

## Core Patterns

## Pattern 1: RL-Controlled Quantum Error Correction

**Core idea**: Use reinforcement learning to adaptively control QEC instead of halting computation for recalibration.

**Problem**: Environmental drift degrades quantum operations over time. Traditional approach: stop computation, recalibrate, resume — unsustainable for long algorithms.

**RL solution**:
- State: Syndrome measurements, drift indicators
- Action: Adjust error correction parameters
- Reward: Logical error rate reduction
- Continuous online adaptation without interrupting computation

**Key paper**: "Reinforcement Learning Control of Quantum Error Correction" (arxiv:2511.08493)

## Pattern 2: Neutral-Atom Fault-Tolerant Architecture

**Core idea**: Reconfigurable neutral-atom arrays for scalable fault-tolerant quantum computing.

**Key results (Harvard, 2025)**:
- 448 neutral atoms in reconfigurable array
- Integrated all core elements of scalable error-corrected computation
- Repeatable error correction with present-day technology
- Roadmap: high-fidelity gates + scalable atom control + robust decoding

**Architecture pattern**:
1. Physical qubits in 2D atom array
2. Logical qubits via surface code or similar
3. Reconfigurable connectivity for gate operations
4. Real-time syndrome extraction

## Pattern 3: Measurement-Free Fault-Tolerant Computation

**Core idea**: Fault-tolerant quantum computation without mid-circuit measurements.

**Method**: Bacon-Shor code + code deformation
- All logical operations via unitary gates + resets only
- No mid-circuit measurements needed
- No classical decoding during computation
- Reduces hardware requirements significantly

## Pattern 4: Loss-Biased Quantum Error Correction

**Core idea**: Exploit biased noise channels (loss dominates over other errors) for more efficient QEC.

**Key insight**: Physical error channels are often biased (e.g., photon loss >> dephasing). Design codes that protect against dominant error type more efficiently.

**Applications**: Superconducting qubits, photonic quantum computing, bosonic codes (GKP).

## Pattern 5: Concatenated Code Decoding

**Core idea**: Bidirectional decoding for concatenated quantum Hamming codes.

**Results** (SpinQ + HKUST, QEC 2026):
- Near-optimal effective distance
- More efficient fault-tolerant threshold
- Suitable for near-term quantum processors

## Pattern 6: Adaptive Window Decoding (ADaPT)

**Core idea**: Use decoder confidence to dynamically adjust window size in real-time QEC decoding, reducing reaction time without compromising logical error rates.

**Problem**: Fixed window size `d` in window decoding pays unnecessary overhead per window due to sparsity of average-case errors in QEC.

**Solution** (arxiv:2605.01149, 2026-05-05):
- Monitor decoder confidence during window processing
- Shrink window when confidence is high (sparse errors)
- Expand window only when needed (dense error clusters)
- Achieves target error rate with lower decoding time overhead
- Benchmarked across different codes and hardware-inspired noise models
- Maintains low reaction time while preserving logical error rate performance

**Key insight**: Average-case QEC errors are sparse — most windows don't need full-size processing.

## Pattern 7: FPGA-Based QLDPC Decoding with GARI

**Core idea**: Hardware architecture for correlated error decoding in quantum LDPC codes using Graph Augmentation and Rewiring for Inference (GARI) method.

**Architecture** (arxiv:2605.01035, 2026-05-05):
- Message-passing decoder exploiting detector error model structure from GARI
- Resource reuse with modest parallelism for reduced power/area
- Case study: VCU19P FPGA, 3 decoder cores for [[144,12,12]] bivariate bicycle code
- Average latency: 596 ns per decoding round
- 6x fewer resources than previous GARI-based proposal
- First multi-core decoder implementation for correlated errors on single FPGA

**Design principles**:
- Flexible scaling to any QLDPC code using GARI framework
- Energy-conscious scaling for QEC classical layer
- Real-time decoding constraints met without accuracy compromise

## Pattern 8: Quasi-Dyadic CSS LDPC Code Construction

**Core idea**: Build dual-containing CSS LDPC codes using quasi-dyadic (circulant block) matrices for efficient encoding/decoding and fault tolerance.

**Construction** (arxiv:2605.03631, 2026-05-05):
- Use quasi-dyadic matrices: sparse circulant blocks that commute
- Dual-containing property: H_x · H_z^T = 0 (needed for CSS codes)
- Enables compact representation and efficient algebraic decoding
- Applicable to scalable fault-tolerant quantum computation

**Key advantage**: Circulant structure enables hardware-friendly implementation with reduced memory and computation overhead.

## Pattern 9: Fault-Tolerant Cut-Cat Syndrome Extraction

**Core idea**: Novel syndrome extraction protocol using cut-cat states that prevents error propagation during QEC measurement cycles.

**Method** (arxiv:2604.17339, 2026-04-19):
- Prepare ancillary "cut-cat" states (truncated cat states)
- Use transversal CNOT gates between data qubits and ancilla
- Verify syndrome measurement before applying corrections
- Prevents single physical error from cascading into logical failure

**Benefit**: Reduces syndrome extraction circuit depth and connectivity requirements compared to standard Steane/Shor extraction.

## Pattern 10: Compass Code Dynamic Low-Valency QEC

**Core idea**: Dynamic compass codes with low valency (few connections per qubit) enable scalable QEC on hardware with limited connectivity.

**Method** (arxiv:2604.14299, 2026-04-15):
- Low-valency code structure: each qubit connects to few neighbors
- Dynamic code deformation for adaptivity
- Rapid logical error rate reduction with code scaling
- Practical for near-term hardware with connectivity constraints

## Pattern 11: QEC Decoder Analysis Framework

**Core idea**: Systematic analysis framework for comparing QEC decoders across multiple dimensions.

**Analysis dimensions** (arxiv:2603.20127, 2026-03-20):
- **Belief propagation convergence**: Speed and stability of iterative message passing
- **Trapping set analysis**: Short cycles in Tanner graph that cause decoder failure
- **OSD post-processing**: Ordered statistics decoding to escape local minima
- **Computational complexity**: Classical processing overhead per syndrome round

## Pattern 12: Maximum Likelihood Decoding (MLD) via Three Complementary Lenses

**Core idea**: MLD is provably optimal for QEC but #P-hard in general. Three approaches approximate or solve it:

1. **Statistical Mechanics** (arxiv:2605.17230): Maps MLD to partition functions of disordered spin models. For CSS codes: MLD ↔ partition function of classical spin model with quenched disorder. Each qubit → spin variable; syndrome → random magnetic field; error probability → Boltzmann weight. Decoding threshold = thermodynamic phase transition on Nishimori line: exp(-2βJ) = p/(1-p). Exact MLD via tensor network contraction of the spin model; approximate MLD via belief propagation with guaranteed convergence for tree-like factor graphs. Code geometry determines: computational complexity (low treewidth → exact TN tractable), BP convergence (locally tree-like → converges), optimal contraction order. Below threshold = ordered phase (successful decoding); at threshold = critical point; above threshold = disordered phase (decoding failure). See `references/statistical-physics-qec-decoding.md` for detailed spin model construction and implementation patterns.

2. **Tensor Networks**: Build factor graph from parity check matrix H, contract tensor network to compute marginals. Complexity O(χ^d) where χ is bond dimension. Near-MLD accuracy with polynomial cost.
3. **AI/Neural Decoders**: Autoregressive generative models and recurrent transformers learn P(error|syndrome) from data. Fast real-time decoding on GPU/TPU, accuracy depends on training data quality.

**Integration pattern**: Statistical mechanics for exact threshold estimation (small codes), tensor networks for near-optimal accuracy (moderate distances), neural decoders for real-time throughput (large codes).

**Key paper**: "Maximum Likelihood Decoding of Quantum Error Correction Codes" (arxiv:2605.17230, 2026-05)

## Pattern 13: VarEFTQC — Learning-Based Logical Operation Discovery for Arbitrary QEC Codes

**Core idea**: Given only an encoding circuit (no stabilizer description required), use learning-based optimization to discover physical implementations of logical operations while enforcing structural constraints (transversality, shallow depth). Extended to **VarEFTQC** co-design: jointly optimizes non-additive encodings with noise-adapted logical gate sets.

**Problem**: Discovering logical operations for quantum error-correcting codes is challenging, especially for non-additive codes that lack a stabilizer description. Analytical methods only work for well-studied codes.

**Solution** (arxiv:2605.28162, 2026-05):
1. **Input**: Only the encoding circuit is needed — no stabilizer tableau
2. **Ansatz construction**: Parameterized gate sequences for candidate logical operations
3. **Loss function**: Combines fidelity (correct logical action) with structural constraints (transversality, depth)
4. **Optimization**: Gradient-based or gradient-free methods for non-convex landscapes
5. **VarEFTQC co-design**: Jointly optimizes encoding + logical ops for specific noise models
   - Tailors non-additive encodings to noise characteristics
   - Enforces desired logical gate sets (transversal IQP families, low-depth universal sets)

**Validation**: Rediscover known logical operations on standard stabilizer codes, then extend to non-additive codes.

**When to use**:
- Non-additive codes where analytical methods fail
- Hardware-adapted logical gadget discovery
- Code-device co-optimization for specific noise models
- Exploring codes beyond the stabilizer formalism

**Pitfalls**:
- Non-convex optimization landscape with many local minima — requires careful initialization
- Circuit size scales with code size — may need hierarchical approaches
- Results depend on accurate noise model characterization
- Full simulation verification required

**Key paper**: "Learning Logical Operations for Arbitrary Quantum Error Correction Codes" (arxiv:2605.28162, 2026-05)

## Pattern 15: qLDPC Breakeven on Trapped-Ion with OMG Architecture

**Core idea**: High-rate qLDPC codes achieve breakeven on trapped-ion hardware using optical-metastable-ground (OMG) architecture for addressable mid-circuit measurement and reset.

**Problem**: qLDPC codes require non-local connectivity — surface codes dominate planar architectures. Trapped-ion all-to-all connectivity makes them ideal for qLDPC but mid-circuit measurement traditionally requires ion transport or coolant ions, consuming significant runtime/ion count.

**OMG Architecture** (arxiv:2606.06455, 2026-06):
1. Prepare data + ancilla qubits in ion chain
2. Apply syndrome extraction gates (entangling)
3. Pump ancilla to metastable state (optical transition)
4. Read metastable state via fluorescence detection
5. Reset ancilla via optical pumping to ground state
6. **No ion transport or coolant ions needed**

**Results**:
- [[18,4]] qLDPC code: 9× better logical error rate than previous superconducting demonstration
- **Breakeven achieved**: logical qubit lifetime ≥ physical qubit lifetime
- Tested **9 QECC families** (qLDPC, topological, concatenated) on single device without reconfiguration
- Demonstrates trapped-ion flexibility advantage for QEC code comparison

**When to use**:
- qLDPC code design on flexible-connectivity platforms
- Mid-circuit measurement without hardware overhead
- Multi-code QEC family benchmarking
- Logical qubit breakeven evaluation

**Key metrics**:
- Logical error rate vs physical error rate (breakeven = logical ≤ physical)
- Syndrome extraction cycle time vs coherence time
- Error suppression factor (target: >10× improvement per code generation)

**Pitfalls**:
- **Connectivity mismatch**: qLDPC requires non-local stabilizers; superconducting platforms need SWAP overhead
- **OMG readout fidelity**: Directly impacts syndrome extraction quality
- **Decoding latency**: Must complete within coherence time
- **Code distance trade-off**: Higher-rate qLDPC has lower distance than surface codes of similar size

## Pattern 14: Hybrid Stabilizer-Tensor Network for Non-Clifford Crosstalk

**Core idea**: Simulate surface code QEC under **coherent crosstalk noise** by decomposing noise into Clifford + non-Clifford components, using stabilizer formalism for the Clifford part and matrix product states (MPS) for the non-Clifford corrections.

**Problem**: Surface code QEC simulation assumes Pauli/incoherent noise. Real devices have **coherent crosstalk** (ZZ, XZ, YZ couplings between neighbors) that breaks Gottesman-Knill stabilizer simulation.

**Method** (arxiv:2605.29514, 2026-05):
1. **Decompose** crosstalk noise into Clifford + non-Clifford components
2. **Stabilizer layer**: efficient tableau simulation of Clifford operations
3. **Tensor network layer**: MPS representation of non-Clifford noise as low-rank corrections
4. **Iterate**: alternate stabilizer evolution and TN corrections per QEC round

**Crosstalk Hamiltonian**: H = J_zz Z_iZ_j + J_xz X_iZ_j + J_yz Y_iZ_j (depends on qubit layout and pulse shapes)

**TN compression**:
- Adaptive bond dimension based on entanglement entropy
- Exploit locality: crosstalk limited to nearest-neighbor qubits
- Truncate small Schmidt values (tolerance ~1e-8)

**When to use**:
- Surface code threshold estimation under realistic coherent noise
- Hardware-aware QEC design (pulse sequence optimization)
- Benchmarking beyond Pauli noise assumptions

**Pitfalls**:
- **Bond dimension explosion**: non-Clifford noise creates entanglement → bond dim grows exponentially with rounds. Mitigation: truncate aggressively, use local MPS patches.
- **Clifford approximation error**: ignoring small non-Clifford components underestimates logical error rate.
- **Measurement noise**: framework assumes noise-free syndrome measurements; needs separate treatment for measurement errors.

## Pattern 16: Iterative Low-Order Decoding (ILOD) via Ising Hamiltonian

**Core idea**: Map QEC decoding to classical Ising Hamiltonian ground-state optimization, then decompose the joint Hamiltonian into alternating X-type and Z-type sub-Hamiltonians with Bayesian priors to approximate cross-correlations. This halves the maximum interaction order per sub-problem.

**Problem**: Under phenomenological depolarizing noise, exact joint QEC decoding contains:
- **Toric code**: up to 8-body interaction terms
- **6.6.6 color code**: up to 10-body interaction terms
- X-Z error correlations appear as cross terms in the Hamiltonian

High-order terms cause: solver convergence degradation at larger code distances, inflated runtime, large auxiliary spin overhead when embedding into native 2-body Ising hardware.

**ILOD Algorithm** (arxiv:2606.12301, 2026-06-10):
1. **Decompose** joint Hamiltonian into X-type and Z-type sub-Hamiltonians
2. **Initialize** uniform priors P_X = P_Z
3. **Alternate optimization**:
   - Solve argmin H_X(error_X | P_Z) — X-errors conditioned on Z-prior
   - Update P_X via Bayesian inference from inferred error_X
   - Solve argmin H_Z(error_Z | P_X) — Z-errors conditioned on X-prior
   - Update P_Z via Bayesian inference from inferred error_Z
4. **Converge** when |error - prev_error| < threshold

**Performance**:
- Toric code threshold: 4.73% (vs 4.83% joint formulation — minimal loss)
- Runtime scaling: (0.81)^d empirical ratio vs joint formulation
- Spin reduction: 2.5x fewer spins for 2-body hardware embedding
- **Color code advantage**: ILOD remains convergent at larger code distances where joint formulation fails entirely

**When to use**:
- Hardware embedding on 2-body Ising solvers (D-Wave, simulated annealing)
- Color code decoding at large distances (joint formulation infeasible)
- Any QEC decoder where X-Z cross-correlations dominate Hamiltonian complexity

**Pitfalls**:
- **Near-threshold degradation**: Performance drops ~0.1% below joint at threshold — increase code distance rather than decoder complexity
- **Convergence failure**: Increase iterations, check syndrome consistency, fall back to MWPM for toric codes
- **Bayesian coupling strength (λ)**: Controls influence of cross-priors; too high causes oscillation, too low loses correlation benefit

## Pattern 17: GSC-QEMit — Adaptive Telemetry-Driven Quantum Error Mitigation

**Core idea**: Use a context-forecast-bandit framework to dynamically switch between QEM strategies (lightweight → heavy) as hardware noise drifts, optimizing the mitigation-quality vs runtime-overhead tradeoff.

**Problem**: QEM deployments must balance mitigation strength against computational cost under time-varying noise. Static QEM pipelines either over-mitigate (wasting runtime) or under-mitigate (poor results).

**Solution** (arxiv:2604.24551, 2026-04):

GSC-QEMit composes three coupled modules:

1. **(G) Growing Hierarchical Context**: Builds multi-scale noise telemetry representations
   - Organizes device calibration data (T1, T2, gate fidelities, readout errors) into hierarchical time windows
   - Shorter windows for fast-changing parameters, longer for slow drift
   - Cross-correlates noise across qubits to identify shared noise sources

2. **(S) State Forecast**: Time-series prediction of future noise states
   - Anticipates noise regime transitions (calibration changes, drift events)
   - Provides lookahead for proactive (not reactive) mitigation selection
   - Generates confidence intervals for forecast uncertainty

3. **(C) Contextual Bandit Controller**: Multi-armed bandit for mitigation strategy selection
   - Maps forecast noise state + context to bandit context vector
   - Balances exploration vs exploitation in strategy selection
   - Selects from spectrum: ZNE (light) → PEC (medium) → full QEM suite (heavy)
   - Approaches oracle performance that knows noise in advance

**When to use**:
- VQA and other iterative quantum algorithms (per-iteration mitigation adjustment)
- Long-running quantum workloads where noise drifts significantly
- NISQ devices with available telemetry data
- Scenarios where QEM overhead is a significant fraction of total runtime

**Implementation pattern**:
1. Collect telemetry → build hierarchical context
2. Forecast noise state with confidence bounds
3. Select mitigation strategy via contextual bandit (Thompson sampling or UCB)
4. Execute circuit, record outcome, update bandit rewards
5. Iterate: continuously update context and refine forecasts

**Pitfalls**:
- **No telemetry available**: Fall back to static mitigation or worst-case assumptions
- **Bandit not converging**: Increase exploration rate, reset if noise regime fundamentally changed
- **Forecast inaccurate**: Reduce forecast horizon, increase context uncertainty, bias toward heavier mitigation
- **Overhead exceeds benefit**: For very short circuits, static QEM may be more efficient

**Key paper**: "GSC-QEMit: A Telemetry-Driven Hierarchical Forecast-and-Bandit Framework for Adaptive Quantum Error Mitigation" (arxiv:2604.24551, 2026-04)

## Pattern 19: Quantum Error Recovery (QER) for Permutation-Invariant Codes

**Core idea**: Use channel-aware quantum error recovery maps on permutation-invariant (PI) codes to achieve fidelity beyond noise-parameter-independent QEC.

**Problem**: Stabilizer codes apply fixed correction regardless of noise strength. For correlated non-Pauli noise (e.g., amplitude damping), this wastes resources. PI codes are symmetric under qubit permutations, have tunable parameters, and require simpler recovery circuits.

**QER vs QEC**:
- **QEC**: Fixed correction, noise-parameter independent
- **QER**: Optimal recovery map computed from channel knowledge, exceeds QEC fidelity

**CAD Codes** (arxiv:2607.02346, 2026-07):
- New PI code family for global symmetric amplitude-damping errors
- **CAD4**: 4-qubit code, perfectly corrects 1 global symmetric AD error, recovery circuit = 10 system/ancilla gates (realizable from linear geometric phase gates)
- **CAD9**: 9-qubit code, outperforms many existing codes by >1 order of magnitude
- Direct path from optimized recovery maps → low-overhead implementable protocols

**When to use**:
- Correlated amplitude-damping noise dominant
- Hardware with limited addressability (PI codes need fewer targeted operations)
- Non-Pauli noise where stabilizer overhead is prohibitive

**Pitfalls**:
- QER requires accurate noise channel estimation — performance degrades with poor channel knowledge
- Recovery map computation scales with code size — use approximate recovery for large codes
- PI codes may have lower code distance than optimal stabilizer codes for the same qubit count

## Pattern 20: Spatially Coupled CSS Codes with Seeded BP Decoding

**Core idea**: Spatial coupling of CSS codes enables belief-propagation (BP) decoding to achieve the quantum erasure hashing bound — a threshold normally only reachable with optimal (MAP) decoding.

**Problem**: BP is a suboptimal decoder compared to MAP. For quantum erasure channels, achieving the hashing bound (R = 1 - 2p) typically requires MAP decoding.

**Solution** (arxiv:2606.32001, 2026-06):
1. **CSS ensemble**: MN/HA-type punctured sparse matrices for X and Z checks
2. **Spatial coupling**: Couple multiple code instances along a chain
3. **Seeded BP**: Initialize with known qubits at chain boundaries
4. **DE analysis**: Five-message density evolution recursion decomposed into Z-side and X-side constituents
5. **Coupled-vector potential method**: Proves BP threshold = MAP threshold = hashing bound for equal-rate case

**Key mathematical result**: For X/Z equal-rate family, BP threshold = hashing-bound channel parameter determined by design rate. For unequal rates: BP threshold = min(Z-side degree ratio, X-side complementary degree ratio).

**When to use**:
- Quantum erasure channel QEC design
- Need low-complexity BP decoder with near-optimal performance
- CSS code construction with spatial coupling

**Pitfalls**:
- **Finite-length effects**: DE assumes infinite block length; finite codes need BP concentration analysis and block-error convergence study
- **Unequal X/Z rates**: Hashing bound not achieved; threshold limited by min of constituent ratios
- **Seed realization**: Finite-code realization of ideal DE seed is a separate engineering challenge

## Pattern 18: Quantum Group Codes from Class Field Theory for Non-Clifford Logic

**Core idea**: Construct quantum CSS codes from classical quasi group codes lifted via class field theory, supporting transversal multi-control-Z gates that are both addressable and parallelizable — enabling efficient non-Clifford gate implementation with quasi-quadratic decoding.

**Problem**: Non-Clifford gates require magic-state distillation, which dominates resource overhead in fault-tolerant quantum computing. Existing quantum AG codes support transversal gates but have cubic-time decoding.

**Solution** (arxiv:2606.27211, 2026-06):

1. **Classical quasi group codes**: Codes over F_q where product is associative up to invertible normalized cocycle
2. **Lifting via class field theory**: Apply ray class field construction to underlying classical AG code
3. **Result**: Quantum group code over F_{q^2} supporting transversal C^mZ and parallelizable C^{m-1}Z gates
4. **Decoding**: Quasi-quadratic time decoder with linear decoding radius (vs O(n^3) for previous quantum AG codes)

**Mathematical bridge**: Class field theory (deep algebraic number theory) → quantum CSS code construction
- Ray class fields provide the lifting structure
- Stark units may enter SIC overlaps (related to arxiv:2606.23535)
- Maximal rings of integers attached to ray class fields determine code parameters

**When to use**:
- Non-Clifford gate implementation without costly magic-state distillation per gate
- Parallelizable multi-control-Z gates in quantum circuit design
- Reducing magic-state distillation protocol overhead (almost linear speedup)
- Connecting number-theoretic code construction to fault-tolerant quantum computing

**Key advantage**: Quasi-quadratic decoding complexity O(n^2 log^c n) vs O(n^3) for previous quantum AG codes, plus parallelizable C^{m-1}Z gates reduce circuit depth.

**Pitfalls**:
- Requires understanding of class field theory and algebraic geometry codes
- Code parameters depend on ray class field properties — not all base codes admit good liftings
- Verification of transversality requires checking class field theory lifting conditions

## Code Selection Guide

| Platform | Recommended Code | Key Advantage |
|---|---|---|
| Neutral atoms | Surface code variants | Reconfigurable connectivity |
| Superconducting | Bacon-Shor, loss-biased | Measurement-free ops possible |
| Photonic | GKP, loss-biased | Natural loss bias exploitation |
| Trapped ions | qLDPC (OMG architecture) | Breakeven achieved, 9× better than superconducting qLDPC |
| NISQ general | RL-controlled adaptive | No recalibration needed |
| QLDPC (real-time) | GARI message-passing | FPGA-decodable, correlated errors |
| Non-Clifford logic | Quantum group codes (class field theory) | Quasi-quadratic decoding, parallelizable C^mZ gates |
| Correlated amplitude damping | Permutation-invariant QER (CAD codes) | Channel-aware recovery, 10-gate CAD4, >10x CAD9 improvement |
| Erasure channel (CSS) | Spatially coupled MN/HA CSS codes | Seeded BP achieves hashing bound, coupled-vector potential proof |
| Surface code (FTQC) | ADaPT adaptive window | Low latency, confidence-based |
| Toric/Color code (Ising hardware) | ILOD iterative low-order | 2.5x spin reduction, (0.81)^d scaling |
| Threshold estimation | Statistical mechanics mapping | Exact via phase transition, Nishimori line |
| Moderate-distance codes | Tensor network contraction | Near-MLD, O(χ^d) complexity |
| Large-scale real-time | Neural network decoders | GPU/TPU parallel, fast inference |

## Key Metrics to Track

- **Logical error rate**: Target < 10^-6 for practical computation
- **Code distance**: d = 3, 5, 7... (higher = more protection, more overhead)
- **Syndrome extraction cycle time**: Must be << qubit coherence time
- **Qubit overhead**: Physical/logical qubit ratio
- **Threshold**: Physical error rate below which logical error decreases with code size
- **Decoding latency**: Target < 1 μs per round for real-time FTQC (ADaPT: adaptive; GARI: 596 ns on FPGA)
- **Decoder resource usage**: FPGA LUT/DSP count, power consumption for hardware decoders

## References

Key papers in knowledge graph (kg.db):
- Entity 177: Google Quantum Echoes (verifiable Q advantage)
- Entity 179: Quantum Computing 2025 Milestones (1000+ qubit)
- New: RL Control of QEC (arxiv:2511.08493)
- New: Harvard 448-Atom FT Milestone (2025-11)
- New: Universal QC via Measurement-Free QEC (APS, 2026)
- New: Loss-biased FT QEC
- New: MLD Three-Lens Framework (arxiv:2605.17230, 2026-05) — spin models + tensor networks + neural decoders
- New: ADaPT Adaptive Window Decoding (arxiv:2605.01149, 2026-05)
- New: FPGA QLDPC GARI Decoder (arxiv:2605.01035, 2026-05)
- New: Trapped-Ion Multiqubit Gates Compatible with Scalable QEC (arxiv:2605.28536, 2026-05)
- New: VarEFTQC Learning-Based Logical Operation Discovery (arxiv:2605.28162, 2026-05) — Pattern 13 above
- New: Non-Clifford Crosstalk via Hybrid Stabilizer-TN (arxiv:2605.29514, 2026-05) — Pattern 14 above
- New: qLDPC Breakeven on Trapped-Ion with OMG Architecture (arxiv:2606.06455, 2026-06) — Pattern 15 above
- New: Iterative Low-Order Decoding (ILOD) via Ising Hamiltonian (arxiv:2606.12301, 2026-06) — Pattern 16 above
- New: GSC-QEMit Adaptive Telemetry-Driven QEM (arxiv:2604.24551, 2026-04) — Pattern 17 above
- New: Quantum Group Codes from Class Field Theory (arxiv:2606.27211, 2026-06) — Pattern 18 above
- New: QER for Permutation-Invariant Codes (arxiv:2607.02346, 2026-07) — Pattern 19 above
- New: Spatially Coupled CSS Codes with Seeded BP (arxiv:2606.32001, 2026-06) — Pattern 20 above
- New: Spacetime Lifting for Low-Overhead QEC (arxiv:2606.06365, 2026-06)

**Support files**:
- `references/gsc-qemit-adaptive-qem.md` — GSC-QEMit architecture details, module breakdown, mitigation strategy spectrum
- `references/statistical-physics-qec-decoding.md` — Statistical mechanics QEC decoding details
- `references/ilod-ising-qec-decoder.md` — ILOD algorithm implementation details

## Pattern 22: Confidence-Gated Two-Stage QEC Decoding

**Core idea**: Treat QEC syndrome decoding as a confidence-gated inference problem — lightweight neural fast-path handles the majority, expensive MWPM refinement only for low-confidence cases.

**Problem**: Real-time decoding is the major bottleneck in scaling QEC. MWPM has O(n³) complexity; pure neural decoders sacrifice accuracy for speed.

**Solution** (arxiv:2607.05814, 2026-07):
1. **Stage 1 (Fast-Path)**: Feed-forward neural network produces correction + confidence score
2. **Stage 2 (Refinement)**: MWPM triggered only when confidence < threshold τ
3. **Results**: At τ=0.95, accuracy 99.21% → 99.81% with only 3.3–6.2% escalation rate
4. **Throughput**: ~4.6×10⁵ samples/s on commodity CPU (batch size 512)
5. **Key insight**: Beyond code distance d=7, neural inference is NOT the throughput bottleneck — the MWPM refinement stage dominates

**Accuracy-Latency Trade-off**:
| τ (threshold) | Accuracy | Escalation Rate | Latency |
|---------------|----------|-----------------|---------|
| 0.00 (neural-only) | 99.21% | 0% | Minimal |
| 0.95 | 99.81% | 3.3-6.2% | Medium |
| 1.00 (MWPM-only) | ~99.9%+ | 100% | High |

**When to use**:
- Latency-constrained real-time QEC decoder design
- Hardware-aware QEC co-design for fault-tolerant systems
- Benchmarking decoder performance across code distances
- Systems engineering for quantum computing reliability

**Pitfalls**:
- Confidence threshold must be calibrated per noise model and code distance
- Neural training data must cover the full syndrome distribution
- Beyond d=7, optimize the MWPM graph stage, not the neural inference

**Key paper**: "Latency-Constrained Hardware-Aware Quantum Error Correction Co-Design with Adaptive Confidence-Gated Neural Decoding" (arxiv:2607.05814, 2026-07)

## Pattern 23: Bosonic QEC with Finite Stellar Rank

**Core idea**: Use stellar rank as an operational resource measure for bosonic QEC under practical state-preparation constraints.

**Problem**: Bosonic QEC relies on non-Gaussian encodings whose preparation cost is a central constraint. Prior work assumed ideal (infinite stellar rank) codewords.

**Solution** (arxiv:2607.06404, 2026-07):
1. **Stellar rank k**: Number of zeros of the stellar function f_ψ(z) = ⟨z*|ψ⟩
2. **Trade-off**: State approximability × energy × logical protection under finite rank
3. **Key finding**: k=2 suffices for break-even under ALL dephasing strengths
4. **Direct optimization**: At fixed stellar rank, discovers noise-adapted code structures
   - Photon loss → grid-like encodings emerge
   - Dephasing → rotation-symmetric encodings emerge
5. **Photon loss**: Required rank increases with loss rate γ

**Stellar rank meaning**:
- k = 0: Gaussian states (free, easy to prepare)
- k ≥ 1: Non-Gaussian states (resource-intensive)

**When to use**:
- Designing bosonic QEC codes for circuit QED or optical systems
- Analyzing non-Gaussian resource requirements for fault tolerance
- Optimizing GKP or cat state preparation under hardware constraints
- Determining minimum stellar rank for break-even

**Pitfalls**:
- Codewords with better ideal properties need NOT be optimal under finite-rank constraints
- Required rank for photon loss protection scales with loss rate — budget accordingly
- Direct optimization at fixed rank > approximating ideal codewords

**Key paper**: "Bosonic quantum error-correcting codes with finite stellar rank" (arxiv:2607.06404, 2026-07)

**Related Skills**:
- `bosonic-gkp-parity-encoding` — GKP code design
- `bosonic-grid-states-qec` — Bosonic grid states for QEC

## Practical Notes

**Quantum Group Codes Reference**: See `references/quantum-group-codes-class-field.md` for class field theory lifting procedure details and SIC overlap connections (arxiv:2606.27211, 2606.23535).

## Session Notes

- See `references/session-2026-05-07-qec.md` for 2026-05-07 paper analysis including CSS LDPC construction, cut-cat syndrome extraction, compass codes, bosonic QEC memory, and decoder analysis framework.
- See `references/session-2026-07-09-qec-decoders.md` for confidence-gated decoding, geometric obstruction metrology, and stellar rank bosonic QEC patterns (2607.05814, 2607.06410, 2607.06404).

**Core idea**: Extend pipe diagram lattice surgery compilation from surface codes to **triangular color codes** on the 6.6.6 lattice, enabling distance-independent spacetime optimization and automated compilation to syndrome extraction circuits.

**Problem**: Pipe diagrams are established for **surface code** lattice surgery compilation, but analogous techniques for **color codes** were unexplored — despite color code advantages: reduced qubit overhead and transversal single-qubit Clifford gates.

**Solution** (arxiv:2607.05501, 2026-07-06):

1. **Pipe diagram representation** for triangular color code on 6.6.6 lattice
2. **ZX-diagram correspondence**: Mapping between color code pipes and ZX-diagrammatic computation
3. **Distance-independent constructions**: Correlation surfaces, stabilizers, syndrome extraction circuits
4. **Compact spacetime embeddings**: Leverage color code geometry for efficient logical computation layouts

**Color Code vs Surface Code Trade-off**:
| Property | Surface Code | Color Code (6.6.6) |
|----------|-------------|-------------------|
| Qubit overhead | Higher | Lower |
| Transversal Cliffords | Limited | Full single-qubit set |
| Lattice surgery framework | Established (pipe diagrams) | **This paper** |

**When to use**:
- FTQC architecture using color codes (lower overhead than surface code)
- Need lattice surgery compilation with transversal Clifford advantage
- Spacetime optimization for logical color code computations

**Pitfalls**:
- **Surface code pipe diagrams ≠ color code pipe diagrams**: Different lattice geometry (triangular 6.6.6 vs square) requires different constructions
- **Related skill**: `color-code-pipe-diagrams` (2607.05501) covers the methodology in detail

## Practical Notes

**Quantum Group Codes Reference**: See `references/quantum-group-codes-class-field.md` for class field theory lifting procedure details and SIC overlap connections (arxiv:2606.27211, 2606.23535).

**arXiv API rate limiting**: arXiv returns HTTP 429 (Too Many Requests) when sending queries too quickly. Mitigation: add 3.5s delay between queries (time.sleep(3.5)). Also handle HTTP 421 (Misdirected Request) — may indicate proxy misconfiguration. Use `scripts/arxiv_sunday_search.py` pattern with httpx and proxy support.

## Session Notes

- See `references/session-2026-05-07-qec.md` for 2026-05-07 paper analysis including CSS LDPC construction, cut-cat syndrome extraction, compass codes, bosonic QEC memory, and decoder analysis framework.