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

qec/quantum_codes.py

@@ -1,185 +0,0 @@
-import numpy as np
-from qec.hgp import hgp_single,hgp
-# from .hgp3d import hgp3d
-from ldpc.codes import rep_code,ring_code,hamming_code
-from .css import css_code
-from ldpc.code_util import compute_code_distance
-# from .lifted_hgp import lifted_hgp, lifted_bicycle
-
-
-'''
-[[4,2,2]] detection code
-'''
-
-class det422(css_code):
-    def __init__(self):
-        hx=np.array([[1,1,1,1]])
-        hz=np.array([[1,1,1,1]])
-        super().__init__(hx,hz)
-        self.name="det422"
-
-'''
-The Steane Code
-'''
-class steane_code(css_code):
-    def __init__(self,g=3):
-        if g<3: raise Exception("g must be equal or larger than 3")
-
-        super().__init__()
-        self.hx=hamming_code(g)
-        self.hz=hamming_code(g)
-        self.K=self.compute_dimension()
-        self.D=3
-        self.lx,self.lz=self.compute_logicals()
-        self.name=f"steane_{g}"
-
-'''
-2D topological codes
-'''
-
-class surface_code(hgp):
-    def __init__(self,n1,n2=None):
-        if n2 is None: n2=n1
-        h1=rep_code(n1)
-        h2=rep_code(n2)
-        super().__init__(h1,h2,compute_distance=True)
-        self.compute_ldpc_params()
-        self.name=f"surface_{self.D}"
-
-
-class toric_code(hgp):
-    def __init__(self,n1,n2=None):
-        if n2 is None: n2=n1
-        h1=ring_code(n1)
-        h2=ring_code(n2)
-        super().__init__(h1,h2,compute_distance=True)
-        self.compute_ldpc_params()
-        self.name=f"toric_{self.D}"
-
-
-# '''
-# 3D Topological codes
-# '''
-
-# class toric_code_3d(hgp3d):
-#     def __init__(self,distance):
-#         h=ring_code(distance)
-#         super().__init__(h)
-#         if self.K==np.nan: self.compute_dimension()
-#         self.compute_ldpc_params()
-#         self.name=f"toric3d_{distance}"
-
-# class surface_code_3d(hgp3d):
-#     def __init__(self,distance):
-#         h=rep_code(distance)
-#         super().__init__(h,h,h.T)
-#         if self.K==np.nan: self.compute_dimension()
-#         self.compute_ldpc_params()
-#         self.name=f"surface3d_{distance}"
-
-
-# '''
-# Lifted Product Codes
-# '''
-
-# def qldpc(code_name):
-
-#     print(code_name)
-
-#     if code_name is "p19b1":
-
-#         lift_parameter=63
-
-#         proto_a = np.array([
-#                 [{27}, {}, {}, {}, {}, {0}, {54}],
-#                 [{54}, {27}, {}, {}, {}, {}, {0}],
-#                 [{0}, {54}, {27}, {}, {}, {}, {}],
-#                 [{}, {0}, {54}, {27}, {}, {}, {}],
-#                 [{}, {}, {0}, {54}, {27}, {}, {}],
-#                 [{}, {}, {}, {0}, {54}, {27}, {}],
-#                 [{}, {}, {}, {}, {0}, {54}, {27}]
-#             ])
-
-#         proto_b = np.array([
-#                 [{0, 62, 57}]
-#             ])
-
-#         return lifted_hgp(lift_parameter,proto_a,proto_b)
-
-#     if code_name is "p19b2":
-
-#         lift_parameter=63
-
-#         proto_a = np.array([
-#                 [{27}, {}, {}, {0}, {18}, {27}, {0}],
-#                 [{0}, {27}, {}, {}, {0}, {18}, {27}],
-#                 [{27}, {0}, {27}, {}, {}, {0}, {18}],
-#                 [{18}, {27}, {0}, {27}, {}, {}, {0}],
-#                 [{0}, {18}, {27}, {0}, {27}, {}, {}],
-#                 [{}, {0}, {18}, {27}, {0}, {27}, {}],
-#                 [{}, {}, {0}, {18}, {27}, {0}, {27}]
-#             ])
-
-#         proto_b = np.array([
-#                 [{0, 62, 57}]
-#             ])
-
-#         return lifted_hgp(lift_parameter,proto_a,proto_b)
-
-#     if code_name is "p19b3":
-
-#         lift_parameter=127
-
-#         proto_a = np.array([
-#                 [{0}, {}, {51}, {52}, {}],
-#                 [{}, {0}, {}, {111}, {20}],
-#                 [{0}, {}, {98}, {}, {122}],
-#                 [{0}, {80}, {}, {119}, {}],
-#                 [{}, {0}, {5}, {}, {106}]
-#             ])
-
-#         proto_b = np.array([
-#                 [{0, 126, 120}]
-#             ])
-
-#         return lifted_hgp(lift_parameter,proto_a,proto_b)
-
-#     if code_name is "tanner":
-
-#         lift_parameter=31
-
-#         proto_a = np.array([
-#                 [{1},{2},{4},{8},{16}],
-#                 [{5},{10},{20},{9},{18}],
-#                 [{25},{19},{7},{14},{28}]
-#             ])
-
-#         return lifted_hgp(31,proto_a)
-
-#     if code_name is "p19a1":
-
-#         '''
-#         Bicycle code A1 from p19
-#         '''
-
-#         a=np.array([[{0,15,20,28,66}]])
-#         b=np.array([[{0,58,59,100,121}]])
-
-#         return lifted_bicycle(127,a,b)
-
-
-#     if code_name is "p19a2":
-
-#         '''
-#         Bicycle code A1 from p19
-#         '''
-
-#         a=np.array([[{0,1,14,16,22}]])
-#         b=np.array([[{0,3,13,20,42}]])
-
-#         return lifted_bicycle(63,a,b)
-
-
-    
- 
-

