upate shor code

Author: rochisha0

src/qutip_qip/algorithms/error_correction/shor_code.py

@@ -1,66 +1,40 @@
-import numpy as np
-from qutip import Qobj, tensor, basis, sigmax, sigmay, sigmaz
-from qutip_qip.operations import Gate
 from qutip_qip.circuit import QubitCircuit
-
-__all__ = ["ShorCode"]
-
+from qutip_qip.algorithms import BitFlipCode
+from qutip_qip.algorithms import PhaseFlipCode
 
 class ShorCode:
     """
-    Implementation of the 9-qubit Shor code.
-
-    The Shor code protects against arbitrary single-qubit errors by combining
-    the 3-qubit phase-flip code with the 3-qubit bit-flip code.
-
-    The logical states are encoded as:
-    |0⟩ → (|000⟩ + |111⟩)(|000⟩ + |111⟩)(|000⟩ + |111⟩) / 2√2
-    |1⟩ → (|000⟩ - |111⟩)(|000⟩ - |111⟩)(|000⟩ - |111⟩) / 2√2
-
-    This encoding allows correction of any single-qubit error (bit-flip, phase-flip,
-    or both) on any of the 9 physical qubits.
+    Constructs the 9-qubit Shor code encoding circuit using BitFlipCode and PhaseFlipCode.
     """
 
-    @staticmethod
-    def encode_circuit():
+    def __init__(self):
+        # Logical qubit -> Phase protection: [0, 3, 6] (1 qubit to 3)
+        # Each → BitFlipCode: [0,1,2], [3,4,5], [6,7,8]
+        self.data_qubits = list(range(9))
+        self.phase_code = PhaseFlipCode(data_qubits=[0, 3, 6], syndrome_qubits=[])  # No ancillas for encoding
+        self.bit_blocks = [
+            BitFlipCode(data_qubits=[0, 1, 2], syndrome_qubits=[]),
+            BitFlipCode(data_qubits=[3, 4, 5], syndrome_qubits=[]),
+            BitFlipCode(data_qubits=[6, 7, 8], syndrome_qubits=[])
+        ]
+        self.n_qubits = 9  # Encoding only requires 9 qubits
+
+    def encode_circuit(self):
         """
-        Create a circuit for encoding a single qubit into the 9-qubit Shor code.
-
-        The encoding process:
-        1. Apply phase-flip encoding to the input (creating |+++⟩ or |---⟩)
-        2. Apply bit-flip encoding to each of the three qubits
+        Construct the 9-qubit Shor code encoding circuit.
 
         Returns
         -------
-        qc : instance of QubitCircuit
-            Encoding circuit for the Shor code.
+        QubitCircuit
+            Circuit that encodes one logical qubit into the Shor code.
         """
-        qc = QubitCircuit(9)
-
-        # Step 1: Phase-flip encoding on the first qubit
-        # Apply Hadamard to the input qubit
-        qc.add_gate("SNOT", targets=0)
-
-        # Create the GHZ-like state by using CNOTs
-        qc.add_gate("CNOT", controls=0, targets=3)
-        qc.add_gate("CNOT", controls=0, targets=6)
-
-        # Apply Hadamard to all three qubits
-        qc.add_gate("SNOT", targets=0)
-        qc.add_gate("SNOT", targets=3)
-        qc.add_gate("SNOT", targets=6)
-
-        # Step 2: Bit-flip encoding for each of the three blocks
-        # First block: qubits 0,1,2
-        qc.add_gate("CNOT", controls=0, targets=1)
-        qc.add_gate("CNOT", controls=0, targets=2)
+        qc = QubitCircuit(self.n_qubits)
 
-        # Second block: qubits 3,4,5
-        qc.add_gate("CNOT", controls=3, targets=4)
-        qc.add_gate("CNOT", controls=3, targets=5)
+        phase_encode = self.phase_code.encode_circuit()
+        qc.gates.extend(phase_encode.gates)
 
