Spreading Information Out
The Idea Behind Quantum Error Correction
Before we start, I’ve recently launched a crowdfunding campaign to fund our much needed workstation project. Just to recap, the kit we desperately need is a fast, well built PC with dual monitors, one for the experiments and the other for the results, and writing and documentation. We also need an uninterruptible power supply (UPS) and two large, fast data disks for professional level data analysis and daily, weekly and monthly backups. If you’d like to pitch in and help, you’ll find the link here.
Every contribution, however modest, makes a real difference. And if you’re not in a position to contribute, sharing the campaign on social media is a powerful way to help spread the word! Thank you for your support.
And now, today’s post!
Last time we arrived at what looked like an impossible constraint. We can’t copy a qubit. We can’t measure it directly without destroying what we’re trying to protect. And yet quantum systems are noisy, errors are inevitable, and computation requires that information survive long enough to be useful.
The solution, and to my mind, a stroke of sheer engineering genius can be expressed as, ‘Stop trying to protect a single qubit!’ Instead, the method is to hide the information in a pattern spread across many qubits simultaneously. That is, in the relationships between them rather than in any one of them individually. Make the information collective. Make it so that no single error, acting on a single qubit, can reach the thing we’re actually trying to preserve.1
This is the central idea of quantum error correction. It sounds abstract at first. But it has a precise, workable structure underneath it.
Quantum redundancy can’t use duplication because the no-cloning theorem rules it out.2 But it can do something subtler. It can entangle a group of physical qubits in such a way that the logical information is encoded non-locally across all of them.
No individual qubit holds the information. No individual qubit can be measured to reveal it. The information is genuinely distributed (not copied) to multiple locations, but woven into a collective quantum state that none of the parts contain on their own.
Think of it like this. If we wanted to hide a secret in a classical system, we might split it into pieces and give each piece to a different person. No single person knows the secret. But the right combination of people, pooling their pieces, can reconstruct it. Quantum encoding is something like this, except the pieces aren’t classical fragments, they’re entangled quantum correlations, and the rules for how they can be combined are governed by quantum mechanics rather than simple arithmetic.
The result is a logical qubit. One protected unit of quantum information encoded across many physical qubits. The physical qubits are the noisy, vulnerable components the hardware actually manipulates. The logical qubit is the abstract, protected thing we actually care about.
Let’s consider a simple example i.e. The three-qubit bit flip code; the simplest possible quantum error correcting code and one that protects against a single type of error.
Suppose we want to protect a logical qubit against bit flips only. We encode it across three physical qubits using entanglement, in a way that mirrors the classical repetition idea but without copying. The logical |0⟩ is encoded as a particular entangled state across all three qubits, and so is the logical |1⟩. The superposition, critically, is preserved in the encoding.
If a bit flip strikes one of the three physical qubits, the collective state shifts in a detectable way. We haven’t destroyed the logical information, but the error has left a mark. In effect, a fingerprint in the relationships between qubits. That fingerprint can be read without touching the encoded state itself.
This is only a toy example. It handles bit flips but ignores phase flips entirely, which means it isn’t a complete solution. Real quantum error correcting codes have to handle both error types simultaneously, and that requires more qubits and more structure. But the core logic is already here and that is as follows.
Distribute the information, so that local errors disturb only part of the pattern, and the disturbance can be diagnosed without reading the whole thing.
Here is where quantum error correction becomes genuinely remarkable. In a well-designed code, we can perform a special kind of measurement; called a syndrome measurement , that tells us whether an error has occurred, and roughly where, without ever revealing the encoded logical information.
This sounds like it shouldn’t be possible. Measurement collapses quantum states. How can we measure anything about the system without disturbing what we’re protecting?
The answer lies in what exactly we’re measuring. Syndrome measurements don’t ask “what is the logical qubit state?” They ask a more indirect question. “Are these two physical qubits consistent with each other?” or “has the relationship between this group of qubits changed in an unexpected way?”
These are questions about correlations, not about the underlying logical state. The answers, the syndromes, flag the presence and location of errors without exposing the protected information itself. It’s like a security system that tells us a window has been opened without showing us anything about what’s inside the house.
If the syndrome is trivial it means no inconsistencies are detected so we do nothing. If the syndrome flags an error, we apply a targeted correction to the affected qubit. The logical information, encoded non-locally3 across the whole system, was never directly disturbed by either the measurement or the correction.
What makes this possible, at the mathematical level, is a careful choice of which properties of the system to monitor. Quantum error correcting codes are designed so that the syndromes; that is the measurable correlations; commute with the logical operators. In plain terms, checking for errors doesn’t interfere with the information. The two live in different parts of the system’s structure.
This isn’t obvious, and it isn’t free. Designing codes with this property requires mathematical care, and implementing syndrome measurements on real hardware requires additional qubits, called ancilla qubits, and carefully calibrated operations. The overhead is real and significant.
But the principle is sound. We can detect errors without seeing the state. We can protect information without copying it. Quantum error correction isn’t a workaround or an approximation, it’s a rigorous framework that respects every constraint quantum mechanics imposes and finds a path through them anyway.
That’s all for now! If you like my efforts to make quantum science, computing and physical chemistry, more accessible to everyone; please consider recommending this newsletter on our own substack or website. Or share ExoArtDataPulse with a friend or colleague. Every recommend makes the project grow. Thanks for Reading!
Support our workstation fundraiser here :-)
To me, it feels like throwing up a shield wall of logical qubits around the actual qubit concerned.
The no-cloning theorem, proved independently by Wootters and Zurek and by Dieks in 1982, states that it is impossible to create a perfect copy of an arbitrary unknown quantum state. This follows directly from the linearity of quantum mechanics. It has profound implications for error correction. Classical computers can protect information simply by copying bits and checking the copies against each other, but quantum computers cannot do this. Quantum error correction instead encodes logical information across entangled states of multiple physical qubits, detecting errors through indirect measurements that reveal whether something went wrong without ever directly reading out the underlying quantum state. See last post, ‘We can’t Copy a Qubit!’
Just to reiterate the method. Non-local encoding means the logical qubit information is distributed across many physical qubits simultaneously, rather than residing in any single one. No individual qubit "holds" the information. It exists only in the collective correlations between them. This is precisely what makes it invisible to local measurements and resilient to local errors.