Shor Code: A Nine-Qubit Quantum Error Correcting Code

Table of Contents

1. Introduction
2. Why We Need the Shor Code
3. Basics of Quantum Error Correction
4. The Concept Behind Shor Code
5. What Errors Can Shor Code Correct?
6. Encoding in Shor Code
7. Step-by-Step Encoding Process
8. Logical Qubit Representation
9. Correcting Bit-Flip Errors
10. Correcting Phase-Flip Errors
11. Combined Error Protection
12. Shor Code Circuit Design
13. Syndrome Measurement
14. Recovery Operations
15. Shor Code Stabilizers
16. Fault Tolerance in Shor Code
17. Use of Ancilla Qubits
18. Error Propagation Considerations
19. Shor Code and Decoherence
20. Shor Code vs Simple Codes
21. Experimental Realization
22. Shor Code in Quantum Algorithms
23. Simulation and Emulation Tools
24. Limitations and Challenges
25. Conclusion

1. Introduction

The Shor Code is the first quantum error correcting code capable of correcting arbitrary single-qubit errors, including both bit-flip and phase-flip errors. It was introduced by Peter Shor in 1995 and laid the foundation for fault-tolerant quantum computation.

2. Why We Need the Shor Code

Quantum systems are susceptible to various types of errors. Unlike classical systems, quantum errors cannot be detected or corrected by direct measurement. A more sophisticated mechanism is needed that preserves superposition and entanglement.

3. Basics of Quantum Error Correction

Quantum error correction encodes one logical qubit into several physical qubits. It uses redundancy and syndrome measurements to detect and correct errors without collapsing the quantum information.

4. The Concept Behind Shor Code

The Shor Code protects a single logical qubit by:

• First encoding it against phase errors using 3 qubits
• Then encoding each of those against bit-flip errors using 3 more qubits each

This leads to a total of 9 qubits.

5. What Errors Can Shor Code Correct?

• Any single-qubit error, including arbitrary superpositions of Pauli \( X \), \( Y \), and \( Z \)
• Works even when the error is unknown or probabilistic

6. Encoding in Shor Code

Let \( |\psi\rangle = \alpha|0\rangle + \beta|1\rangle \). The logical codewords are:

\[
|0_L\rangle = \frac{1}{2\sqrt{2}}(|000\rangle + |111\rangle)^{\otimes 3}
\]
\[
|1_L\rangle = \frac{1}{2\sqrt{2}}(|000\rangle – |111\rangle)^{\otimes 3}
\]

7. Step-by-Step Encoding Process

1. Start with \( |\psi\rangle \)
2. Encode phase protection:
   \[
   |\psi’\rangle = \alpha|+\rangle|+\rangle|+\rangle + \beta|-\rangle|-\rangle|-\rangle
   \]
3. Apply 3-qubit bit-flip protection to each \( |+\rangle, |-\rangle \)

8. Logical Qubit Representation

• Logical \( |0_L\rangle \): three copies of \( |+\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) \)
• Logical \( |1_L\rangle \): three copies of \( |-\rangle = \frac{1}{\sqrt{2}}(|0\rangle – |1\rangle) \)

9. Correcting Bit-Flip Errors

Bit-flip detection:

• Use majority voting on each 3-qubit block
• If one qubit differs, correct using a Pauli-X gate

10. Correcting Phase-Flip Errors

Phase error affects one of the blocks:

• Convert phase flip to bit-flip using Hadamard gates
• Detect and correct as before

11. Combined Error Protection

By nesting bit-flip and phase-flip codes, Shor’s code can correct any Pauli error:
\[
X, Z, Y = iXZ
\]

Even if the nature of the error is unknown.

12. Shor Code Circuit Design

The encoding circuit involves:

• 2 Hadamard gates
• 6 CNOT gates for replication
• 3 ancilla qubits (optional) for measurement and correction

Quantum frameworks like Qiskit provide ready-made circuit templates.

13. Syndrome Measurement

Use ancilla qubits to measure stabilizers:

• No disturbance to the encoded logical qubit
• Output indicates error syndrome
• Guides which correction to apply

14. Recovery Operations

Based on syndrome:

• Apply \( X \) for detected bit flips
• Apply \( Z \) for detected phase flips
• Combined \( Y \) corrections if necessary

15. Shor Code Stabilizers

Stabilizer formalism defines generators:

\[
Z_1Z_2, \quad Z_2Z_3, \quad Z_4Z_5, \quad Z_5Z_6, \quad Z_7Z_8, \quad Z_8Z_9
\]
\[
X_1X_2X_3X_4X_5X_6, \quad X_4X_5X_6X_7X_8X_9
\]

These help in detecting and correcting errors via syndrome extraction.

16. Fault Tolerance in Shor Code

• Designed to work with imperfect gates
• Prevents error propagation during measurement
• Serves as a base model for fault-tolerant logic gates

17. Use of Ancilla Qubits

Ancillas are used to:

• Measure stabilizers
• Avoid entanglement collapse
• Provide measurement outputs for feedback

18. Error Propagation Considerations

CNOT gates can spread errors. Shor code accounts for this using:

• Gate sequencing
• Verified ancilla
• Redundant checks

19. Shor Code and Decoherence

It significantly increases robustness against decoherence:

• Protects against \( T_1 \), \( T_2 \) errors
• Encodes fragile quantum data into more stable blocks

20. Shor Code vs Simple Codes

21. Experimental Realization

Shor code has been demonstrated using:

• Trapped ions
• Superconducting qubits
• Photonic qubits (encoded polarization)

22. Shor Code in Quantum Algorithms

Used in:

• Fault-tolerant quantum gates
• Memory encoding for VQE, QAOA
• Benchmarking resilience in noisy systems

23. Simulation and Emulation Tools

• Qiskit: qiskit.ignis for error correction
• Cirq, QuTiP, and ProjectQ support Shor-like codes

24. Limitations and Challenges

• Overhead: 9 physical qubits per logical qubit
• Complexity of encoding and correction
• Requires high-fidelity operations and synchronized control

25. Conclusion

The Shor Code is a landmark in quantum error correction. It bridges simple error models with full fault-tolerant architectures and continues to inspire advanced codes and quantum hardware development. Mastering the Shor Code is foundational to building reliable, scalable quantum computers.