-        # Third block: qubits 6,7,8
-        qc.add_gate("CNOT", controls=6, targets=7)
-        qc.add_gate("CNOT", controls=6, targets=8)
+        for bit_code in self.bit_blocks:
+            bit_encode = bit_code.encode_circuit()
+            qc.gates.extend(bit_encode.gates)
 
         return qc

tests/test_shor_code.py

@@ -1,45 +1,23 @@
 import pytest
-from qutip_qip.algorithms import ShorCode
+from qutip_qip.algorithms import ShorCode  # Adjust the import as per your file/module name
 
+def test_shor_encode_structure():
+    shor = ShorCode()
+    circuit = shor.encode_circuit()
 
-def test_encode_circuit():
-    """Test the Shor code encoding circuit structure."""
-    qc = ShorCode.encode_circuit()
+    # Gate count: 3 Hadamards (phase flip) + 6 CNOTs (bit flip blocks)
+    assert len(circuit.gates) == 9, "Shor code should have 3 Hadamards and 6 CNOTs in encode circuit."
 
-    # Check correct number of qubits
-    assert qc.N == 9
+    # Check Hadamard gates applied to qubits 0, 3, 6
+    snot_targets = [gate.targets[0] for gate in circuit.gates if gate.name == "SNOT"]
+    assert set(snot_targets) == {0, 3, 6}, "Hadamards should be on qubits 0, 3, and 6."
 
-    # Check total number of gates (1H + 2CNOT + 3H + 6CNOT = 12 gates)
-    assert len(qc.gates) == 12
+    # Check correct number of CNOTs for 3 blocks
+    cnot_gates = [gate for gate in circuit.gates if gate.name == "CNOT"]
+    assert len(cnot_gates) == 6, "Shor code encoding must include 6 CNOTs."
 
-    # Check first Hadamard gate (phase-flip encoding starts)
-    assert qc.gates[0].name == "SNOT" and qc.gates[0].targets[0] == 0
-
-    # Check first level CNOTs (create GHZ-like state across blocks)
-    assert qc.gates[1].name == "CNOT"
-    assert qc.gates[1].controls == [0] and qc.gates[1].targets[0] == 3
-    assert qc.gates[2].name == "CNOT"
-    assert qc.gates[2].controls == [0] and qc.gates[2].targets[0] == 6
-
-    # Check three Hadamard gates (complete phase-flip encoding)
-    assert qc.gates[3].name == "SNOT" and qc.gates[3].targets[0] == 0
-    assert qc.gates[4].name == "SNOT" and qc.gates[4].targets[0] == 3
-    assert qc.gates[5].name == "SNOT" and qc.gates[5].targets[0] == 6
-
-    # Check bit-flip encoding CNOTs for first block
-    assert qc.gates[6].name == "CNOT"
-    assert qc.gates[6].controls == [0] and qc.gates[6].targets[0] == 1
-    assert qc.gates[7].name == "CNOT"
-    assert qc.gates[7].controls == [0] and qc.gates[7].targets[0] == 2
-
-    # Check bit-flip encoding CNOTs for second block
-    assert qc.gates[8].name == "CNOT"
-    assert qc.gates[8].controls == [3] and qc.gates[8].targets[0] == 4
-    assert qc.gates[9].name == "CNOT"
-    assert qc.gates[9].controls == [3] and qc.gates[9].targets[0] == 5
-
-    # Check bit-flip encoding CNOTs for third block
-    assert qc.gates[10].name == "CNOT"
-    assert qc.gates[10].controls == [6] and qc.gates[10].targets[0] == 7
-    assert qc.gates[11].name == "CNOT"
-    assert qc.gates[11].controls == [6] and qc.gates[11].targets[0] == 8
+    # Check CNOTs in each block
+    expected_blocks = [(0, 1), (0, 2), (3, 4), (3, 5), (6, 7), (6, 8)]
+    actual_blocks = [(g.controls[0], g.targets[0]) for g in cnot_gates]
+    for pair in expected_blocks:
+        assert pair in actual_blocks, f"CNOT {pair} not found in circuit."