- How errors arise in classical and quantum systems
- Why quantum information is fundamentally fragile
- Modelling quantum errors through channels and noise
- The three fundamental quantum errors: X, Y and Z
- The dilemma of measuring versus detecting quantum errors
- A first intuition for stabiliser codes
Modern machine learning systems perform an extraordinary number of operations every second. Training large neural networks involves massive matrix multiplications, memory transfers, and continuous information flow across hardware. Despite this scale, classical computers remain remarkably reliable because modern computational systems are built on layers of error correction and fault tolerance.
Errors still occur in classical hardware. Electrical noise, thermal fluctuations, and even cosmic rays can occasionally corrupt information. Yet classical information is surprisingly robust.
The reason is remarkably simple:
Bits can be copied and checked without changing their state.
This seemingly ordinary property forms the foundation of classical error correction. By introducing redundancy and performing consistency checks, classical systems can detect and correct errors before they propagate through a computation.
Quantum systems operate very differently.
In Quantum Machine Learning (QML), information is encoded into fragile quantum states that evolve through superposition and entanglement. Unlike classical bits, quantum states cannot simply be copied for backup. Worse still, directly inspecting a quantum state can disturb the very information we are trying to protect.
This creates one of the biggest challenges in quantum computing:
How do we keep quantum information alive long enough to perform meaningful computation?
The answer lies in Quantum Error Correction (QEC), a collection of techniques designed to protect quantum information from the noisy and imperfect world around it.
How errors arise in classical and quantum systems
No physical system is perfect. Whether we are transmitting information across the internet, storing data in memory, or training a machine learning model on specialised hardware, information is constantly exposed to disturbances from the surrounding environment.
In classical systems, these disturbances can originate from many sources. Electrical noise can alter voltages in a circuit, thermal fluctuations can affect electronic components, and even high-energy cosmic rays occasionally strike memory cells, causing bits to flip unexpectedly. Such events are rare, but given the billions of operations performed every second in modern computers, they cannot be ignored.
Fortunately, classical information is relatively resilient. Since bits can be copied and checked without changing their value, redundancy can be introduced to detect and correct errors before they propagate through a computation.
Quantum systems face a similar problem but under far more restrictive rules and their sensitivity to the noise is extremely high.
A quantum computer is never completely isolated from its surroundings. Interactions with the environment, imperfections in quantum gates, noise in control electronics, and inaccuracies during state preparation can all disturb the quantum state being processed. Unlike classical systems, however, even a small disturbance can significantly alter a quantum computation.
Furthermore, quantum information is far more complex as it is not limited to the binary states 0 and 1. A qubit may exist in a superposition of both states simultaneously, making the effects of noise far more subtle than a simple bit flip.
As a result, understanding how errors arise in quantum systems requires a different framework, one that accounts for both the probabilistic nature of quantum mechanics and the unavoidable interaction between a quantum system and its environment.
Why quantum information is fundamentally fragile
As we have already established classical information is stored in bits that exist in one of two states: 0 or 1. A bit may occasionally become corrupted, but its state can be copied, inspected and verified without fundamentally changing the information being stored.
Quantum information behaves very differently.
A qubit can exist in a superposition of states, allowing it to represent both 0 and 1 simultaneously. This property lies at the heart of quantum computing’s potential advantage, but it also makes quantum information exceptionally delicate.
Even a small interaction with the surrounding environment can disturb a quantum state. This process is known as decoherence and remains one of the greatest obstacles to building large-scale quantum computers.
The challenge becomes even more severe because quantum information cannot be treated like classical information.
Suppose a classical memory bit is suspected to be corrupted. We can simply create multiple copies, compare them and identify inconsistencies and fix the issue. A quantum state does not permit such a strategy. The No-Cloning Theorem states that
an arbitrary unknown quantum state cannot be perfectly copied.
At the same time, directly measuring a quantum state is not a harmless operation. Measurement collapses the state and can destroy the very superposition we are trying to preserve.
This places quantum information in a peculiar position. It is highly sensitive to errors, yet the two most natural strategies for detecting those errors—copying the information and directly inspecting it—are fundamentally prohibited by quantum mechanics.
Before we look at how quantum error correction overcomes this challenge, we must first understand what quantum errors actually look like and how they are modelled mathematically.
Modelling Quantum Errors Through Channels and Noise
In practice, quantum computers do not operate in perfectly isolated environments. Every quantum system interacts, to some extent, with the world around it. These interactions may be caused by thermal fluctuations, electromagnetic interference, imperfections in quantum gates, or even inaccuracies during state preparation and measurement.
Collectively, these unwanted disturbances are referred to as noise.
Rather than describing each physical source of noise individually, we often adopts a more general abstraction known as a quantum channel. A quantum channel represents the effect of an imperfect environment on a quantum state as it evolves through a computation. This idea is very close to how classical information theory models noise via classical channels
You can think of a quantum channel as a black box through which quantum information must travel. Ideally, the state emerging from the channel would be identical to the state that entered it. In reality, however, interactions with the environment may alter the state, introducing errors along the way.
Fortunately, despite the infinite number of ways a quantum state can be disturbed, many quantum errors can be understood in terms of a small set of fundamental error operations. These operations form the building blocks of quantum error correction and provide a surprisingly simple way to reason about complex quantum noise.
Let us examine these fundamental error operations, commonly known as the Pauli errors: X, Y, and Z.
The three fundamental quantum errors: X, Y and Z
At first glance, you might be thinking that quantum errors are overwhelmingly complex. A qubit can exist in infinitely many superposition states, and interactions with the environment can disturb these states in countless ways.
However, rest assured, many quantum errors can be understood in terms of just three fundamental operations: X, Y, and Z. Known as the Pauli errors, these operations form the building blocks of quantum error correction.
Much like complex classical errors can often be decomposed into simpler components, more complicated quantum errors can frequently be expressed as combinations of these three operators.
Let’s examine them one at a time.
The X Error: Bit Flip
The X error is the quantum equivalent of a classical bit flip.
A qubit in the state (= vector) becomes (= vector), while a qubit in the state becomes .
In a physical quantum device, such errors may arise from imperfect control pulses, hardware imperfections, or unwanted interactions with the environment.
A simple simulation illustrates this behavior:
import numpy as np
#vector representation of |0⟩
ket0 = np.array([1, 0])
#Matrix representation of X gate
X = np.array([[0, 1],
[1, 0]])
print(f`X@ket_0: {X @ ket0}`)this outputs:
X@Ket_0: [0 1]which is bit-flipped or
The Z Error: Phase Flip
Phase errors have no direct classical equivalent and are uniquely quantum in nature. Rather than changing the computational basis state, a Z error changes the relative phase between quantum amplitudes.
Consider the superposition state (which is special state, where probability of qubit being 0 or 1 is the same):
Applying a Z error produces:
The qubit still appears to contain the same probabilities, but its phase information has changed. Since quantum algorithms rely heavily on interference between amplitudes, even a small phase error can significantly alter a computation. This phase difference is commonly called Relative phase.
import numpy as np
ket0 = np.array([1, 0])
#vector representation of |1⟩
ket1 = np.array([0, 1])
plus = (ket0 + ket1) / np.sqrt(2)
print(f'Plus state: {plus}')
#Matrix representation of Z
Z = np.array([[1, 0],
[0, -1]])
print(f'Z@Plus state: {Z @ plus}')this outputs:
Plus State: [0.70710678 0.70710678]
Z@Plus State: [0.70710678 -0.70710678]The amplitudes still have the same magnitude, but the relative phase changed.
A phase-flip error doesn’t “look” as obvious as a classical bit flip, yet it can completely change the outcome of a quantum computation.
The Y Error: Bit Flip and Phase Flip Together
Unlike the X and Z errors, the Y error introduces both a bit flip and a phase change simultaneously. Mathematically, the Pauli-Y operator can be written as:which is why it is often viewed as a combination of X and Z errors.
import numpy as np
ket0 = np.array([1, 0])
ket1 = np.array([0, 1])
plus = (ket0 + ket1) / np.sqrt(2)
print(f"Plus state: {plus}")
#Matrix representation of Y
Y = np.array([[0, -1j],
[1j, 0]])
#Output is a complex vector
print(f"Y@Plus state: {Y @ plus}")the output:
Plus state: [0.70710678 0.70710678]
Y@Plus state: [0.-0.70710678j 0.+0.70710678j]In summary:
- X → bit flip
- Z → phase flip
- Y → both together
Why These Errors Matter
The seemingly infinite complexity of quantum noise—where a state can drift continuously by any arbitrary angle on the Bloch sphere—would appear impossible to manage.
The remarkable insight behind quantum error correction is that continuous errors can be discretised. Any realistic noise process can be expressed as a linear combination of the Pauli operators . When we perform a stabiliser measurement, we actively force the environment’s complex, continuous distortion to collapse into one of these discrete, fundamental building blocks.
By focusing entirely on detecting and correcting this small, discrete set of errors, the monumental task of protecting quantum information becomes fundamentally tractable (though extremely challenging).
The dilemma of measuring versus detecting quantum errors
Now that we understand the different types of quantum errors, the next question naturally follows:
How do we detect them?
Unfortunately, this is where quantum mechanics presents us with a seemingly impossible challenge.
In classical systems, detecting errors is straightforward. We can inspect the stored information, compare it against redundant copies, and identify inconsistencies. The process may be computationally expensive, but it does not fundamentally alter the information being examined.
Quantum systems do not offer the same luxury.
A qubit stores information in a quantum state that may exist in a superposition of multiple basis states. To learn anything about that state, we must perform a measurement. However, quantum measurement is not a passive observation. The act of measuring a qubit generally disturbs the state and causes it to collapse into one of its possible outcomes.
In other words, the very act of checking whether quantum information has been corrupted may destroy the information we are trying to protect.
As if that were not challenging enough, quantum mechanics introduces another restriction known as the No-Cloning Theorem. Unlike classical bits, an arbitrary unknown quantum state cannot be copied perfectly. Since we cannot create backup copies of a qubit, the classical strategy of redundancy through duplication is no longer available.
This leaves us with a remarkable paradox:
Quantum information is highly susceptible to errors, yet the two most obvious strategies for detecting those errors—direct measurement and copying the information—are both forbidden by the laws of quantum mechanics.
At first glance, quantum error correction appears impossible.
And yet, somehow, it works.
The key insight lies in detecting the effects of errors without directly measuring the quantum information itself, an idea that forms the foundation of stabiliser codes.
A first intuition for stabiliser codes
At first glance, quantum error correction appears impossible.
Quantum information is highly susceptible to errors, yet we cannot directly measure a quantum state without disturbing it. We also cannot create backup copies of an unknown quantum state because of the No-Cloning Theorem. The two most obvious error-detection strategies available in classical computing are therefore unavailable.
So how can quantum computers possibly detect errors?
The key idea is surprisingly clever: instead of measuring the quantum information itself, we measure carefully chosen properties of the system that reveal whether an error has occurred.
Imagine trying to determine whether a book has been altered without reading its contents. Rather than inspecting every page, you might verify a set of checksums that indicate whether the text has changed. Stabiliser codes follow a similar philosophy. They monitor specific properties of an encoded quantum state and use those properties to identify the presence of errors without revealing the information being protected.
In practice, stabiliser codes distribute information across multiple physical qubits and perform auxiliary measurements that reveal where an error may have occurred while leaving the encoded quantum information intact.
This idea forms the foundation of many modern quantum error-correcting codes and represents one of the most important breakthroughs in quantum computing.
But how can a quantum computer learn about an error without learning about the quantum state itself?
That question leads us to syndrome measurements, ancilla qubits, and stabiliser codes in greater detail—the focus of the next article in this series.
Thank you for reading!
Disclaimer:
This article was grammatically refined with the assistance of Large Language Models (LLMs). All illustrations were created by the author using GPT and Gemini image-generation tools. All code examples and technical content were written and verified by the author.
Version 1.0