qec/stab.py

@@ -1,119 +0,0 @@
-import numpy as np
-from ldpc import mod2
-from tqdm import tqdm
-
-def gf2_to_gf4(bin):
-    n=int(len(bin)/2)
-    gf4=np.zeros(n).astype(int)
-    for i in range(n):
-        if bin[i]==1 and bin[i+n]==0:
-            gf4[i]=1
-        elif bin[i]==0 and bin[i+n]==1:
-            gf4[i]=3
-        elif bin[i]==1 and bin[i+n]==1:
-            gf4[i]=2
-        else:
-            gf4[i]=0
-    return gf4
-
-
-class stab_code():
-
-    def __init__(self,hx=None,hz=None):
-  
-        if hz is None or hz is None:
-            self.hx=np.array([[]])
-            self.hz = np.array([[]])
-            self.N=np.nan
-            self.K=np.nan
-            self.lx=np.array([[]])
-            self.lz=np.array([[]])
-            self.D=np.nan
-
-        else:
-            self.hx=hx
-            self.hz=hz
-            self.init_code()
-
-        self.h=np.hstack([self.hx,self.hz])
-        self.l=np.hstack([self.lx,self.lz])
-
-    def init_code(self):
-
-        self.h=np.hstack([self.hx,self.hz])
-        self.N=self.hx.shape[1]
-        self.K=self.N-mod2.rank(self.h)
-        self.compute_logical_operators()
-        self.D=np.nan
-
-    def compute_logical_operators(self):
-        #compute logical operators
-        #Kernel H
-
-        ker_H=mod2.nullspace(np.hstack([self.hz,self.hx]))
-        image_HT=mod2.row_basis(np.hstack([self.hx,self.hz]))
-
-        log_stack=np.vstack([image_HT,ker_H])
-        pivots=mod2.row_echelon(log_stack.T)[3]
-        log_op_indices=[i for i in range(image_HT.shape[0],log_stack.shape[0]) if i in pivots]
-        self.l=log_stack[log_op_indices]
-        self.lx =self.l[:,0:self.N]
-        self.lz=self.l[:,self.N:2*self.N]
-
-        self.K=int(self.l.shape[0]/2)
-
-    def compute_code_distance(self,return_logicals=False):
-
-        if self.N>10:
-            print("Warning: computing a code distance of codes with N>10 will take a long time.")
-
-        re,r,_,_=mod2.row_echelon(self.h)
-        stab_basis=re[0:r]
-        logical_stack=np.vstack([stab_basis,self.l])
-        all_logicals=mod2.row_span(logical_stack)
-        # np.argmin(np.sum(all_logicals,axis=1))
-        
-        d_min=self.N
-        min_indices=[]
-        min_logicals=[]
-        for i in tqdm(range(len(all_logicals))):
-            logical=all_logicals[i]
-            logical=gf2_to_gf4(logical)
-            temp=np.count_nonzero(logical)
-            if temp<d_min:
-                d_min=temp
-                min_indices=[i]
-                min_logicals=[logical]
-            elif temp==d_min:
-                min_indices.append(i)
-                min_logicals.append(logical)
-        
-        # d_min=np.min( np.sum(all_logicals,axis=1) )
-        self.D=d_min
-
-        # print(all_logicals)
-
-        if return_logicals:
-            return np.array(min_logicals)
-
-        return d_min
-
-    def test(self):
-        #check the logical operators are in the kernel of the pcm        
-        assert ((self.hx@self.lz.T %2 + self.hz@self.lx.T %2)%2).any()==0
-        assert mod2.rank((self.lx@self.lz.T%2 + self.lz@self.lx.T%2) %2)==self.l.shape[0]
-
-        self.compute_logical_operators()
-
-        #check commutativity relation (non CSS code)
-        assert (( (self.hz@self.hx.T %2) + (self.hx@self.hz.T %2) ) %2 ).any() == 0
-    
-        # #check the logical operators valid
-        assert ((self.hx@self.lz.T %2 + self.hz@self.lx.T %2)%2).any()==0
-        assert mod2.rank((self.lx@self.lz.T%2 + self.lz@self.lx.T%2) %2)==self.l.shape[0]
-
-    @property
-    def code_params(self):
-        return f"[[{self.N},{self.K},{self.D}]]"
-
-    

