qec 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

qec/code_constructions/__init__.py

@@ -0,0 +1,4 @@
+from .stabilizer_code import StabilizerCode
+from .css_code import CSSCode
+from .hgp_code import HypergraphProductCode
+

qec/{stabilizer_code → code_constructions}/css_code.py

@@ -1,4 +1,4 @@
-from qec.stabilizer_code import StabilizerCode
+from qec.code_constructions import StabilizerCode
 from qec.utils.sparse_binary_utils import convert_to_binary_scipy_sparse
 
 # Added / ammended from old code
@@ -10,7 +10,7 @@ from ldpc import BpOsdDecoder
 from tqdm import tqdm
 import time
 import logging
-from typing import Optional
+from typing import Optional, Sequence
 
 logging.basicConfig(level=logging.DEBUG)
 
@@ -76,6 +76,9 @@ class CSSCode(StabilizerCode):
         self.x_logical_operator_basis = None
         self.z_logical_operator_basis = None
 
+        self.x_code_distance = None
+        self.z_code_distance = None
+
         # Check if the input matrices are NumPy arrays or SciPy sparse matrices
         if not isinstance(x_stabilizer_matrix, (np.ndarray, scipy.sparse.spmatrix)):
             raise TypeError(
@@ -182,7 +185,7 @@ class CSSCode(StabilizerCode):
 
     # TODO: Add a function to save the logical operator basis to a file
 
-    def check_valid_logical_xz_basis(self) -> bool:
+    def check_valid_logical_basis(self) -> bool:
         """
         Validate that the stored logical operators form a proper logical basis for the code.
 
@@ -408,7 +411,7 @@ class CSSCode(StabilizerCode):
         Returns
         -------
         int
-            Best estimate of code distance found within time limit.
+            Best estimate of code distance found within the time limit.
         """
         start_time = time.time()
 
@@ -419,13 +422,13 @@ class CSSCode(StabilizerCode):
         ):
             self.compute_logical_basis()
 
