Merge branch 'development' into feat/pauli

Author: ciaranra

python/quantum-pecos/src/pecos/qeclib/steane/steane_class.py

@@ -14,6 +14,9 @@
 from typing import TYPE_CHECKING
 from warnings import warn
 
+from pecos.qeclib.steane.decoders.lookup import (
+    FlagLookupQASMActiveCorrectionZ,
+)
 from pecos.qeclib.steane.gates_sq import paulis, sqrt_paulis
 from pecos.qeclib.steane.gates_sq.hadamards import H
 from pecos.qeclib.steane.gates_tq import transversal_tq
@@ -162,9 +165,7 @@ def prep_t_plus_state(
                 d=self.d,
                 a=self.a,
                 out=self.scratch,
-                reject=self.scratch[
-                    2
-                ],  # the first two bits of self.scratch are used by "out"
+                reject=self.scratch[2],  # the first two bits are used by "out"
                 flag_x=self.flag_x,
                 flag_z=self.flag_z,
                 flags=self.flags,
@@ -268,6 +269,7 @@ def tdg(self, aux: Steane, reject: Bit | None = None, rus_limit: int | None = No
         )
 
     #  Begin Experimental: ------------------------------------
+
     def nonft_t_tel(self, aux: Steane):
         """Warning:
             This is experimental.
@@ -283,7 +285,7 @@ def nonft_t_tel(self, aux: Steane):
             aux.cx(self),
             self.mz(self.t_meas),
             If(self.t_meas == 1).Then(aux.x(), aux.sz()),
-            Permute(self.d, aux.d),
+            self.permute(aux),
         )
 
     def t_tel(
@@ -306,7 +308,7 @@ def t_tel(
             aux.cx(self),
             self.mz(self.t_meas),
             If(self.t_meas == 1).Then(aux.x(), aux.sz()),  # SZ/S correction.
-            Permute(self.d, aux.d),
+            self.permute(aux),
         )
 
     def nonft_tdg_tel(self, aux: Steane):
@@ -324,7 +326,7 @@ def nonft_tdg_tel(self, aux: Steane):
             aux.cx(self),
             self.mz(self.tdg_meas),
             If(self.tdg_meas == 1).Then(aux.x(), aux.szdg()),
-            Permute(self.d, aux.d),
+            self.permute(aux),
         )
 
     def tdg_tel(
@@ -347,8 +349,84 @@ def tdg_tel(
             aux.cx(self),
             self.mz(self.tdg_meas),
             If(self.t_meas == 1).Then(aux.x(), aux.szdg()),  # SZdg/Sdg correction.
-            Permute(self.d, aux.d),
+            self.permute(aux),
+        )
+
+    def t_cor(
+        self,
+        aux: Steane,
+        reject: Bit | None = None,
+        flag: Bit | None = None,
+        rus_limit: int | None = None,
+    ):
+        """T gate via teleportation using fault-tolerant initialization of the T|+> state.
+
+        Applies active corrections of errors diagnozed by the measurement for gate teleportation.
+        """
+        warn("Using experimental feature: t_cor", stacklevel=2)
+        block = Block(
+            # gate teleportation without logical correction
+            aux.prep_t_plus_state(reject=reject, rus_limit=rus_limit),
+            self.cx(aux),
+            aux.mz(self.t_meas),
+            # active error correction
+            self.syn_z.set(aux.syn_meas),
+            self.last_raw_syn_z.set(0),
+            self.pf_x.set(0),
+            FlagLookupQASMActiveCorrectionZ(
+                self.d,
+                self.syn_z,
+                self.syn_z,
+                self.last_raw_syn_z,
+                self.pf_x,
+                self.syn_z,
+                self.syn_z,
+                self.scratch,
+            ),
+            # logical correction
+            If(self.t_meas == 1).Then(self.sz()),
         )
+        if flag is not None:
+            block.extend(If(self.syn_z != 0).Then(flag.set(1)))
+        return block
+
+    def tdg_cor(
+        self,
+        aux: Steane,
+        reject: Bit | None = None,
+        flag: Bit | None = None,
+        rus_limit: int | None = None,
+    ):
+        """Tdg gate via teleportation using fault-tolerant initialization of the Tdg|+> state.
+
+        Applies active corrections of errors diagnozed by the measurement for gate teleportation.
+        """
+        warn("Using experimental feature: t_cor", stacklevel=2)
+        block = Block(
+            # gate teleportation without logical correction
+            aux.prep_tdg_plus_state(reject=reject, rus_limit=rus_limit),
+            self.cx(aux),
+            aux.mz(self.tdg_meas),
+            # active error correction
+            self.syn_z.set(aux.syn_meas),
+            self.last_raw_syn_z.set(0),
+            self.pf_x.set(0),
+            FlagLookupQASMActiveCorrectionZ(
+                self.d,
+                self.syn_z,
+                self.syn_z,
+                self.last_raw_syn_z,
+                self.pf_x,
+                self.syn_z,
+                self.syn_z,
+                self.scratch,
+            ),
+            # logical correction
+            If(self.tdg_meas == 1).Then(self.szdg()),
+        )
+        if flag is not None:
+            block.extend(If(self.syn_z != 0).Then(flag.set(1)))
+        return block
 
     # End Experimental: ------------------------------------
 
@@ -370,19 +448,17 @@ def cz(self, target: Steane):
 
     def m(self, meas_basis: str, log: Bit | None = None):
         """Destructively measure the logical qubit in some Pauli basis."""
-        block = Block(
-            MeasDecode(
-                q=self.d,
-                meas_basis=meas_basis,
-                meas=self.raw_meas,
-                log_raw=self.log_raw,
-                log=self.log,
-                syn_meas=self.syn_meas,
-                pf_x=self.pf_x,
-                pf_z=self.pf_z,
-                last_raw_syn_x=self.last_raw_syn_x,
-                last_raw_syn_z=self.last_raw_syn_z,
-            ),
+        block = MeasDecode(
+            q=self.d,
+            meas_basis=meas_basis,
+            meas=self.raw_meas,
+            log_raw=self.log_raw,
+            log=self.log,
+            syn_meas=self.syn_meas,
+            pf_x=self.pf_x,
+            pf_z=self.pf_z,
+            last_raw_syn_x=self.last_raw_syn_x,
+            last_raw_syn_z=self.last_raw_syn_z,
         )
         if log is not None:
             block.extend(log.set(self.log))
@@ -400,7 +476,7 @@ def mz(self, log: Bit | None = None):
         """Logical destructive measurement of the logical Z operator."""
         return self.m("Z", log=log)
 
-    def qec(self, flag_bit: Bit | None = None):
+    def qec(self, flag: Bit | None = None):
         block = ParallelFlagQECActiveCorrection(
             q=self.d,
             a=self.a,
@@ -416,6 +492,21 @@ def qec(self, flag_bit: Bit | None = None):
             pf_z=self.pf_z,
             scratch=self.scratch,
         )
-        if flag_bit is not None:
-            block.extend(If(self.flags != 0).Then(flag_bit.set(1)))
+        if flag is not None:
+            block.extend(If(self.flags != 0).Then(flag.set(1)))
+        return block
+
+    def permute(self, other: Steane):
+        """Permute this code block (including both quantum and classical registers) with another."""
+        block = Block(
+            Permute(self.d, other.d),
+            Permute(self.a, other.a),
+        )
+        for var_a, var_b in zip(self.vars, other.vars):
+            if isinstance(var_a, CReg):
+                block.extend(
+                    var_a.set(var_a ^ var_b),
+                    var_b.set(var_b ^ var_a),
+                    var_a.set(var_a ^ var_b),
+                )
         return block