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

qec/utils/sparse_binary_utils.py

@@ -0,0 +1,64 @@
+import numpy as np
+import scipy.sparse
+
+
+def convert_to_binary_scipy_sparse(
+    matrix: np.typing.ArrayLike,
+) -> scipy.sparse.csr_matrix:
+    """
+    Convert and validate a matrix as a sparse binary matrix in CSR format.
+
+    This function checks whether all elements of the input matrix are binary (0 or 1).
+    If the input is not already a sparse matrix, it converts it to a CSR (Compressed Sparse Row) matrix.
+
+    Parameters
+    ----------
+    matrix : array-like
+        Input matrix of shape (M, N). Can be a dense array-like or any SciPy sparse matrix format.
+
+    Returns
+    -------
+    scipy.sparse.csr_matrix
+        Binary sparse matrix in CSR format, of shape (M, N).
+
+    Raises
+    ------
+    ValueError
+        If the input matrix has elements outside {0, 1}.
+    TypeError
+        If the input is not array-like.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipy.sparse import csr_matrix
+    >>> from qec.utils.sparse_binary_utils import convert_to_binary_scipy_sparse
+    >>> mat = np.array([[0, 1], [1, 0]])
+    >>> convert_to_binary_scipy_sparse(mat).toarray()
+    array([[0, 1],
+           [1, 0]])
+
+    >>> mat = csr_matrix([[0, 1], [1, 0]])
+    >>> convert_to_binary_scipy_sparse(mat).toarray()
+    array([[0, 1],
+           [1, 0]])
+
+    >>> mat = np.array([[0, 2], [1, 0]])
+    >>> convert_to_binary_scipy_sparse(mat)
+    Traceback (most recent call last):
+        ...
+    ValueError: All elements of the input matrix must be binary.
+    """
+    if not isinstance(matrix, (np.ndarray, list, scipy.sparse.spmatrix)):
+        raise TypeError("Input must be array-like.")
+
+    if not isinstance(matrix, scipy.sparse.spmatrix):
+        matrix = scipy.sparse.csr_matrix(matrix, dtype=np.uint8)
+
+    if not matrix.dtype == np.uint8:
+        matrix = matrix.astype(np.uint8)
+
+    if not np.all(np.isin(matrix.data, [0, 1])):
+        raise ValueError("All elements of the input matrix must be binary.")
+
+    return matrix

qec-0.2.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+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.

qec-0.2.1.dist-info/METADATA

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,16 @@
+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,,

