qec 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

qec/code_constructions/__init__.py

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

qec/code_constructions/hgp_code.py

@@ -1,12 +1,13 @@
 import numpy as np
-import scipy 
+import scipy
 from typing import Union, Tuple
-import ldpc.mod2 
+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.
@@ -59,15 +60,19 @@ class HypergraphProductCode(CSSCode):
 
     def __init__(
         self,
-        seed_matrix_1 : Union[np.ndarray, scipy.sparse.spmatrix],
-        seed_matrix_2 : Union[np.ndarray, scipy.sparse.spmatrix],
-        name : str = None
+        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.")
+        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)
@@ -90,31 +95,30 @@ class HypergraphProductCode(CSSCode):
         # --------------------------------------------------------------------------
 
         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. 
+        int
+            The distance of the code.
 
         Notes
         -----
-        The distance of a HGP code is given as: 
-        
+        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:
@@ -124,7 +128,7 @@ class HypergraphProductCode(CSSCode):
             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)
@@ -141,70 +145,86 @@ class HypergraphProductCode(CSSCode):
         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 
-        
+        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. 
+            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_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_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
+        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_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
+        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_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
+        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)
+            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]:
+    def compute_logical_basis(
+        self,
+    ) -> Tuple[scipy.sparse.spmatrix, scipy.sparse.spmatrix]:
         """
         Compute the logical operator basis for the given HGP code.
 
@@ -225,40 +245,64 @@ class HypergraphProductCode(CSSCode):
         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)])
+        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])
+        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)])
+        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__? 
-        #---------------------------------------------------------------- 
+        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. 
+        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}]]"
-
 
+        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-0.2.5.dist-info → qec-0.2.7.dist-info}/METADATA

@@ -1,9 +1,8 @@
 Metadata-Version: 2.2
 Name: qec
-Version: 0.2.5
+Version: 0.2.7
 Summary: Python Tools for Quantum Error Correction
-Author: Tamas Noszko, Liam Veeder-Sweeney
-Author-email: Joschka Roffe <joschka@roffe.eu>
+Author-email: Joschka Roffe <joschka@roffe.eu>, Tamas Noszko <T.K.Noszko@sms.ed.ac.uk>, Liam Veeder-Sweeney <L.D.Veeder-Sweeney@sms.ed.ac.uk>
 License: MIT License
         
         Copyright (c) 2023 qec.Codes

{qec-0.2.5.dist-info → qec-0.2.7.dist-info}/RECORD

@@ -1,7 +1,7 @@
 qec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qec/code_constructions/__init__.py,sha256=MWyNUCS5mYcDzjGr_nbr2-ifkJigRJIzsw7sQIQXDfM,119
+qec/code_constructions/__init__.py,sha256=AyEYcahGs_4C8nqSUhoYmZNBt1TzuzVPZjNN1FErRyQ,118
 qec/code_constructions/css_code.py,sha256=nIaC24QhQwrmWQNhmX-X4TzlkmNAYoxN0feTdWjhswo,32376
-qec/code_constructions/hgp_code.py,sha256=VAKU2lfZnDXSmAk6xFZCYT5b0hbtXpEoQUw4qHFcaEk,10419
+qec/code_constructions/hgp_code.py,sha256=r5E_tEilRRJWDXrMbNAbplf-N5Y0XS7VUoWWTEjh9BY,11098
 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
@@ -11,8 +11,8 @@ 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.5.dist-info/LICENSE,sha256=1b_xwNz1znYBfEaCL6pN2gNBAn8pQIjDRs_UhDp1EJI,1066
-qec-0.2.5.dist-info/METADATA,sha256=xK6P1cPR5OyCWe7rsFb1OO3BYL_k9kmHwW-75uAEIu8,4558
-qec-0.2.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-qec-0.2.5.dist-info/top_level.txt,sha256=d8l_7pJ5u9uWdviNp0FUK-j8VPZqywkDek7qa4NDank,4
-qec-0.2.5.dist-info/RECORD,,
+qec-0.2.7.dist-info/LICENSE,sha256=1b_xwNz1znYBfEaCL6pN2gNBAn8pQIjDRs_UhDp1EJI,1066
+qec-0.2.7.dist-info/METADATA,sha256=KJk3mjCfJkluDMXt7-jh3lhPMpd_bvX3e3KPmKurRbo,4611
+qec-0.2.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+qec-0.2.7.dist-info/top_level.txt,sha256=d8l_7pJ5u9uWdviNp0FUK-j8VPZqywkDek7qa4NDank,4
+qec-0.2.7.dist-info/RECORD,,