qec/xzzx_codes.py

@@ -1,333 +0,0 @@
-from ldpc.mod2 import nullspace
-import numpy as np
-from ldpc.codes import rep_code,ring_code
-from ldpc.code_util import get_code_parameters
-from qec.css import css_code
-from qec.stab import stab_code
-from qec.hgp import hgp
-from qec.protograph import protograph_transpose,protograph_to_qc_code
-from qec.lifted_hgp import lifted_hgp
-
-def gf2_to_gf4(bin):
-    n=int(len(bin)/2)
-    gf4=np.zeros(n).astype(int)
-    for i in range(n):
-        if bin[i]==1 and bin[i+n]==0:
-            gf4[i]=1
-        elif bin[i]==0 and bin[i+n]==1:
-            gf4[i]=3
-        elif bin[i]==1 and bin[i+n]==1:
-            gf4[i]=2
-
-    return gf4
-
-def hadamard_rotate(css_code,sector1_length):
-
-    hx_css=css_code.hx
-    hz_css=css_code.hz
-
-    mx,n=hx_css.shape
-    mz,nz=hz_css.shape
-
-    assert n==nz
-
-    hx=np.zeros((mx+mz,n)).astype(int)
-    hz=np.zeros((mx+mz,n)).astype(int)
-
-    hx[mz:,:sector1_length]=hx_css[:,:sector1_length]
-    hx[:mz,sector1_length:]=hz_css[:,sector1_length:]
-
-    hz[:mz,:sector1_length]=hz_css[:,:sector1_length]
-    hz[mz:,sector1_length:]=hx_css[:,sector1_length:]
-
-    return stab_code(hx,hz)
-
-class xzzx_surface_code(stab_code):
-
-    def __init__(self,nx,nz=None):
-
-        if nz is None:
-            nz=nx
-
-        h1=rep_code(nx)
-        h2=rep_code(nz)
-
-        css_sc=hgp(h1,h2)
-        xzzx_sc=hadamard_rotate(css_sc,css_sc.hx1.shape[1])
-
-        self.__dict__=xzzx_sc.__dict__.copy()
-
-        self.m1,self.n1=h1.shape
-        self.m2,self.n2=h2.shape
-
-        self.twist_boundaries()
-
-    def twist_boundaries(self):
-
-        for i in range(self.m1):
-
-            self.hz[self.m2*self.n1+i*self.n2, i*self.n2+self.n2-1]=1
-            self.hz[self.m2*self.n1+i*self.n2+(self.n2-1), (i+1)*self.n2]=1
-            
-        for i in range(self.m2):
-            self.hx[i, self.n2*(self.n1-1) +i +1]=1
-            self.hx[self.m2*(self.n1-1) +i, i]=1
-
-        self.compute_logical_operators()
-        self.h=np.hstack([self.hx,self.hz])
-        self.l=np.hstack([self.lx,self.lz])
-
-class xzzx_toric_code_old(stab_code):
-
-    def __init__(self,nx,nz=None):
-
-        if nz is None:
-            nz=nx
-
-        h1=ring_code(nx)
-        h2=ring_code(nz)
-
-        css_tc=hgp(h1,h2)
-        xzzx_tc=hadamard_rotate(css_tc,css_tc.hx1.shape[1])
-
-        self.__dict__=xzzx_tc.__dict__.copy()
-
-        self.m1,self.n1=h1.shape
-        self.m2,self.n2=h2.shape
-
-        self.twist_boundaries()
-
-    def twist_boundaries(self):
-
-        hz1_n=self.n1*self.n2
-
-        self.hz[:hz1_n,:hz1_n]=ring_code(hz1_n)
-        self.hz[hz1_n:,hz1_n:]=ring_code(hz1_n).T
-
-        self.compute_logical_operators()
-        self.h=np.hstack([self.hx,self.hz])
-        self.l=np.hstack([self.lx,self.lz])
-
-    def to_css(self):
-
-        hz1_n=self.n1*self.n2
-        hz1=self.hz[:hz1_n,:hz1_n]
-        hx2=self.hz[hz1_n:,hz1_n:]
-
-        hx1=self.hx[hz1_n:,:hz1_n]
-        hz2=self.hx[:hz1_n,hz1_n:]
-
-        hx=np.hstack([hx1,hx2])
-        hz=np.hstack([hz1,hz2])
-
-        qcode_css=css_code(hx,hz)
-        qcode_css.hx1=hx1
-        qcode_css.hx2=hx2
-        qcode_css.hz1=hz1
-        qcode_css.hz2=hz2
-
-        return qcode_css
-
-
-class rotated_xzzx_code(stab_code):
-
-    def __init__(self,nx,nz):
-
-        n=nx*nz
-        m=(nx-1)*(nz-1) + nz//2 +(nz-1)//2 +nx//2 +(nx-1)//2
-
-
-        hx=np.zeros((m,n)).astype(int)
-        hz=np.zeros((m,n)).astype(int)
-
-        # print(hx)
-
-        for j in range(nx-1):
-            
-            #main grid
-            for k in range(nz-1):
-                temp=j*(nz-1)
-                hx[temp+k,j*(nz)+k]=1
-                hx[temp+k,j*(nz)+k+nz+1]=1
-                
-                hz[temp+k,j*(nz)+k+1]=1
-                hz[temp+k,j*(nz)+k+nz]=1
-
-        temp=(nx-1)*(nz-1)
-        count=0
-        for j in range(0,nz-1,2):
-            
-            #the extra checks top
-            hz[temp+count,j]=1
-            hz[temp+count,(n-1)-(nz-1)+1+j]=1
-
-            hx[temp+count,j+1]=1
-            hx[temp+count,(n-1)-(nz-1)+j]=1
-
-            count+=1
-        
-        temp=(nx-1)*(nz-1) + nz//2
-        count=0
-        for j in range(1,nz-1,2):
-            #extra checks bottom
-
-            hx[temp+count,j+1]=1
-            hx[temp+count,(n-1)-(nz-1)+j]=1
-
-            hz[temp+count,j]=1
-            hz[temp+count,(n-1)-(nz-1)+1+j]=1
-
-            count+=1
-        
-        temp=(nx-1)*(nz-1) + nz//2 +(nz-1)//2
-        count=0
-        for j in range(0,nx-1,2):
-
-            #extra checks #right
-
-            hz[temp+count,(j+1)*nz+nz-1]=1        
-            hz[temp+count,j*nz]=1
-            
-            
-            hx[temp+count,(j+1)*nz] =1
-            hx[temp+count,j*nz+nz-1] =1
-
-            count+=1
-
-
-        temp=(nx-1)*(nz-1) + nz//2 +(nz-1)//2 +(nx)//2
-        count=0
-        for j in range(1,nx-1,2):
-
-            #extra checks #left
-
-            hz[temp+count,(j+1)*nz+nz-1]=1        
-            hz[temp+count,j*nz]=1
-            
-            hx[temp+count,(j+1)*nz] =1
-            hx[temp+count,j*nz+nz-1] =1
-
-            count+=1
-
-
-        super().__init__(hx,hz)
-        self.nx=nx
-        self.nz=nz
-
-    def to_css(self):
-
-        if not self.nx%2==0 and not self.nz%2:
-            raise Exception(f"Attribute error: the XZZX code must have even lattice parameters to be converted to a CSS code. Not nx={self.nx} and nz={self.nz}.") 
-
-        sector1_qubits=np.nonzero(nullspace(self.hx)[0])[0]
-        sector2_qubits=np.nonzero(nullspace(self.hx)[1])[0]
-
-        qubit_ordering=np.concatenate([sector1_qubits,sector2_qubits])
-
-        print(qubit_ordering)
-
-        self.hx=self.hx[:,qubit_ordering]
-        self.hz=self.hz[:,qubit_ordering]
-
-     
-        temp1=np.copy(self.hx[:,self.N//2:])
-        temp2=np.copy(self.hz[:,self.N//2:])
-
-        self.hx[:,self.N//2:]=temp2
-        self.hz[:,self.N//2:]=temp1
-
-        delete_zero_rows = lambda mat: np.delete(mat,np.where(~mat.any(axis=1))[0], axis=0)
-        self.hx=delete_zero_rows(self.hx)
-        self.hz=delete_zero_rows(self.hz)
-
-        print(self.hx)
-        print(self.hz)
-
-        # print(self.hx)
-        # print(self.hz)
-
-        return css_code(self.hx,self.hz)
-
-class xzzx_toric_code(stab_code):
-    def __init__(self,nx,nz):
-
-        self.nx=nx
-        self.nz=nz
-        self.N=int(2*self.nx*self.nz)
-        
-        self.proto_1=np.array([[{0,1}]])
-        self.proto_2=np.array([[{0,nz}]])
-
-        self.css=lifted_hgp(self.N//2,self.proto_2,self.proto_1)
-
-        lp=hadamard_rotate(self.css,self.N//2)
-
-        # for key in lp.__dict__.keys():
-        #     if key not in self.__dict__.keys():
-        #         self.__dict__[key]=lp.__dict__[key]
-
-        super().__init__(lp.hx,lp.hz)
-
-    def to_css(self):
-        return self.css
-
-
-class xzzx_sc(stab_code):
-    def __init__(self,nx,nz):        
-
-        def Pfr(n,shift):
-            base=np.hstack([np.identity(n-1),np.zeros((n-1,1))]).astype(int)
-            perm=np.arange(n)
-            perm=(perm-shift)%(n)
-            return base[:,perm]
-
-        N=nx*nz+(nx-1)*(nz-1)
-        hz=Pfr(N,0)+Pfr(N,1)
-        hx=Pfr(N,nz)+Pfr(N,(1-nz))
-        super().__init__(hx,hz)
-
-
-def main():
-
-    print("Rotated XZZX codes")
-    tsc=rotated_xzzx_code(4,3)
-    tsc.test()
-    # tsc=tsc.to_css()
-    tsc.test()
-    tsc.compute_code_distance()
-    print(f"[[{tsc.N},{tsc.K},{tsc.D}]]")
-    print(get_code_parameters(tsc.hx))
-    print(get_code_parameters(tsc.hz))
-    print()
-
-
-    # print("Toric code lifted")
-    # #xzzx toric from lifted product
-    # tsc=xzzx_toric_code(2,2)
-    # logicals=tsc.compute_code_distance(return_logicals=True)
-    # tsc.test()
-    # print(tsc.code_params)
-    # print(logicals)
-    # print()
-
-
-    print("XZZX Surface code constructed")
-    #xzzx toric from lifted product
-    sc=xzzx_sc(3,2)
-    logicals=sc.compute_code_distance(return_logicals=True)
-    sc.test()
-    print(sc.code_params)
-    print(get_code_parameters(sc.hx))
-    print(get_code_parameters(sc.hz))
-    print(logicals)
-    # print(sc.hz)
-    # print(sc.hx)
-
-    # assert np.array_equal(sc.hz,sc2.hz)
-
-    # print(logicals)
-    print()
-
-
-if __name__ == "__main__":
-    main()

qec-0.0.11.dist-info/METADATA

@@ -1,18 +0,0 @@
-Metadata-Version: 2.1
-Name: qec
-Version: 0.0.11
-Summary: UNKNOWN
-Home-page: https://www.roffe.eu
-Author: Joschka Roffe
-Author-email: joschka@roffe.eu
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Development Status :: 1 - Planning
-Requires-Python: >=3.6
-Requires-Dist: numpy
-Requires-Dist: ldpc
-Requires-Dist: tqdm
-
-Python Tools for Quantum Error Correction
-
-

qec-0.0.11.dist-info/RECORD

@@ -1,11 +0,0 @@
-qec/css.py,sha256=DnVxU6HNySoly8_rlgqPATSw2_yWiMvoTHRpswc5Sb8,5211
-qec/hgp.py,sha256=wf_F_RdnAdFny8aA0E9_4201j6jvallfQnU5jAfBPJY,2085
-qec/lifted_hgp.py,sha256=_uIXULX5Q3NLza5SUo7IWPkRwuZ8ah824Reitjn-6GQ,2538
-qec/protograph.py,sha256=8un7qYs0LIjm0WOs1Qr0wGaNzToIuPy3WFtY02FcPR0,3953
-qec/quantum_codes.py,sha256=JUWGJmcZocNC7pT0_jTGOaIIx4VdV9ig1yhLA9aZMy0,4550
-qec/stab.py,sha256=04EQDOrmKorgGTCn9jFZfc9JkUcNjJcdmiOOJVMcCaM,3508
-qec/xzzx_codes.py,sha256=ilUH5xbxYZ9vb4hCAW6_erNd34cT7gfsaoQX7ZFvtVo,8050
-qec-0.0.11.dist-info/METADATA,sha256=xO4tBRgbPYjDvTmai9HcWvqLI1gJ_m8a5j6BqOaaIE4,361
-qec-0.0.11.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
-qec-0.0.11.dist-info/top_level.txt,sha256=d8l_7pJ5u9uWdviNp0FUK-j8VPZqywkDek7qa4NDank,4
-qec-0.0.11.dist-info/RECORD,,