The foundational theory of Quantum Error Correction (QEC) relies on a comforting mathematical simplification: the independent error assumption. This assumption posits that the noise destroying a quantum state acts locally and stochastically. If Qubit $A$ undergoes a bit-flip error with a small probability $p$, the probability that its neighbor Qubit $B$ simultaneously flips due to the same root cause is assumed to be $p^2$. Because $p$ is engineered to be incredibly small (e.g., $10^{-3}$), the chance of simultaneous failures ($10^{-6}$) becomes negligible. Under this assumption, scaling up a quantum code by adding more qubits exponentially suppresses the logical error rate.
However, real-world quantum hardware does not obey this assumption. As processors scale, they encounter correlated noise—errors that strike multiple qubits simultaneously across space or persist over time. When errors are correlated, the joint probability of multiple failures scales as $O(p)$ rather than $O(p^2)$. This correlation breaks the mathematical machinery of standard surface codes, creating an error floor that cannot be overcome simply by adding more qubits.
To build fault-tolerant quantum computers, we must understand why errors correlate, how they propagate, and how we can redesign our software and hardware to handle them.
The Mechanisms of Correlation
Correlated errors do not arise from a single flaw; rather, they emerge from different physical and architectural layers of a quantum information processor.
1. Hardware Crosstalk and Context-Dependence
In an ideal processor, executing a gate on Qubit 1 has zero effect on Qubit 2. In practice, physical proximity and static parasitic couplings cause operations to leak. As explained by Sarovar et al., when a multi-qubit processor scales, simultaneous operations trigger emergent interactions that violate spatial locality.
This creates context-dependent errors, where a gate's fidelity depends heavily on what its neighbors are doing at that exact moment. Rudinger et al. and Patel et al. demonstrate that static error metrics fail to predict actual program success because they ignore this spatial context; a gate that performs perfectly in isolation can exhibit severe errors when surrounded by active parallel operations.
2. Environmental Radiation and Quasiparticle Bursts
Some correlated errors originate entirely outside the quantum circuit. High-energy environmental radiation, such as cosmic rays or background gamma radiation, can strike the silicon or sapphire substrate of a superconducting chip.
[Cosmic Ray Strike]
│
▼
[Substrate Phonon Wave] ──► [Breaks Cooper Pairs] ──► [Quasiparticle Cloud]
│
▼
[Simultaneous Multi-Qubit Decay]
When a particle hits the chip, it releases a burst of phonons that propagate through the substrate, breaking Cooper pairs in superconducting circuits and generating a cloud of non-equilibrium quasiparticles. As documented by Chen et al. and Niu et al., these events trigger correlated, chip-wide error spikes. Because a single strike causes simultaneous decoherence across a large physical footprint, it completely bypasses the localized protection offered by standard distance-scaled codes.
3. Circuit-Induced Propagation
Even if noise starts as a localized, independent event, the very structure of a quantum circuit can transform it into a correlated fault. Entangling operations, such as CNOT gates, act as conduits for error propagation. If a phase-flip error occurs on a control qubit before a CNOT, the gate naturally copies that error onto the target qubit, turning a single-qubit fault into a correlated two-qubit fault.
Zhou et al. and Qi et al. highlight how entangling operations cause errors to cascade across logical circuits. Similarly, when auxiliary systems or ancilla qubits are used to mediate gates across a register, any error occurring on the shared mediator distributes correlated faults across the entire data register, as detailed by Kendon and Dooley et al..
4. Correlated Measurement and Leakage
Errors also correlate during the final stages of a circuit cycle or during mid-circuit measurements. Hines et al. show that noise associated with mid-circuit measurements is frequently structured across multiple qubits rather than independent. Furthermore, hardware crosstalk can cause the measurement of one qubit to corrupt the state of its neighbor, a phenomenon modeled through joint probability distributions by Funcke et al. and Jansen et al..
Finally, errors like leakage—where a qubit escapes its computational $|0\rangle$ and $|1\rangle$ states into higher energy levels—persist across multiple operational cycles and spread to adjacent qubits via physical coupling components, violating the assumption that noise is transient and isolated (Yang et al.).
Why Correlated Noise Defeats Standard Decoders
To understand why correlated noise is uniquely destructive, we must look at how a classical decoder interprets error syndromes.
In a standard surface code, the decoder receives a set of syndrome measurements (indications that something went wrong) and maps them to a graph. Traditional graph-based decoders, such as Minimum Weight Perfect Matching (MWPM), use static edge weights calculated under the assumption that error events are independent (Peled et al.). The decoder looks for the most likely (shortest) path of independent failures that could explain the syndromes.
Independent Model (Decoder Expectation):
Syndrome ──[Likely Local Path]──► Syndrome
Correlated Reality (Actual Hardware Fault):
Syndrome ◄─────────[Single Global Burst Event]─────────► Syndrome
When a correlated burst occurs, syndromes light up across the chip simultaneously. Because the decoder assumes these events are independent, it misinterprets the massive cluster of syndromes as a long chain of separate, sequential errors. It then applies a correction path that is fundamentally wrong, often injecting more errors and causing logical failure rates to exceed 50% (Vallero et al.).
This introduces a harsh paradox: increasing the code distance expands the physical footprint of the logical qubit, which paradoxically increases its vulnerability to large-scale radiation strikes (Vallero et al.).
Solutions: Restoring and Bypassing Independence
To overcome this bottleneck, researchers attack correlated noise from three angles: tailoring the noise, shielding the hardware, and designing correlation-aware software.
Noise Tailoring via Randomized Compiling
If coherent crosstalk is dangerous because its phase errors add up constructively, we can use software to force it to behave like independent noise. Randomized Compiling (RC) achieves this by inserting pairs of mutually canceling, random single-qubit Pauli gates around entangling cycles.
As demonstrated by Hashim et al., RC mathematically "twirls" complex, coherent spatial crosstalk into simple, predictable stochastic Pauli channels. By forcing the worst-case error rate to converge to the average error rate, RC restores the validity of the independent error models that decoders expect.
Physical Mitigation: Gap Engineering
To stop environmental radiation from causing correlated bursts, the physical architecture of the chip must be altered. McEwen et al. developed a technique called gap engineering to shield superconducting qubits.
By varying the thickness of the aluminum films at the Josephson junctions, they created localized variations in the superconducting energy gap. These variations act as physical energy barriers, trapping and reflecting quasiparticles before they can diffuse across the substrate and cause simultaneous multi-qubit decay.
Correlation-Aware Decoding and Specialized Codes
Finally, classical decoding algorithms can be upgraded to recognize correlations instead of ignoring them.
- Neural Decoders: Peled et al. introduced Neural Minimum Weight Perfect Matching (NMWPM), which uses Graph Neural Networks to dynamically calculate edge weights based on real-time hardware noise patterns rather than relying on static, independent assumptions.
- Modular Decoders: The Multi-Core Circuit Decoder (MCCD) proposed by Zhou et al. assigns dedicated decoding "cores" to specific gate operations, isolating and resolving the correlated errors propagated by entangling operations in linear time.
- Burst-Correcting Codes: Rather than relying entirely on surface codes, architectures can incorporate classical burst-error correction logic into Quantum Tensor Product Codes (QTPCs). As shown by Fan et al., the subblock structure of a tensor product allows the system to isolate and rectify spatially or temporally correlated error bursts that occur within distinct segments of physical qubits, preventing them from corrupting the global state.
Key Foundational Work
Spatially correlated qubit errors and burst-correcting quantum codes (1999) — contributed 4 concept elements to this direction.
Gates for the Kane quantum computer in the presence of dephasing (2004) — contributed 1 concept elements to this direction.