Skip to content

Quantum Error Correction (QEC)

Quantum Error Correction is essential for building reliable quantum computers. QPyth includes implementations of two canonical QEC codes: Shor's 9-qubit code and Steane's 7-qubit code.

Overview

Quantum errors can be classified into three types: - Bit flip errors - |0⟩ ↔ |1⟩ - Phase flip errors - |+⟩ ↔ |−⟩ - Combined errors - Both bit and phase flips

QEC codes encode logical qubits into multiple physical qubits to detect and correct these errors.

Shor's 9-Qubit Code

Shor's code is the first quantum error-correcting code, capable of correcting arbitrary single-qubit errors.

How It Works

  1. Encoding: Encodes 1 logical qubit into 9 physical qubits
  2. Error Detection: Uses syndrome measurements to detect errors
  3. Error Correction: Applies corrective operations based on syndrome

CLI Usage

qpy
# Select option 9: Quantum Error Correction
# Select option 1: Shor's 9-qubit Code

Python API

from quantumpytho.modules.qec_shor import run_shor_qec_demo
from quantumpytho.engine import QuantumEngine

# Create engine
engine = QuantumEngine()

# Run Shor code demo
result = run_shor_qec_demo(
    engine,
    logical_state=0,
    error_type="bit_flip",
    error_qubit=0
)

print(f"Original state: |{result['original_state']}>")
print(f"Decoded state: |{result['decoded_state']}>")
print(f"Success: {result['success']}")

Error Types

  • none - No error injected
  • bit_flip - Bit flip error on specified qubit
  • phase_flip - Phase flip error on specified qubit
  • both - Both bit and phase flip errors

Steane's 7-Qubit Code

Steane's code is a CSS (Calderbank-Shor-Steane) code that encodes 1 logical qubit into 7 physical qubits.

How It Works

  1. Encoding: Uses CSS construction with classical Hamming codes
  2. Error Detection: Separate X and Z stabilizer measurements
  3. Error Correction: Efficient correction using classical decoding

CLI Usage

qpy
# Select option 9: Quantum Error Correction
# Select option 2: Steane's 7-qubit Code

Python API

from quantumpytho.modules.qec_steane import run_steane_qec_demo
from quantumpytho.engine import QuantumEngine

# Create engine
engine = QuantumEngine()

# Run Steane code demo
result = run_steane_qec_demo(
    engine,
    logical_state=1,
    error_type="phase_flip",
    error_qubit=3
)

print(f"Original state: |{result['original_state']}>")
print(f"Decoded state: |{result['decoded_state']}>")
print(f"Success: {result['success']}")

Comparing Codes

QPyth provides a comparison of both codes:

CLI Usage

qpy
# Select option 9: Quantum Error Correction
# Select option 3: Compare Codes

Python API

from quantumpytho.modules.qec_shor import run_shor_qec_demo
from quantumpytho.modules.qec_steane import run_steane_qec_demo
from quantumpytho.engine import QuantumEngine

# Create engine
engine = QuantumEngine()

# Test both codes with same error
shor_result = run_shor_qec_demo(
    engine,
    logical_state=0,
    error_type="bit_flip",
    error_qubit=0
)

steane_result = run_steane_qec_demo(
    engine,
    logical_state=0,
    error_type="bit_flip",
    error_qubit=0
)

print(f"Shor code success: {shor_result['success']}")
print(f"Steane code success: {steane_result['success']}")

Code Comparison

Feature Shor's 9-Qubit Steane's 7-Qubit
Physical Qubits 9 7
Correctable Errors Arbitrary single-qubit Arbitrary single-qubit
Encoding Depth Higher Lower
Syndrome Measurements 8 6
Transversal Gates Limited Better
Fault Tolerance Yes Yes

Advanced Usage

Custom Error Injection

Inject custom errors:

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

# Create circuit with custom error
qc = QuantumCircuit(9)
# ... encoding circuit ...

# Inject error on qubit 3
qc.x(3)

# ... syndrome measurement and correction ...

# Run simulation
simulator = AerSimulator()
result = simulator.run(qc, shots=1024).result()

Multiple Error Correction

Correct multiple errors (limited by code distance):

# Shor's code can correct any single-qubit error
# but cannot correct two simultaneous errors

result = run_shor_qec_demo(
    engine,
    logical_state=0,
    error_type="bit_flip",
    error_qubit=0  # Single error - correctable
)

# Two errors - may fail
result = run_shor_qec_demo(
    engine,
    logical_state=0,
    error_type="bit_flip",
    error_qubit=0  # First error
)
# Inject second error on qubit 1
# ... correction may fail

Fault-Tolerant Gates

Implement fault-tolerant gates:

# Transversal CNOT for Steane's code
def transversal_cnot(logical_control, logical_target):
    """Apply CNOT transversally to logical qubits"""
    for i in range(7):
        qc.cx(logical_control[i], logical_target[i])

Performance Considerations

Overhead

  • Qubit overhead: 7-9x physical qubits per logical qubit
  • Gate overhead: Additional gates for encoding/decoding
  • Measurement overhead: Syndrome measurements

Optimization Tips

  1. Use appropriate code - Steane's code for lower overhead
  2. Optimize syndrome extraction - Minimize measurement rounds
  3. Use fault-tolerant operations - Prevent error propagation
  4. Benchmark first - Test with small circuits

Real-World Applications

Surface Codes

While Shor's and Steane's codes are foundational, modern quantum computers use surface codes:

  • Higher threshold (~1% vs ~10^-4)
  • 2D nearest-neighbor connectivity
  • Scalable architecture

Concatenated Codes

For higher error rates, use concatenated codes:

# Concatenate Shor's code with itself
# Outer code: Shor's 9-qubit
# Inner code: Shor's 9-qubit
# Total: 81 physical qubits per logical qubit

Troubleshooting

Correction Fails

If error correction fails: - Check if error is within correction capability - Verify syndrome measurement accuracy - Ensure proper error injection

Performance Issues

  • Reduce circuit depth
  • Optimize syndrome extraction
  • Use efficient decoding algorithms

References

Next Steps