Extend functionality for working with codes.

src/mqt/qecc/codes/__init__.py

@@ -4,6 +4,7 @@
 
 from .bb_codes import construct_bb_code
 from .color_code import ColorCode, LatticeType
+from .concatenation import ConcatenatedCode, ConcatenatedCSSCode
 from .css_code import CSSCode, InvalidCSSCodeError
 from .hexagonal_color_code import HexagonalColorCode
 from .square_octagon_color_code import SquareOctagonColorCode
@@ -12,6 +13,8 @@
 __all__ = [
     "CSSCode",
     "ColorCode",
+    "ConcatenatedCSSCode",
+    "ConcatenatedCode",
     "HexagonalColorCode",
     "InvalidCSSCodeError",
     "InvalidStabilizerCodeError",

src/mqt/qecc/codes/concatenation.py

@@ -0,0 +1,137 @@
+"""Concatenated quantum codes."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from .css_code import CSSCode
+from .pauli import Pauli
+from .stabilizer_code import InvalidStabilizerCodeError, StabilizerCode
+from .symplectic import SymplecticVector
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import numpy.typing as npt
+
+
+class ConcatenatedCode(StabilizerCode):
+    """A concatenated quantum code."""
+
+    def __init__(self, outer_code: StabilizerCode, inner_code: StabilizerCode | Sequence[StabilizerCode]) -> None:
+        """Initialize a concatenated quantum code.
+
+        Args:
+            outer_code: The outer code.
+            inner_code: The inner code. If a list of codes is provided, the qubits of the outer code are encoded by the different inner codes in the list.
+        """
+        self.outer_code = outer_code
+        if isinstance(inner_code, list):
+            self.inner_codes = inner_code
+        else:
+            self.inner_codes = [inner_code] * outer_code.n
+        if not all(code.k == 1 for code in self.inner_codes):
+            msg = "The inner codes must be stabilizer codes with a single logical qubit."
+            raise InvalidStabilizerCodeError(msg)
+
+        self.n = sum(code.n for code in self.inner_codes)
+        generators = [self._outer_pauli_to_physical(p) for p in outer_code.generators]
+        if outer_code.x_logicals is not None:
+            x_logicals = [self._outer_pauli_to_physical(p) for p in outer_code.x_logicals]
+        if outer_code.z_logicals is not None:
+            z_logicals = [self._outer_pauli_to_physical(p) for p in outer_code.z_logicals]
+        d = min(code.distance * outer_code.distance for code in self.inner_codes)
+        super().__init__(generators, d, x_logicals, z_logicals)
+
+    def _outer_pauli_to_physical(self, p: Pauli) -> Pauli:
+        """Convert a Pauli operator on the outer code to the operator on the concatenated code.
+
+        Args:
+            p: The Pauli operator.
+
+        Returns:
+            The Pauli operator on the physical qubits.
+        """
+        if len(p) != self.outer_code.n:
+            msg = "The Pauli operator must have the same number of qubits as the outer code."
+            raise InvalidStabilizerCodeError(msg)
+        concatenated = SymplecticVector.zeros(self.n)
+        phase = 0
+        offset = 0
+        for i in range(self.outer_code.n):
+            c = self.inner_codes[i]
+            new_offset = offset + c.n
+            assert c.x_logicals is not None
+            assert c.z_logicals is not None
+            if p[i] == "X":
+                concatenated[offset:new_offset] = c.x_logicals[0].x_part()
+                concatenated[offset + self.n : new_offset + self.n] = c.x_logicals[0].z_part()
+                phase += c.x_logicals[0].phase
+            elif p[i] == "Z":
+                concatenated[offset:new_offset] = c.z_logicals[0].x_part()
+                concatenated[offset + self.n : new_offset + self.n] = c.z_logicals[0].z_part()
+                phase += c.z_logicals[0].phase
+
+            elif p[i] == "Y":
+                concatenated[offset:new_offset] = c.x_logicals[0].x_part ^ c.z_logicals[0].x_part()
+                concatenated[offset + self.n : new_offset + self.n] = c.x_logicals[0].z_part ^ c.z_logicals[0].z_part()
+                phase += c.x_logicals[0].phase + c.z_logicals[0].phase
+
+            offset = new_offset
+        return Pauli(concatenated, phase)
+
+
+# def _valid_logicals(lst: list[StabilizerTableau | None]) -> TypeGuard[list[StabilizerTableau]]:
+#     return None not in lst
+
+
+class ConcatenatedCSSCode(ConcatenatedCode, CSSCode):
+    """A concatenated CSS code."""
+
+    def __init__(self, outer_code: CSSCode, inner_codes: CSSCode | Sequence[CSSCode]) -> None:
+        """Initialize a concatenated CSS code.
+
+        Args:
+            outer_code: The outer code.
+            inner_codes: The inner code. If a list of codes is provided, the qubits of the outer code are encoded by the different inner codes in the list.
+        """
+        self.outer_code = outer_code
+        if isinstance(inner_codes, list):
+            self.inner_codes = inner_codes
+        else:
+            self.inner_codes = [inner_codes] * outer_code.n
+        if not all(code.k == 1 for code in self.inner_codes):
+            msg = "The inner codes must be CSS codes with a single logical qubit."
+            raise InvalidStabilizerCodeError(msg)
+
+        self.n = sum(code.n for code in self.inner_codes)
+        hx = np.array([self._outer_checks_to_physical(check, "X") for check in outer_code.Hx], dtype=np.int8)
+        hz = np.array([self._outer_checks_to_physical(check, "Z") for check in outer_code.Hz], dtype=np.int8)
+        d = min(code.distance * outer_code.distance for code in self.inner_codes)
+        CSSCode.__init__(self, d, hx, hz)
+
+    def _outer_checks_to_physical(self, check: npt.NDArray[np.int8], operator: str) -> npt.NDArray[np.int8]:
+        """Convert a check operator on the outer code to the operator on the concatenated code.
+
+        Args:
+            check: The check operator.
+            operator: The type of operator to be converted. Either 'X' or 'Z'.
+
+        Returns:
+            The check operator on the physical qubits.
+        """
+        if check.shape[0] != self.outer_code.n:
+            msg = "The check operator must have the same number of qubits as the outer code."
+            raise InvalidStabilizerCodeError(msg)
+        concatenated = np.zeros((self.n), dtype=np.int8)
+        offset = 0
+        for i in range(self.outer_code.n):
+            c = self.inner_codes[i]
+            new_offset = offset + c.n
+            if check[i] == 1:
+                logical = c.Lx if operator == "X" else c.Lz
+                concatenated[offset:new_offset] = logical
+            offset = new_offset
+        return concatenated

src/mqt/qecc/codes/css_code.py

@@ -8,13 +8,14 @@
 import numpy as np
 from ldpc import mod2
 
+from .pauli import StabilizerTableau
 from .stabilizer_code import StabilizerCode
 
 if TYPE_CHECKING:  # pragma: no cover
     import numpy.typing as npt
 
 
 class CSSCode(StabilizerCode):
     """A class for representing CSS codes."""
 
     def __init__(
@@ -24,19 +25,31 @@
         Hz: npt.NDArray[np.int8] | None = None,  # noqa: N803
         x_distance: int | None = None,
         z_distance: int | None = None,
+        n: int | None = None,
     ) -> None:
         """Initialize the code."""
+        if Hx is None and Hz is None:
+            if n is None:
+                msg = "If no check matrices are provided, the code size must be specified."
+                raise InvalidCSSCodeError(msg)
+            self.Hx = np.zeros((0, n), dtype=np.int8)
+            self.Hz = np.zeros((0, n), dtype=np.int8)
+            self.Lx = np.eye(n, dtype=np.int8)
+            self.Lz = np.eye(n, dtype=np.int8)
+            super().__init__([], 1, n=n)
+            return
+
         self._check_valid_check_matrices(Hx, Hz)
 
         if Hx is None:
             assert Hz is not None
             self.n = Hz.shape[1]
             self.Hx = np.zeros((0, self.n), dtype=np.int8)
         else:
             self.Hx = Hx
         if Hz is None:
             assert Hx is not None
             self.n = Hx.shape[1]
             self.Hz = np.zeros((0, self.n), dtype=np.int8)
         else:
             self.Hz = Hz
@@ -46,8 +59,8 @@
 
         x_padded = np.hstack([self.Hx, z_padding])
         z_padded = np.hstack([x_padding, self.Hz])
-        phases = np.zeros((x_padded.shape[0] + z_padded.shape[0], 1), dtype=np.int8)
-        super().__init__(np.hstack((np.vstack((x_padded, z_padded)), phases)), distance)
+        phases = np.zeros((x_padded.shape[0] + z_padded.shape[0]), dtype=np.int8)
+        super().__init__(StabilizerTableau(np.vstack((x_padded, z_padded)), phases), distance)
 
         self.distance = distance
         self.x_distance = x_distance if x_distance is not None else distance
@@ -157,6 +170,11 @@
                 msg = "The check matrices must be orthogonal"
                 raise InvalidCSSCodeError(msg)
 
+    @classmethod
+    def get_trivial_code(cls, n: int) -> CSSCode:
+        """Return the trivial code."""
+        return cls(1, None, None, n=n)
+
     @staticmethod
     def from_code_name(code_name: str, distance: int | None = None) -> CSSCode:
         r"""Return CSSCode object for a known code.