-        # Setup decoders for X and Z logical operators
-        bp_osd_x, x_stack, _, x_min_distance, x_max_distance = (
+        # Setup decoders and parameters for both X and Z
+        bp_osd_z, x_stack, full_rank_x, x_min_distance, x_max_distance = (
             self._setup_distance_estimation_decoder(
                 self.x_stabilizer_matrix, self.x_logical_operator_basis, decoder
             )
         )
-        bp_osd_z, z_stack, _, z_min_distance, z_max_distance = (
+        bp_osd_x, z_stack, full_rank_z, z_min_distance, z_max_distance = (
             self._setup_distance_estimation_decoder(
                 self.z_stabilizer_matrix, self.z_logical_operator_basis, decoder
             )
@@ -434,57 +437,106 @@ class CSSCode(StabilizerCode):
         candidate_logicals_x = []
         candidate_logicals_z = []
 
-        # Search loop
+        x_weight_one_searched = 0
+        z_weight_one_searched = 0
+
         with tqdm(total=timeout_seconds, desc="Estimating distance") as pbar:
             while time.time() - start_time < timeout_seconds:
                 elapsed = time.time() - start_time
                 pbar.update(elapsed - pbar.n)
 
-                # Generate random logical combinations for X
-                dummy_syndrome_x = (
-                    self._generate_random_logical_combination_for_distance_estimation(
-                        x_stack, p, self.x_stabilizer_matrix.shape[0]
-                    )
-                )
-                candidate_x = bp_osd_x.decode(dummy_syndrome_x)
-                x_weight = np.count_nonzero(candidate_x)
-
-                if x_weight < x_min_distance:
-                    x_min_distance = x_weight
-
-                if x_weight < x_max_distance and reduce_logical_basis:
-                    candidate_logicals_x.append(candidate_x)
-
-                # Generate random logical combinations for Z
-                dummy_syndrome_z = (
-                    self._generate_random_logical_combination_for_distance_estimation(
-                        z_stack, p, self.z_stabilizer_matrix.shape[0]
-                    )
-                )
-                candidate_z = bp_osd_z.decode(dummy_syndrome_z)
-                z_weight = np.count_nonzero(candidate_z)
-
-                if z_weight < z_min_distance:
-                    z_min_distance = z_weight
-
-                if z_weight < z_max_distance and reduce_logical_basis:
-                    candidate_logicals_z.append(candidate_z)
-
-                # Update progress bar description
+                if np.random.rand() < 0.5:
+                    # X Logical operators
+                    if x_weight_one_searched < self.z_logical_operator_basis.shape[0]:
+                        dummy_syndrome_x = np.zeros(z_stack.shape[0], dtype=np.uint8)
+                        dummy_syndrome_x[
+                            full_rank_z.shape[0] + x_weight_one_searched
+                        ] = 1
+                        x_weight_one_searched += 1
+                    else:
+                        dummy_syndrome_x = self._generate_random_logical_combination_for_distance_estimation(
+                            z_stack, p, self.z_stabilizer_matrix.shape[0]
+                        )
+
+                    candidate_x = bp_osd_x.decode(dummy_syndrome_x)
+                    x_weight = np.count_nonzero(candidate_x)
+                    if x_weight < x_min_distance:
+                        x_min_distance = x_weight
+
+                    if x_weight < x_max_distance and reduce_logical_basis:
+                        candidate_logicals_x.append(candidate_x)
+
+                        # Reduce X logical operator basis independently
+                        if len(candidate_logicals_x) >= 5:
+                            self._reduce_logical_operator_basis(
+                                candidate_logicals_x, []
+                            )
+                            (
+                                bp_osd_x,
+                                z_stack,
+                                full_rank_z,
+                                z_min_distance,
+                                z_max_distance,
+                            ) = self._setup_distance_estimation_decoder(
+                                self.z_stabilizer_matrix,
+                                self.z_logical_operator_basis,
+                                decoder,
+                            )
+                            candidate_logicals_x = []
+                            x_weight_one_searched = 0
+
+                else:
+                    # Z Logical operators
+                    if z_weight_one_searched < self.x_logical_operator_basis.shape[0]:
+                        dummy_syndrome_z = np.zeros(x_stack.shape[0], dtype=np.uint8)
+                        dummy_syndrome_z[
+                            full_rank_x.shape[0] + z_weight_one_searched
+                        ] = 1
+                        z_weight_one_searched += 1
+                    else:
+                        dummy_syndrome_z = self._generate_random_logical_combination_for_distance_estimation(
+                            x_stack, p, self.x_stabilizer_matrix.shape[0]
+                        )
+
+                    candidate_z = bp_osd_z.decode(dummy_syndrome_z)
+                    z_weight = np.count_nonzero(candidate_z)
+                    if z_weight < z_min_distance:
+                        z_min_distance = z_weight
+
+                    if z_weight < z_max_distance and reduce_logical_basis:
+                        candidate_logicals_z.append(candidate_z)
+
+                        # Reduce Z logical operator basis independently
+                        if len(candidate_logicals_z) >= 5:
+                            self._reduce_logical_operator_basis(
+                                [], candidate_logicals_z
+                            )
+                            (
+                                bp_osd_z,
+                                x_stack,
+                                full_rank_x,
+                                x_min_distance,
+                                x_max_distance,
+                            ) = self._setup_distance_estimation_decoder(
+                                self.x_stabilizer_matrix,
+                                self.x_logical_operator_basis,
+                                decoder,
+                            )
+                            candidate_logicals_z = []
+                            z_weight_one_searched = 0
+
+                x_weights, z_weights = self.logical_basis_weights()
                 pbar.set_description(
-                    f"Estimating distance: dx <= {x_min_distance}, dz <= {z_min_distance}"
+                    f"Estimating distance: dx <= {x_min_distance}, dz <= {z_min_distance}, x-weights: {np.mean(x_weights):.2f}, z-weights: {np.mean(z_weights):.2f}"
                 )
 
-        # Update distances and reduce logical bases if applicable
+        self._reduce_logical_operator_basis(candidate_logicals_x, candidate_logicals_z)
+
+        # Update distances
         self.x_code_distance = x_min_distance
         self.z_code_distance = z_min_distance
         self.code_distance = min(x_min_distance, z_min_distance)
 
-        if reduce_logical_basis:
-            self._reduce_logical_operator_basis(
-                candidate_logicals_x, candidate_logicals_z
-            )
-
         return self.code_distance
 
     def _setup_distance_estimation_decoder(
@@ -569,28 +621,140 @@ class CSSCode(StabilizerCode):
 
         return dummy_syndrome
 
+    def _reduce_logical_operator_basis(
+        self,
+        candidate_logicals_x: Union[Sequence, np.ndarray, scipy.sparse.spmatrix] = [],
+        candidate_logicals_z: Union[Sequence, np.ndarray, scipy.sparse.spmatrix] = [],
+    ):
+        """
+        Reduce the logical operator bases (for X and Z) to include lower-weight logicals.
+
+        Parameters
+        ----------
+        candidate_logicals_x : Union[Sequence, np.ndarray, scipy.sparse.spmatrix], optional
+            A list or array of candidate X logical operators to consider for reducing the X basis.
+            Defaults to an empty list.
+        candidate_logicals_z : Union[Sequence, np.ndarray, scipy.sparse.spmatrix], optional
+            A list or array of candidate Z logical operators to consider for reducing the Z basis.
+            Defaults to an empty list.
+        """
+        # Reduce X logical operator basis
+        if candidate_logicals_x:
+            # Convert candidates to a sparse matrix if they aren't already
+            if not isinstance(candidate_logicals_x, scipy.sparse.spmatrix):
+                candidate_logicals_x = scipy.sparse.csr_matrix(candidate_logicals_x)
+
+            # Stack the candidate X logicals with the existing X logicals
+            temp_x = scipy.sparse.vstack(
+                [candidate_logicals_x, self.x_logical_operator_basis]
+            ).tocsr()
+
+            # Calculate Hamming weights for sorting
+            x_row_weights = temp_x.getnnz(axis=1)
+            sorted_x_rows = np.argsort(x_row_weights)
+            temp_x = temp_x[sorted_x_rows, :]
+
+            # Add the X stabilizer matrix to the top of the stack
+            temp_x = scipy.sparse.vstack([self.x_stabilizer_matrix, temp_x]).tocsr()
+
+            # Determine rank of the X stabilizer matrix
+            rank_hx = ldpc.mod2.rank(self.x_stabilizer_matrix)
+
+            # Perform row reduction to find a new X logical basis
+            pivots_x = ldpc.mod2.pivot_rows(temp_x)
+            self.x_logical_operator_basis = temp_x[pivots_x[rank_hx:], :]
+
+        # Reduce Z logical operator basis
+        if candidate_logicals_z:
+            # Convert candidates to a sparse matrix if they aren't already
+            if not isinstance(candidate_logicals_z, scipy.sparse.spmatrix):
+                candidate_logicals_z = scipy.sparse.csr_matrix(candidate_logicals_z)
+
+            # Stack the candidate Z logicals with the existing Z logicals
+            temp_z = scipy.sparse.vstack(
+                [candidate_logicals_z, self.z_logical_operator_basis]
+            ).tocsr()
+
+            # Calculate Hamming weights for sorting
+            z_row_weights = temp_z.getnnz(axis=1)
+            sorted_z_rows = np.argsort(z_row_weights)
+            temp_z = temp_z[sorted_z_rows, :]
+
+            # Add the Z stabilizer matrix to the top of the stack
+            temp_z = scipy.sparse.vstack([self.z_stabilizer_matrix, temp_z]).tocsr()
+
+            # Determine rank of the Z stabilizer matrix
+            rank_hz = ldpc.mod2.rank(self.z_stabilizer_matrix)
+
+            # Perform row reduction to find a new Z logical basis
+            pivots_z = ldpc.mod2.pivot_rows(temp_z)
+            self.z_logical_operator_basis = temp_z[pivots_z[rank_hz:], :]
+
     def fix_logical_operators(self, fix_logical: str = "X"):
+        """
+        Create a canonical basis of logical operators where X-logical and Z-logical operators pairwise anticommute.
+
+        Parameters
+        ----------
+        fix_logical : str, optional
+            Specify which logical operator basis to fix. "X" adjusts Z-logicals based on X-logicals, and "Z" adjusts
+            X-logicals based on Z-logicals. Default is "X".
+
+        Raises
+        ------
+        TypeError
+            If `fix_logical` is not a string.
+        ValueError
+            If `fix_logical` is not "X" or "Z".
+
+        Returns
+        -------
+        bool
+            True if the logical operator basis is valid after fixing; False otherwise.
+
+        Notes
+        -----
+        This method ensures that the symplectic product of the logical bases results in the identity matrix.
+        If any issues occur during the adjustment, the method logs an error.
+        """
         if not isinstance(fix_logical, str):
             raise TypeError("fix_logical parameter must be a string")
 
         if fix_logical.lower() == "x":
             temp = self.z_logical_operator_basis @ self.x_logical_operator_basis.T
             temp.data = temp.data % 2
-            temp = ldpc.mod2.inverse(temp)
+            temp = scipy.sparse.csr_matrix(ldpc.mod2.inverse(temp), dtype=np.uint8)
             self.z_logical_operator_basis = temp @ self.z_logical_operator_basis
             self.z_logical_operator_basis.data = self.z_logical_operator_basis.data % 2
 
         elif fix_logical.lower() == "z":
             temp = self.x_logical_operator_basis @ self.z_logical_operator_basis.T
             temp.data = temp.data % 2
-            temp = ldpc.mod2.inverse(temp)
+            temp = scipy.sparse.csr_matrix(ldpc.mod2.inverse(temp), dtype=np.uint8)
             self.x_logical_operator_basis = temp @ self.x_logical_operator_basis
             self.x_logical_operator_basis.data = self.x_logical_operator_basis.data % 2
         else:
             raise ValueError("Invalid fix_logical parameter")
 
-    @property
-    def logical_operator_weights(self) -> Tuple[np.ndarray, np.ndarray]:
+        try:
+            assert self.check_valid_logical_basis()
+        except AssertionError:
+            logging.error("Logical basis is not valid after fixing logical operators.")
+            return False
+
+        try:
+            lx_lz = self.x_logical_operator_basis @ self.z_logical_operator_basis.T
+            lx_lz.data = lx_lz.data % 2
+            assert (
+                lx_lz != scipy.sparse.eye(self.logical_qubit_count, format="csr")
+            ).nnz == 0
+        except AssertionError:
+            logging.error("Logical basis is not valid after fixing logical operators.")
+            return False
+
+        return True
+
+    def logical_basis_weights(self) -> Tuple[np.ndarray, np.ndarray]:
         x_weights = []
         z_weights = []
         for i in range(self.logical_qubit_count):

qec/code_constructions/hgp_code.py

@@ -0,0 +1,264 @@
+import numpy as np
+import scipy 
+from typing import Union, Tuple
+import ldpc.mod2 
+import time
+
+from qec.code_constructions import CSSCode
+from qec.utils.sparse_binary_utils import convert_to_binary_scipy_sparse
+
+class HypergraphProductCode(CSSCode):
+    """
+    Implements a Hypergraph Product (HGP) code - derived from two classical linear binary codes.
+    
+    Parameters
+    ----------
+    seed_matrix_1 : 
+        A classical linear binary code used as a "seed" in the HGP construction method.
+    seed_matrix_2 :
+        A classical linear binary code used as a "seed" in the HGP construction method.
+    name : str, default = None
+        The name of the code. If None, the name is set to: "Hypergraph product code" 
+    
+    Attributes
+    ----------
+    seed_matrix_1 : scipy.sparse.spmatrix
+        The input seed_matrix_1 stored as a scipy sparse matrix.
+    seed_matrix_2 : scipy.sparse.spmatrix
+        The input seed_matrix_2 stored as a scipy sparse matrix.
+    _n1 : int
+        Number of columns in seed_matrix_1
+    _n2 : int
+        Number of columns in seed_matrix_2
+    _m1 : int
+        Number of rows in seed_matrix_1 (the number of columns of it's transpose)
+    _m2 : int
+        Number of rows in seed_matrix_2 (the number of columns of it's transpose)
+    
+    Notes
+    -----
+
+    The X and Z stabilizer matrices are given by [1]_: 
+    
+    .. math::
+
+        \begin{align}
+            H_{X} &= \begin{pmatrix}
+                        H_{1}\otimes I_{n_{2}} & \,\,I_{r_{1}}\otimes H_{2}^{T}
+                     \end{pmatrix}\tag*{(1)}\\
+            H_{Z} &= \begin{pmatrix}
+                        I_{n_{1}}\otimes H_{2} & \,\,H_{1}^{T}\otimes I_{r_{2}}
+                     \end{pmatrix}~, \tag*{(2)}
+        \end{align}
+
+    where  :math:`H_1` and  :math:`H_2` correspond to the parity check matrix of the first and second "seed" codes.
+    
+
+    .. [1] J.-P. Tillich and G. Zemor, “Quantum LDPC Codes With Positive Rate and Minimum Distance Proportional to the Square Root of the Blocklength”, IEEE Transactions on Information Theory 60, 1193 (2014)
+    """
+
+    def __init__(
+        self,
+        seed_matrix_1 : Union[np.ndarray, scipy.sparse.spmatrix],
+        seed_matrix_2 : Union[np.ndarray, scipy.sparse.spmatrix],
+        name : str = None
+    ):
+
+        self.name = name if name else "Hypergraph product code"
+
+        if not all(isinstance(seed_m, (np.ndarray, scipy.sparse.spmatrix)) for seed_m in (seed_matrix_1, seed_matrix_2)):
+            raise TypeError("The seed matrices must be either numpy arrays or scipy sparse matrices.")
+
+        self.seed_matrix_1 = convert_to_binary_scipy_sparse(seed_matrix_1)
+        self.seed_matrix_2 = convert_to_binary_scipy_sparse(seed_matrix_2)
+
+        # maybe move the below to a private _construct_stabilizer_matrices function?
+        # --------------------------------------------------------------------------
+        self._n1 = seed_matrix_1.shape[1]
+        self._n2 = seed_matrix_2.shape[1]
+
+        self._m1 = seed_matrix_1.shape[0]
+        self._m2 = seed_matrix_2.shape[0]
+
+        x_left = scipy.sparse.kron(seed_matrix_1, scipy.sparse.eye(self._n2))
+        x_right = scipy.sparse.kron(scipy.sparse.eye(self._m1), seed_matrix_2.T)
+        self.x_stabilizer_matrix = scipy.sparse.hstack([x_left, x_right])
+
+        z_left = scipy.sparse.kron(scipy.sparse.eye(self._n1), seed_matrix_2)
+        z_right = scipy.sparse.kron(seed_matrix_1.T, scipy.sparse.eye(self._m2))
+        self.z_stabilizer_matrix = scipy.sparse.hstack([z_left, z_right])
+        # --------------------------------------------------------------------------
+
+        super().__init__(self.x_stabilizer_matrix, self.z_stabilizer_matrix, self.name)
+    
+
+    def compute_exact_code_distance(self) -> int:
+        """
+        Computes the exact code distance of the HGP code.
+        
+        Returns
+        -------
+        int 
+            The distance of the code. 
+
+        Notes
+        -----
+        The distance of a HGP code is given as: 
+        
+        .. math::
+
+            \min(d_1, d_2, d_1^T, d_2^T)
+
+        corresponding to the distance of the seed codes and the distance of their transposes.
+        """
+    
+        rank_seed_m1 = ldpc.mod2.rank(self.seed_matrix_1)
+        rank_seed_m2 = ldpc.mod2.rank(self.seed_matrix_2)
+        
+        if self.seed_matrix_1.shape[1] != rank_seed_m1:
+            self.d1 = ldpc.mod2.compute_exact_code_distance(self.seed_matrix_1)
+        else:
+            self.d1 = np.inf
+
+        if self.seed_matrix_2.shape[1] != rank_seed_m2:
+            self.d2 = ldpc.mod2.compute_exact_code_distance(self.seed_matrix_2)
+        else:
+            self.d2 = np.inf
+        
+        # note: rank(A) = rank(A^T):
+        if self.seed_matrix_1.shape[0] != rank_seed_m1:
+            self.d1T = ldpc.mod2.compute_exact_code_distance(self.seed_matrix_1.T)
+        else:
+            self.d1T = np.inf
+
+        if self.seed_matrix_2.shape[0] != rank_seed_m2:
+            self.d2T = ldpc.mod2.compute_exact_code_distance(self.seed_matrix_2.T)
+        else:
+            self.d2T = np.inf
+
+        self.x_code_distance = min(self.d1T, self.d2)
+        self.z_code_distance = min(self.d1, self.d2T)
+        self.code_distance = min(self.x_code_distance, self.z_code_distance)
+
+        return self.code_distance
+       
+
+    def estimate_min_distance(self, timeout_seconds: float = 0.025) -> int:
+        """
+        Estimate the minimum X and Z distance of the HGP code.        Parameters
+        ----------
+        timeout_seconds : float, optional 
+            Time limit in seconds for the full search. Default: 0.25 
+        
+        Returns
+        -------
+        int
+            Best estimate of the (overall) code distance found within time limit. 
+
+        """
+        
+        rank_seed_m1 = ldpc.mod2.rank(self.seed_matrix_1)
+        rank_seed_m2 = ldpc.mod2.rank(self.seed_matrix_2)
+
+
+        d1_timeout_seconds = timeout_seconds/4
+        if self.seed_matrix_1.shape[1] != rank_seed_m1:    
+            d1_start_time = time.time()
+            d1_min_estimate, _, _ = ldpc.mod2.estimate_code_distance(self.seed_matrix_1, d1_timeout_seconds, 0)
+            d1_run_time = time.time() - d1_start_time
+        else:
+            d1_min_estimate = np.inf
+            d1_run_time = 0
+
+        d1T_timeout_seconds = (d1_timeout_seconds * 4 - d1_run_time)/3 if d1_run_time <= d1_timeout_seconds else timeout_seconds/4
+        if self.seed_matrix_1.shape[0] != rank_seed_m1:
+            d1T_start_time = time.time()
+            d1T_min_estimate, _, _ = ldpc.mod2.estimate_code_distance(self.seed_matrix_1.T, d1T_timeout_seconds, 0)
+            d1T_run_time = time.time() - d1T_start_time
+        else:
+            d1T_min_estimate = np.inf
+            d1T_run_time = 0
+
+        d2_timeout_seconds = (d1T_timeout_seconds * 3 - d1T_run_time)/2 if d1T_run_time <= d1T_timeout_seconds else timeout_seconds/4
+        if self.seed_matrix_2.shape[1] != rank_seed_m2:
+            d2_start_time = time.time()
+            d2_min_estimate, _, _ = ldpc.mod2.estimate_code_distance(self.seed_matrix_2, d2_timeout_seconds, 0)
+            d2_run_time = time.time() - d2_start_time
+        else:
+            d2_min_estimate = np.inf
+            d2_run_time = 0
+
+
+        d2T_timeout_seconds = (d2_timeout_seconds * 2 - d2_run_time) if d2_run_time <= d2_timeout_seconds else timeout_seconds/4
+        if self.seed_matrix_2.shape[0] != rank_seed_m2:
+            d2T_min_estimate, _, _ = ldpc.mod2.estimate_code_distance(self.seed_matrix_2.T, d2T_timeout_seconds, 0)
+        else:
+            d2T_min_estimate = np.inf
+        
+        self.x_code_distance = min(d1T_min_estimate, d2_min_estimate)
+        self.z_code_distance = min(d1_min_estimate, d2T_min_estimate)
+        self.code_distance = min(self.x_code_distance, self.z_code_distance)
+
+
+        return self.code_distance
+
+
+
+    def compute_logical_basis(self) -> Tuple[scipy.sparse.spmatrix, scipy.sparse.spmatrix]:
+        """
+        Compute the logical operator basis for the given HGP code.
+
+        Returns
+        -------
+        Tuple[scipy.sparse.spmatrix, scipy.sparse.spmatrix]
+            Logical X and Z operator bases (lx, lz).
+        """
+
+        ker_h1 = ldpc.mod2.kernel(self.seed_matrix_1)
+        ker_h2 = ldpc.mod2.kernel(self.seed_matrix_2)
+        ker_h1T = ldpc.mod2.kernel(self.seed_matrix_1.T)
+        ker_h2T = ldpc.mod2.kernel(self.seed_matrix_2.T)
+
+        row_comp_h1 = ldpc.mod2.row_complement_basis(self.seed_matrix_1)
+        row_comp_h2 = ldpc.mod2.row_complement_basis(self.seed_matrix_2)
+        row_comp_h1T = ldpc.mod2.row_complement_basis(self.seed_matrix_1.T)
+        row_comp_h2T = ldpc.mod2.row_complement_basis(self.seed_matrix_2.T)
+
+        temp = scipy.sparse.kron(ker_h1, row_comp_h2)
+        lz1 = scipy.sparse.hstack([temp, scipy.sparse.csr_matrix((temp.shape[0], self._m1*self._m2), dtype=np.uint8)])
+
+        temp = scipy.sparse.kron(row_comp_h1T, ker_h2T)
+        lz2 = scipy.sparse.hstack([scipy.sparse.csr_matrix((temp.shape[0], self._n1*self._n2), dtype=np.uint8), temp])
+
+        self.z_logical_operator_basis = scipy.sparse.vstack([lz1, lz2], dtype=np.uint8)
+
+
+        temp = scipy.sparse.kron(row_comp_h1, ker_h2)
+        lx1 = scipy.sparse.hstack([temp, scipy.sparse.csr_matrix((temp.shape[0], self._m1*self._m2), dtype=np.uint8)])
+
+        temp = scipy.sparse.kron(ker_h1T, row_comp_h2T)
+        lx2 = scipy.sparse.hstack([scipy.sparse.csr_matrix((temp.shape[0], self._n1*self._n2), dtype=np.uint8), temp])
+
+        self.x_logical_operator_basis= scipy.sparse.vstack([lx1, lx2], dtype = np.uint8)
+        
+        # Follows the way it is done in CSSCode -> move it into __init__? 
+        #---------------------------------------------------------------- 
+        self.logical_qubit_count = self.x_logical_operator_basis.shape[0]
+        #---------------------------------------------------------------- 
+
+        return (self.x_logical_operator_basis, self.z_logical_operator_basis)
+
+
+    def __str__(self):
+        """
+        String representation of the HGP code. Includes the name and [[n, k, d]] properties of the code.
+
+        Returns
+        -------
+        str 
+            String representation of the HGP code. 
+        """
+    
+        return f"{self.name} Hypergraphproduct Code: [[N={self.physical_qubit_count}, K={self.logical_qubit_count}, dx={self.x_code_distance}, dz={self.z_code_distance}]]"
+
+

qec/code_instances/__init__.py

@@ -0,0 +1 @@
+from .five_qubit_code import FiveQubitCode

qec/{quantum_codes → code_instances}/five_qubit_code.py

@@ -1,4 +1,4 @@
-from qec.stabilizer_code.stabilizer_code import StabilizerCode
+from qec.code_constructions import StabilizerCode
 
 
 class FiveQubitCode(StabilizerCode):

qec/codetables_de/__init__.py

@@ -0,0 +1 @@
+from .codetables_de import CodeTablesDE

qec/{quantum_codes → codetables_de}/codetables_de.py

@@ -1,4 +1,4 @@
-from qec.stabilizer_code import StabilizerCode
+from qec.code_constructions import StabilizerCode
 from qec.utils.codetables_de_utils import get_codetables_de_matrix, pcm_to_csr_matrix
 
 

qec-0.2.2.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.2
+Name: qec
+Version: 0.2.2
+Summary: Python Tools for Quantum Error Correction
+Author-email: Joschka Roffe <joschka@roffe.eu>
+License: MIT License
+        
+        Copyright (c) 2023 qec.Codes
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ldpc
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.9.3
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+
+<h1>
+<p align="center">
+  <br>QEC
+</h1>
+  <p align="center">
+    Python Tools for Quantum Error Correction
+    <br />
+    <a href="https://qec.codes/">Website</a>
+    ·
+    <a href="#features">Features</a>
+    ·
+    <a href="#installation">Installation</a>
+    ·
+    <a href="#examples">Examples</a>
+  </p>
+</p>
+
+# Features
+
+## Code constructions and fundamental analysis
+We currently provide the construction methods for the stabilizer generators of the QEC code families below, along with optimized methods to obtain their fundamental properties. All the classes allow to:
+
+- obtain the physical qubit count
+- obtain the logical qubit count
+- calculate the exact code distance
+- estimate the minimum code distance
+- obtain a logical basis
+
+The classes (along with their extre methods) are:
+
+- Hyperprgarph Product (HGP) codes, with methods:
+  - construct the x and z stabiliser matrices from the seed codes
+  - obtain the canonical basis (work in progress)
+    
+- Calderbank-Shor-Steane (CSS) codes
+  - check that the seed codes satisfy the CSS criteria
+    
+- Stabiliser codes
+  - check that the input stabiliser matrix is valid
+
+## Circuit compilation
+Work in progress.
+
+# Installation 
+
+Simply do:
+```bash
+pip install qec
+```
+
+or obtain a local copy of the package by cloning it, then navigate into the created folder: 
+
+```bash
+git clone git@github.com:qec-codes/qec.git
+cd qec
+```
+
+Finally, install the package:
+
+```bash
+pip install -e .
+```
+
+You are all set! To import the package use:
+
+```python
+In  [1]: import qec
+
+In  [2]: qec.__version__
+Out [2]: '0.1.0'
+
+```
+
+# Examples
+
+In this example we are going to create the Steane code, and obtain its fundamental code properties. We start by initialising its seed matrices (the [7, 4, 3] Hamming code):
+```python
+In [1]: import numpy as np
+In [2]: from qec.code_constructions import CSSCode
+
+In [3]: hamming_code = np.array([[1, 0, 0, 1, 0, 1, 1],
+                                 [0, 1, 0, 1, 1, 0, 1],
+                                 [0, 0, 1, 0, 1, 1, 1]])
+```
+as the Steane code is part of the CSS code family, we can use the `CSSCode` class:
+
+```python
+In [4]: steane_code = CSSCode(x_stabilizer_matrix = hamming_code,
+                              z_stabilizer_matrix = hamming_code,
+                              name = "Steane")
+In [5]: print(steane_code)
+Out [6]: Steane Code: [[N=7, K=1, dx<=3, dz<=3]]
+```
+
+we can see that all the fundamental properties (N - physical qubit number, K - logical qubit number, dx - X distance, dz - Z distance) are pre-calculated for us. We can continue our analysis by taking a look at the x and z logical basis of the code: 
+
+```python
+In [7]: print(steane_code.x_logical_operator_basis.toarray())
+Out [8]: [[1 1 0 1 0 0 0]]
+In [9]: print(steane_code.z_logical_operator_basis.toarray())
+Out [10]: [[1 1 0 1 0 0 0]]
+```
+
+                              
+
+
+
+
+

qec-0.2.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+qec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qec/code_constructions/__init__.py,sha256=MWyNUCS5mYcDzjGr_nbr2-ifkJigRJIzsw7sQIQXDfM,119
+qec/code_constructions/css_code.py,sha256=nIaC24QhQwrmWQNhmX-X4TzlkmNAYoxN0feTdWjhswo,32376
+qec/code_constructions/hgp_code.py,sha256=VAKU2lfZnDXSmAk6xFZCYT5b0hbtXpEoQUw4qHFcaEk,10419
+qec/code_constructions/stabilizer_code.py,sha256=I5u8JKZu88ioC4E2nBJ-00xCmnL8nU6kdAvwYOfmNRk,22138
+qec/code_instances/__init__.py,sha256=z6jOPjekDIx0jgbRFThI95zUzLzjl9Dh89RBzxsT_BE,43
+qec/code_instances/five_qubit_code.py,sha256=ZHyusTEnnnmUv4QxPLXQSKbEQv2QOoBqn2V9N4SgrQE,2177
+qec/codetables_de/__init__.py,sha256=dQBgkBK_DlnI9OrOcfarM7HUbj9NKyO-9QSvItD2cyY,40
+qec/codetables_de/codetables_de.py,sha256=SdOaS7OTMt76uLa1GJXGydMTmwJdNwTDnQyD4SBQDIM,3626
+qec/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qec/utils/binary_pauli_utils.py,sha256=BSlngYDdRICu0aVu4u_m0bvLicohORyGxfk5eRER7TQ,13245
+qec/utils/codetables_de_utils.py,sha256=S1wcVGJkkASQQ5s71QAsYBmpyE-3xTb6UsvgMfQtuiw,9469
+qec/utils/sparse_binary_utils.py,sha256=Y9xfGKzOGFiVTyhb6iF6N7-5oMY6Ah9oLrnv8HhSBHA,1965
+qec-0.2.2.dist-info/LICENSE,sha256=1b_xwNz1znYBfEaCL6pN2gNBAn8pQIjDRs_UhDp1EJI,1066
+qec-0.2.2.dist-info/METADATA,sha256=Soh5GrdXcP861-epLVwGnKlk7tVrrtVVc1xKFTowbhA,4509
+qec-0.2.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+qec-0.2.2.dist-info/top_level.txt,sha256=d8l_7pJ5u9uWdviNp0FUK-j8VPZqywkDek7qa4NDank,4
+qec-0.2.2.dist-info/RECORD,,

qec/quantum_codes/__init__.py

@@ -1,2 +0,0 @@
-from qec.quantum_codes.five_qubit_code import FiveQubitCode
-from qec.quantum_codes.codetables_de import CodeTablesDE

qec/stabilizer_code/__init__.py

@@ -1 +0,0 @@
-from qec.stabilizer_code.stabilizer_code import StabilizerCode

qec-0.2.1.dist-info/METADATA

@@ -1,82 +0,0 @@
-Metadata-Version: 2.2
-Name: qec
-Version: 0.2.1
-Summary: Python Tools for Quantum Error Correction
-Author-email: Joschka Roffe <joschka@roffe.eu>
-License: MIT License
-        
-        Copyright (c) 2023 qec.Codes
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
-Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: ldpc
-Requires-Dist: numpy>=1.24.0
-Requires-Dist: scipy>=1.9.3
-Requires-Dist: requests
-Requires-Dist: beautifulsoup4
-
-<h1 align="center">QEC </h1>
-<h3 align="center"> Python Tools for Quantum Error Correction </h3>
-
-
-- Website: https://qec.codes/
-
-# Table of contents
-1. [Features](#features)
-2. [Installation](#installation)
-3. [Getting started](#getting-started)
-
-
-# Features
-
-Here will go the description of all our fancy features! 
-
-# Installation 
-
-Obtain a local copy of the package by cloning it, then navigate into the created folder: 
-
-```bash
-git clone git@github.com:qec-codes/qec.git
-cd qec
-```
-
-Finally, install the package:
-
-```bash
-pip install -e .
-```
-
-You are all set! To import the package use:
-
-```python
-In  [1]: import qec
-
-In  [2]: qec.__version__
-Out [2]: '0.1.0'
-
-```
-
-# Getting started
-
-A few simple examples 
-

qec-0.2.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-qec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qec/quantum_codes/__init__.py,sha256=DQ1ztrq-vBpTyoehaMWOhals46tRj553Jmkq68bDk-E,117
-qec/quantum_codes/codetables_de.py,sha256=loBDBOK2cbDJ5moKmIx2MXg6e30XEPrEYau19bbDgac,3623
-qec/quantum_codes/five_qubit_code.py,sha256=0zrGLyIpfyKwYG7uL00yMcM5PdhQGF17_MiI2qTMhOk,2190
-qec/stabilizer_code/__init__.py,sha256=L5UMjHBlvfQBhkNlEZYSkyaHvNOcDHjc3oxYibMYHRk,63
-qec/stabilizer_code/css_code.py,sha256=JhNiBHqfwu4OgMVUsXl6yJ4L5KNW4Dn2Sf0beBdAl2s,24763
-qec/stabilizer_code/stabilizer_code.py,sha256=I5u8JKZu88ioC4E2nBJ-00xCmnL8nU6kdAvwYOfmNRk,22138
-qec/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qec/utils/binary_pauli_utils.py,sha256=BSlngYDdRICu0aVu4u_m0bvLicohORyGxfk5eRER7TQ,13245
-qec/utils/codetables_de_utils.py,sha256=S1wcVGJkkASQQ5s71QAsYBmpyE-3xTb6UsvgMfQtuiw,9469
-qec/utils/sparse_binary_utils.py,sha256=Y9xfGKzOGFiVTyhb6iF6N7-5oMY6Ah9oLrnv8HhSBHA,1965
-qec-0.2.1.dist-info/LICENSE,sha256=1b_xwNz1znYBfEaCL6pN2gNBAn8pQIjDRs_UhDp1EJI,1066
-qec-0.2.1.dist-info/METADATA,sha256=AbWaMM6fYb65-0lUw6qWuywZigdtHseO-6QAbNZK0QM,2367
-qec-0.2.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-qec-0.2.1.dist-info/top_level.txt,sha256=d8l_7pJ5u9uWdviNp0FUK-j8VPZqywkDek7qa4NDank,4
-qec-0.2.1.dist-info/RECORD,,