{qec-0.0.11.dist-info → qec-0.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

qec/css.py

@@ -1,164 +0,0 @@
-import numpy as np
-from ldpc import mod2
-from ldpc.code_util import compute_code_distance
-
-class css_code():
-
-    def __init__(self,hx=np.array([[]]),hz=np.array([[]]), name="<Unnamed CSS code>"):
-
-        self.hx=hx #hx pcm
-        self.hz=hz #hz pcm
-
-        self.lx=np.array([[]]) #x logicals
-        self.lz=np.array([[]]) #z logicals
-
-        self.N=np.nan #block length
-        self.K=np.nan #code dimension
-        self.D=np.nan #code distance
-        self.L=np.nan #max column weight
-        self.Q=np.nan #max row weight
-
-        _,nx=self.hx.shape
-        _,nz=self.hz.shape
-        try:
-            assert nx==nz
-        except AssertionError:
-            raise Exception("Error: hx and hz matrices must have equal numbers of columns!")
-
-        if nx!=0:
-            self.compute_dimension()
-            self.compute_ldpc_params()
-            self.compute_logicals()
-        
-        self.name=name
-
-    def compute_dimension(self):
-
-        self.N=self.hx.shape[1]
-        assert self.N == self.hz.shape[1], "Code block length (N) inconsistent!"
-
-        self.K=self.N-mod2.rank(self.hx)-mod2.rank(self.hz)
-        return self.K
-
-    def compute_ldpc_params(self):
-
-        #column weights
-        hx_l=np.max(np.sum(self.hx,axis=0))
-        hz_l=np.max(np.sum(self.hz,axis=0))
-        self.L=np.max([hx_l,hz_l]).astype(int)
-
-        #row weights
-        hx_q=np.max(np.sum(self.hx,axis=1))
-        hz_q=np.max(np.sum(self.hz,axis=1))
-        self.Q=np.max([hx_q,hz_q]).astype(int)
-
-
-    def compute_logicals(self):
-
-        def compute_lz(hx,hz):
-            #lz logical operators
-            #lz\in ker{hx} AND \notin Im(Hz.T)
-
-            ker_hx=mod2.nullspace(hx) #compute the kernel basis of hx
-            im_hzT=mod2.row_basis(hz) #compute the image basis of hz.T
-
-            #in the below we row reduce to find vectors in kx that are not in the image of hz.T.
-            log_stack=np.vstack([im_hzT,ker_hx])
-            pivots=mod2.row_echelon(log_stack.T)[3]
-            log_op_indices=[i for i in range(im_hzT.shape[0],log_stack.shape[0]) if i in pivots]
-            log_ops=log_stack[log_op_indices]
-            return log_ops
-
-        if self.K==np.nan: self.compute_dimension()
-        self.lx=compute_lz(self.hz,self.hx)
-        self.lz=compute_lz(self.hx,self.hz)
-
-        return self.lx,self.lz
-
-    @property
-    def code_params(self):
-        try: self.N
-        except AttributeError: self.N=np.nan
-        try: self.K
-        except AttributeError: self.K=np.nan
-        try: self.D
-        except AttributeError: self.D=np.nan
-        try: self.L
-        except AttributeError: self.L=np.nan
-        try: self.Q
-        except AttributeError: self.Q=np.nan
-
-        return f"({self.L},{self.Q})-[[{self.N},{self.K},{self.D}]]"
-
-    def compute_code_distance(self):
-
-        dx=compute_code_distance(self.hx)
-        dz=compute_code_distance(self.hz)
-        dxt=compute_code_distance(self.hx.T)
-        dzt=compute_code_distance(self.hz.T)
-        self.D=np.min([dx,dz,dxt,dzt]).astype(int)
-
-    def test(self,show_tests=True):
-        valid_code=True
-
-        if self.K==np.nan: self.compute_dimension()
-        self.compute_ldpc_params()
-
-        code_label=f"{self.code_params}"
-
-        if show_tests: print(f"{self.name}, {code_label}")
-
-        try:
-            assert self.N==self.hz.shape[1]==self.lz.shape[1]==self.lx.shape[1]
-            assert self.K==self.lz.shape[0]==self.lx.shape[0]
-            if show_tests: print(" -Block dimensions: Pass")
-        except AssertionError:
-            valid_code=False
-            print(" -Block dimensions incorrect")
-
-        try:
-            assert not (self.hz@self.hx.T %2).any()
-            if show_tests: print(" -PCMs commute hz@hx.T==0: Pass")
-        except AssertionError:
-            valid_code=False
-            print(" -PCMs commute hz@hx.T==0: Fail")
-
-        try:
-            assert not (self.hx@self.hz.T %2).any()
-            if show_tests: print(" -PCMs commute hx@hz.T==0: Pass")
-        except AssertionError:
-            valid_code=False
-            print(" -PCMs commute hx@hz.T==0: Fail")
-
-        # if show_tests and valid_code: print("\t-PCMs commute hx@hz.T == hz@hx.T ==0: Pass")
-
-        try:
-            assert not (self.hz@self.lx.T %2).any()
-        except AssertionError:
-            valid_code=False
-            print(" -lx \in ker{hz} AND lz \in ker{hx}: Fail")
-
-
-        try:
-            assert not (self.hx@self.lz.T %2).any()
-            if show_tests: print(" -lx \in ker{hz} AND lz \in ker{hx}: Pass")
-        except AssertionError:
-            valid_code=False
-            print(" -lx \in ker{hz} AND lz \in ker{hx}: Fail")
-
-
-        # if show_tests and valid_code: print("\t-lx \in ker{hz} AND lz \in ker{hx}: Pass")
-
-        try:
-            assert mod2.rank(self.lx@self.lz.T %2)==self.K
-            if show_tests: print(" -lx and lz anticommute: Pass")
-        except AssertionError:
-            valid_code=False
-            print(" -lx and lz anitcommute: Fail")
-
-        # if show_tests and valid_code: print("\t- lx and lz anitcommute: Pass")
-
-        if show_tests and valid_code: print(f" -{self.name} is a valid CSS code w/ params {code_label}")
-
-        return valid_code
-

qec/hgp.py

@@ -1,75 +0,0 @@
-import numpy as np
-from ldpc.mod2 import rank
-from ldpc.code_util import compute_code_distance
-from qec.css import css_code
-
-class hgp(css_code):
-    def __init__(self,h1,h2=None,compute_distance=False):
-
-        super().__init__()
-        #default to symmetric HGP if
-
-        if type(h2)!=np.ndarray: h2=np.copy(h1)
-
-        self.h1=h1
-        self.h2=h2
-
-        #setting up base codes
-        self.m1,self.n1=np.shape(h1)
-        i_m1=np.identity(self.m1,dtype=int)
-        i_n1=np.identity(self.n1,dtype=int)
-        self.r1=rank(self.h1)
-        self.k1=self.n1-self.r1
-        self.k1t=self.m1-self.r1
-
-        self.m2,self.n2=np.shape(h2)
-        i_m2=np.identity(self.m2,dtype=int)
-        i_n2=np.identity(self.n2,dtype=int)
-        self.r2=rank(self.h2)
-        self.k2=self.n2-self.r2
-        self.k2t=self.m2-self.r2
-
-        #hgp code params
-        self.N=self.n1*self.n2 + self.m1*self.m2
-        self.K=self.k1*self.k2+self.k1t*self.k2t 
-        self.D=None
-
-        #construct hx and hz
-        self.hx1=np.kron(self.h1,i_n2)
-        self.hx2=np.kron(i_m1,self.h2.T)
-        self.hx = np.hstack([   self.hx1,  self.hx2 ])
-
-        self.hz1=np.kron(i_n1,self.h2)
-        self.hz2=np.kron(self.h1.T,i_m2)
-        self.hz = np.hstack([   self.hz1,  self.hz2 ])
-
-        #construct the hgp logicals
-        self.compute_logicals()
-
-        ##compute code distance if the base codes are small enough for it to be tractable
-        if(compute_distance==True):
-            self.d1=compute_code_distance(self.h1)
-            self.d1t=compute_code_distance(self.h1.T)
-            self.d2=compute_code_distance(self.h2)
-            self.d2t=compute_code_distance(self.h2.T)
-            self.D=np.min([self.d1,self.d1t,self.d2,self.d2t]).astype(int)
-        else: self.D=None
-
-    def print_code_parameters(self):
-
-        if self.D==None: print( f"[[{self.N},{self.K},d]]")
-        else: print( f"[[{self.N},{self.K},{self.D}]]")
-
-
-class hgp_single(hgp):
-    def __init__(self,h1,compute_distance=False):
-        super().__init__(h1,compute_distance=compute_distance)
-
-
-
-
-
-
-
-
-

qec/lifted_hgp.py

@@ -1,79 +0,0 @@
-import numpy as np
-from qec.protograph import protograph_to_qc_code,protograph_transpose,kron_mat_proto,kron_proto_mat
-from qec.css import css_code
-
-def I(n):
-    '''
-    Returns an identity matrix of size n
-    '''
-    return np.identity(n).astype(int)
-
-class lifted_hgp(css_code):
-
-    def __init__(self,lift_parameter,a,b=None):
-
-        '''
-        Generates the lifted hypergraph product of the protographs a and b
-        '''
-        self.a=a
-
-        self.a_m,self.a_n=self.a.shape
-        self.a_t=protograph_transpose(self.a)
-
-        if b is None:
-            self.b=np.copy(self.a)
-        else:
-            self.b=b
-        
-        self.b_t=protograph_transpose(self.b)
-        self.b_m,self.b_n=self.b.shape
-
-        self.hx1_proto=kron_proto_mat(self.a,I(self.b_n))
-        self.hx2_proto=kron_mat_proto(I(self.a_m),self.b_t)
-        self.hx_proto=np.hstack([self.hx1_proto,self.hx2_proto])
-
-        self.hx1 = protograph_to_qc_code(lift_parameter,self.hx1_proto)
-        self.hx2 = protograph_to_qc_code(lift_parameter,self.hx2_proto)
-        self.hx=np.hstack([self.hx1,self.hx2]).astype(int)
-
-        self.hz1_proto=kron_mat_proto(I(self.a_n),self.b)
-        self.hz2_proto=kron_proto_mat(self.a_t,I(self.b_m))
-        self.hz_proto=np.hstack([self.hz1_proto,self.hz2_proto])
-
-        self.hz1=protograph_to_qc_code(lift_parameter,self.hz1_proto)
-        self.hz2= protograph_to_qc_code(lift_parameter,self.hz2_proto)
-        self.hz=np.hstack( [self.hz1, self.hz2] ).astype(int)
-
-        super().__init__(self.hx,self.hz)
-
-class lifted_bicycle(css_code):
-
-    def __init__(self,lift_parameter,a,b=None):
-
-        '''
-        Generates the lifted hypergraph product of the protographs a and b
-        '''
-
-        a_m,a_n=a.shape
-        a_T=protograph_transpose(a)
-
-        if b is None:
-            b=np.copy(a)
-        
-        b_T=protograph_transpose(b)
-        b_m,b_n=b.shape
-
-        self.hx1 = protograph_to_qc_code(lift_parameter, a)
-        self.hx2 = protograph_to_qc_code(lift_parameter, b)
-        self.hx=np.hstack([self.hx1,self.hx2]).astype(int)
-
-        self.hz1=protograph_to_qc_code(lift_parameter, protograph_transpose(b))
-        self.hz2= protograph_to_qc_code(lift_parameter, protograph_transpose(a))
-        self.hz=np.hstack( [self.hz1, self.hz2] ).astype(int)
-
-        super().__init__(self.hx,self.hz)
-
-        self.lx1=self.lx[:,0:self.hx1.shape[1]]
-        self.lx2=self.lx[:,self.hx1.shape[1]:]
-        self.lz1=self.lz[:,0:self.hz1.shape[1]]
-        self.lz2=self.lz[:,self.hz1.shape[1]:]

qec/protograph.py

@@ -1,150 +0,0 @@
-import numpy as np
-
-def permutation_matrix(n,shift):
-    '''
-    Outputs a size-n permutation matrix.
-
-
-    Inputs:
-        n: matrix dimension
-        shift: the shift parameter
-    Returns:
-        mat: nxn matrix shifted by `shift' columns to the left
-    '''
-    return np.roll(np.identity(n),1*shift,axis=1).astype(int)
-
-def polynomial_to_circulant_matrix(n,non_zero_coefficients):
-    '''
-    Converts a polynomial into a circulant matrix
-
-    Inputs:
-        n: int, matrix dimension
-        non_zero_coefficieents: list of ints (can be np.ndarray), list of the non-zero coefficients of the polynomial
-    Returns:
-        mat: an nxn circulant matrix corresponding to the inputted polynomial
-    '''
-    mat=np.zeros((n,n)).astype(int)
-    for shift in non_zero_coefficients:
-        mat+=permutation_matrix(n,shift)
-    return mat % 2
-
-# def polynomial_transpose(lift_parameter, polynomial):
-
-#     polynomial_transpose=set()
-#     for coefficient in polynomial:
-#         polynomial_transpose.add((lift_parameter-coefficient)%lift_parameter)
-    
-#     return polynomial_transpose
-
-def polynomial_transpose(polynomial):
-    polynomial_transpose=set()
-    for coefficient in polynomial:
-        polynomial_transpose.add(-1*coefficient)    
-    return polynomial_transpose
-
-def empty_protograph(shape):
-    '''
-    Returns an empty protograh
-    '''
-    m,n=shape
-    row=np.array([{}]*n)
-    return np.vstack([row]*m)
-
-def kron_mat_proto(mat,proto):
-    '''
-    Kronecker product of a numpy matrix and a protograph
-    '''
-    mat_m,mat_n=mat.shape
-    zero_proto=empty_protograph(proto.shape)
-
-    # print(zero_proto)
-
-    out=[]
-    for i in range(mat_m):
-        row=[]
-        for j in range(mat_n):
-            if mat[i,j]:
-                row.append(proto)
-            else:
-                row.append(zero_proto)
-        out.append(np.hstack(row))
-
-    return np.vstack(out)
-
-def kron_proto_mat(proto,mat):
-
-    '''
-    Tensor product of a protograph and numpy matrix
-    '''
-
-    proto_m,proto_n=proto.shape
-    mat_m,mat_n=mat.shape
-    zero_proto=empty_protograph(mat.shape)
-
-    out=[]
-    for i in range(proto_m):
-        row=[]
-        for j in range(proto_n):
-            if len(proto[i,j])==0:
-                row.append(zero_proto)
-            else:
-                temp=np.copy(zero_proto)
-                for k in range(temp.shape[0]):
-                    for l in range(temp.shape[1]):
-                        if mat[k,l]==1:
-                            temp[k,l]=proto[i,j]
-                        else:
-                            temp[k,l]={}
-                
-                row.append(temp)
-
-        out.append(np.hstack(row))
-    
-    return np.vstack(out)
-
-def protograph_transpose(protograph):
-    '''
-    Returns the transpose of a protograph.
-
-    Input:
-        lift_paramter: int, the lift parameter for the protograph
-        protograph: np.ndarray, the protograph
-    Return:
-        protograph_transpose: np.ndarray, the transpose of the inputted protograph for the given lift parameter
-    '''
-
-    m,n=protograph.shape
-    protograph_transpose=empty_protograph((n,m))
-
-    for i in range(m):
-        for j in range(n):
-            protograph_transpose[j,i]=polynomial_transpose(protograph[i,j])
-            
-    return protograph_transpose
-
-
-def protograph_to_qc_code(n,protograph):
-    
-    '''
-    Generates the parity check matrix of a quasicyclic code from a matrix of polynomials.
-
-    Inputs:
-        n: int, lift parameter
-        protograph: np.ndarray, polynomial matrix
-    Returns:
-        qc_matrix: np.ndarray, quasi-cyclic code corresponding to the inputted polynomial matrix
-    '''
-    
-    qc_matrix=[]
-    
-    for row in protograph:
-        qc_row=[]
-        for polynomial in row:
-            qc_row.append( polynomial_to_circulant_matrix(n,polynomial) )
-        qc_row=np.hstack(qc_row)
-        qc_matrix.append(qc_row)
-        
-    qc_matrix=np.vstack(qc_matrix)
-    return qc_matrix
-
-