Quantum Error Correction

Encoding quantum information redundantly to detect and correct errors. Required for fault-tolerant quantum computing.

Quantum Error Correction (QEC) protects quantum information from errors by encoding it across multiple physical qubits. It’s the key to building large-scale quantum computers.

The Challenge

Classical error correction: Copy the bit, use majority voting. But quantum has the no-cloning theorem, so you can’t copy!

Also, quantum errors are continuous (small rotations), not just bit flips.

How QEC Works

The Key Insights

1. Don’t measure the qubits directly: That would collapse the state
2. Measure the errors instead: Use “syndromes” that reveal error type
3. Encode in subspace: Logical states span multiple physical qubits
4. Errors become detectable: Errors move state out of code space

Basic Structure

$$|0{⟩}_L=\text{encoded }|0⟩\text{ (uses multiple physical qubits)}$$ $$|1{⟩}_L=\text{encoded }|1⟩$$

Logical qubit = protected quantum information.

Types of Errors

All errors can be decomposed into Pauli errors:

Simple Example: 3-Qubit Code

Protects against single bit flip (X error):

$$|0{⟩}_L=|000⟩$$ $$|1{⟩}_L=|111⟩$$

Syndrome measurement:

• Measure parity of qubits 1,2 (without measuring individual values)
• Measure parity of qubits 2,3

Real Codes

Surface Code

• Leading candidate for fault tolerance
• 2D layout, local measurements
• ~1000 physical qubits per logical qubit

Stabilizer Codes

• Mathematical framework for QEC
• Includes Steane code, CSS codes

Bacon-Shor Code

• Gauge qubits for simpler syndrome measurement

Color Codes

• Alternative to surface code with transversal gates

The Error Correction Cycle

1. Perform computation gates
2. Measure syndromes (detect errors)
3. Decode: Figure out what errors occurred
4. Correct: Apply corrections (or track in software)
5. Repeat

This cycle must be faster than errors accumulate.

Threshold Theorem

If physical error rate $p$ is below threshold $p_{th}$:

• Logical error rate can be made arbitrarily small
• By using more physical qubits

For surface code: $p_{th}\approx 1\%$

The Overhead

This is why we need millions of physical qubits for useful quantum computers.

See also: Surface Code, Logical Qubit, Fault Tolerance, Fidelity