codedistance 0.0.4__tar.gz → 0.0.6__tar.gz

codedistance-0.0.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Alan Webster, Abraham Jacob, Oscar Higgott
+
+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.

{codedistance-0.0.4 → codedistance-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codedistance
-Version: 0.0.4
+Version: 0.0.6
 Summary: Code and Circuit Distance Algorithms.
 License: GNUv3
 License-File: LICENSE
@@ -42,7 +42,13 @@ Distance algorithms for classical codes, quantum codes and quantum circuits
 Mark Webster, Abe Jacob and Oscar Higgott
 
 # Installation
-To install the python library, use pip install codedistance
+To install the python library, use 
+
+    pip install codedistance
+
+If you wish to make changes to the source code or run the examples from the package, you can also download the codebase from the [github page](https://github.com/m-webster/codeDistancePYPI), create a virtual environment, navigate to the local copy of the codebase and run:
+
+    pip install -e .
 
 Certain distance-finding algorithms require installation of external packages:
 
@@ -52,6 +58,8 @@ Certain distance-finding algorithms require installation of external packages:
 4. CLISATDist: requies a SAT solver binary on the system path - by default this is cashwmaxsatcoreplus which runs only on Unix systems and is available from https://maxsat-evaluations.github.io/2023
 5. qubitserfBZ and qubitserfMM: requires compiliation of the C library from https://github.com/qubitserfed/Qubitserf. By default, this results in an executable called "interface". This binary should be renamed qubitserf and be accessible on the system path
 
+To compile on a Windows machine we recommend using Cygwin with the packages listed  [here](https://www.codefull.net/2015/12/essential-cygwin-development-packages/).
+
 
 # Main Distance-Finding Functions
 The package finds distances of classical codes, CSS quantum codes, non-CSS quantum codes and quantum circuits. 
@@ -136,7 +144,7 @@ As each dataset may have many codes/circuits, the recommended way to run these i
 The distance-finding results for the data set are saved in a text file within the examples/results folder.
 For example, to find distances of the non-CSS codetables dataset using the QDistEvol function, open a terminal window, navigate/change directory to the examples folder then run the following command via a terminal:
 
-python3 runTest.py --dataset codeTables --datafile QECC_sample.txt --method QDistEvol
+    python3 runTest.py --dataset codeTables --datafile QECC_sample.txt --method QDistEvol
 
 # Parameters for Distance-Finding Methods
 Here we lay out the main parameter settings used for various distance-finding methods:

{codedistance-0.0.4 → codedistance-0.0.6}/README.md

@@ -5,7 +5,13 @@ Distance algorithms for classical codes, quantum codes and quantum circuits
 Mark Webster, Abe Jacob and Oscar Higgott
 
 # Installation
-To install the python library, use pip install codedistance
+To install the python library, use 
+
+    pip install codedistance
+
+If you wish to make changes to the source code or run the examples from the package, you can also download the codebase from the [github page](https://github.com/m-webster/codeDistancePYPI), create a virtual environment, navigate to the local copy of the codebase and run:
+
+    pip install -e .
 
 Certain distance-finding algorithms require installation of external packages:
 
@@ -15,6 +21,8 @@ Certain distance-finding algorithms require installation of external packages:
 4. CLISATDist: requies a SAT solver binary on the system path - by default this is cashwmaxsatcoreplus which runs only on Unix systems and is available from https://maxsat-evaluations.github.io/2023
 5. qubitserfBZ and qubitserfMM: requires compiliation of the C library from https://github.com/qubitserfed/Qubitserf. By default, this results in an executable called "interface". This binary should be renamed qubitserf and be accessible on the system path
 
+To compile on a Windows machine we recommend using Cygwin with the packages listed  [here](https://www.codefull.net/2015/12/essential-cygwin-development-packages/).
+
 
 # Main Distance-Finding Functions
 The package finds distances of classical codes, CSS quantum codes, non-CSS quantum codes and quantum circuits. 
@@ -99,7 +107,7 @@ As each dataset may have many codes/circuits, the recommended way to run these i
 The distance-finding results for the data set are saved in a text file within the examples/results folder.
 For example, to find distances of the non-CSS codetables dataset using the QDistEvol function, open a terminal window, navigate/change directory to the examples folder then run the following command via a terminal:
 
-python3 runTest.py --dataset codeTables --datafile QECC_sample.txt --method QDistEvol
+    python3 runTest.py --dataset codeTables --datafile QECC_sample.txt --method QDistEvol
 
 # Parameters for Distance-Finding Methods
 Here we lay out the main parameter settings used for various distance-finding methods:

{codedistance-0.0.4 → codedistance-0.0.6}/codedistance/NHow.py

@@ -450,7 +450,12 @@ def HowPivots(A,nA=0,tB=1,nC=-1,r0=0):
 # @nb.jit
 # @nb.jit(nb.types.Tuple((nb.int8[:,:],nb.int64[:]))(nb.int8[:,:],nb.int64,nb.int64,nb.int64,nb.int64))
 
-
+def indepVecs(A):
+    """Return a linearly independent subset of rows from A, preserving priority order - uses only 2 RREF calls."""
+    H, U = getHU(A, 2)
+    K = U[np.sum(H, axis=-1) == 0, :]
+    K, LI = getH(K, 2, retPivots=True)
+    return invRange(len(A), LI)
 
 def indepL(L,pList,nA,tB,retWeights=False):
     w = np.sum(L[:,-nA:],axis=-1)

{codedistance-0.0.4 → codedistance-0.0.6}/codedistance/distance.py

@@ -13,7 +13,7 @@ import ortools
 import ortools.linear_solver
 import ortools.linear_solver.pywraplp
 import scipy
-import tesseract_decoder as ts
+# import tesseract_decoder as ts
 
 ## MW Library Files
 from .common import *
@@ -30,6 +30,9 @@ def codeDistance(H,L=None,tB=1,method='QDistRndMW',params={},seed=None):
     CSS codes: input H=HX and L=LX for Z-distance or H=HZ and L=LZ for X-distance, set tB=1
     Classical binary linear codes: set S to be the generator matrix, tB=1 '''
     H = Z2Mat(H)
+    # rWeights = rowWeight(H,tB)
+    # cWeights = np.sum(H,axis=0)
+    # print(f'H Row/Col weights: {set(map(int,rWeights))} {set(map(int,rWeights))}')
     if L is not None:
         L = Z2Mat(L)
     r,n = H.shape
@@ -207,6 +210,36 @@ def pauli2str(S,tB=2):
     PauliStrings = "IXZY"
     return "\n".join(["".join([PauliStrings[a] for a in myrow]) for myrow in S])
 
+
+def codeDecomp(S,tB=2):
+    '''Separate stabiliser code into indecomposable parts using method of Slepian, 1960'''
+    H = getH(S,N=2,tB=2)
+    H1 = mod1(ZMatBlockSum(H,tB=tB))
+    m,n = H1.shape
+    partitions = []
+    rSet = set(range(m))
+    cSet = set(range(n))
+    while len(rSet) > 0:
+        r = min(rSet)
+        cVisited = set()
+        rVisited = {r}
+        rTodo = [r]
+        while(len(rTodo) > 0):
+            r = rTodo.pop()
+            for c in bin2Set(H1[r]):
+                if c not in cVisited:
+                    cVisited.add(c)
+                    for r in bin2Set(H1[:,c]):
+                        if r not in rVisited:
+                            rTodo.append(r)
+                            rVisited.add(r)
+        if tB == 2:
+            cVisited.update({n+c for c in cVisited})
+        partitions.append(list(cVisited))
+        rSet.difference_update(rVisited)
+        cSet.difference_update(cVisited)
+    return partitions
+
 def defaultLogicals(S,tB):
     '''Return defaul logical operators for distance-finding
     For tB=1 - classical code - return basis of complementary space
@@ -676,6 +709,12 @@ def grayCode(x):
     '''calculte Gray Code corresponding to integer x'''
     return  x ^ (x >> 1)
 
+def bin2int(x):
+    """Interpret a little-endian binary vector as an integer."""
+    ## need to reverse to make consistent with int2bin
+    xStr = "".join(map(str, reversed(x)))
+    return int(xStr, base=2)
+
 @nb.jit (nb.int8[:](nb.int64,nb.int64))
 def int2bin(x,n):
     '''convert integer to binary representation'''
@@ -1171,6 +1210,7 @@ def dist_m4ri_RW(S,L,tB=2,params={},seed=0):
 
 def dist_m4ri_CC(S,L,tB=2,params={},seed=0):
     '''Connected Cluster algorithm'''
+    addI = False
     if tB == 2:
         ## 2-block non-CSS code
         if L is None:
@@ -1634,7 +1674,8 @@ def gurobiDist(S,L=None,tB=1,params={}):
         'verbose': False,
         'maxTime': 3600 * 8,
         'nThreads': 1,
-        'GF4blockRep': 2
+        'GF4blockRep': 2,
+        'LOCheck': 0 
     }
     params = setDefaultParams(params,paramDefaults)
     if L is None:
@@ -1727,7 +1768,8 @@ def MIPDist(DEMH,DEML=None,solverType='SCIP',params={}):
     paramDefaults = {
         'verbose': False,
         'maxTime': 3600 * 8,
-        'nThreads': 1
+        'nThreads': 1,
+        'LOCheck': 0
     }
     params = setDefaultParams(params,paramDefaults)
     r,n = DEMH.shape
@@ -1909,6 +1951,21 @@ def parseSATResult(mytext):
 ## Decoder Methods
 ###########################################################
 
+def randomLO(H,L,params,rnd):
+    ## make a random non-trivial lo
+    k,n = L.shape
+    r = len(H)
+    x = NonZeroVecRand(k)
+    lo = Z2MatZeros(n)
+    for j in bin2Set(x):
+        lo ^= L[j]
+    ## add randomly generated set of stabilisers to lo
+    if params['addStabs']:
+        x = rnd.integers(2,size=r)
+        for j in bin2Set(x):
+            lo ^= H[j]
+    return lo
+
 def decoderDist(H,L,params={},seed=None):
     '''Distance via syndrome decoders
     set maxErr to a value 0 < maxErr <= 1 to terminate when probability of error less than pErr'''
@@ -1920,10 +1977,14 @@ def decoderDist(H,L,params={},seed=None):
         'maxErr':-1,
         'priors':None,
         'addStabs':0,
-        'permuteDEM': 1
+        'permuteDEM': 1,
+        'randomLO': 1
     }
     params = setDefaultParams(params,paramDefaults)
     k = len(L)
+    ## if params['randomLO'] == 0, then just try each of the k basis elements
+    if params['randomLO'] == 0:
+        params['iterCount'] = k
     s = Z2Mat([0] * r + [1])
     Hlo = ZMatVstack([H,Z2MatZeros((1,n))])
     wDict = ZMatZeros(n+1)
@@ -1932,16 +1993,7 @@ def decoderDist(H,L,params={},seed=None):
     best, minWords, minWordCount, nExp, pErr = mwUpdate(w,minRows)
     ix = np.arange(n)
     for TrialId in range(params['iterCount']):
-        ## make a random non-trivial lo
-        x = NonZeroVecRand(k)
-        lo = Z2MatZeros(n)
-        for j in bin2Set(x):
-            lo ^= L[j]
-        ## add randomly generated set of stabilisers to lo
-        if params['addStabs']:
-            x = rnd.integers(2,size=r)
-            for j in bin2Set(x):
-                lo ^= H[j]
+        lo = randomLO(H,L,params,rnd) if params['randomLO'] else L[TrialId]
         Hlo[-1] = lo
         ## find a correction
         decoderType = params['decoder']
@@ -1954,6 +2006,8 @@ def decoderDist(H,L,params={},seed=None):
             lo = bplsdDecode(Hlo[:,ix],s,params=params)
         elif decoderType in {'tesseract','tesseractLongbeam'}:
             lo = tesseractDecode(Hlo[:,ix],s,params=params)
+        elif decoderType == 'simplex':
+            lo = simplexDecode(Hlo[:,ix],s,params=params)
         ## reverse permutation for lo
         if params['permuteDEM']:
             lo = lo[ixRev(ix)]
@@ -2008,12 +2062,48 @@ def tesseractDecode(DEMH,s,params={},seed=0):
         det_orders=det_orders,
     )
     decoder = ts.tesseract.TesseractDecoder(config)
+    decoder = ts.simplex.SimplexDecoder(config)
+    decoder.decode_to_errors(syndrome=np.array(s,dtype=bool))
+    ## Tesseract jumbles the order of the errors - need to restore order!!
+    nErr = len(DEMH.T)
+    DEMDict = {tuple(bin2Set(DEMH[:,i])):i for i in range(nErr)}
+    errMap = ZMatZeros(nErr)
+    ## decoder.errors are the errors and symptom.detector tells us which detectors they fire
+    # print('error weight',len(decoder.predicted_errors_buffer),'low_confidence_flag',decoder.low_confidence_flag)
+
+    for i,myObj in enumerate(decoder.errors):
+        errMap[i] = DEMDict[tuple(myObj.symptom.detectors)]
+    return set2Bin(nErr,errMap[decoder.predicted_errors_buffer],dtype=np.int8)
+
+
+def simplexDecode(DEMH,s,params={},seed=0):
+    '''apply simplex Decoder from tesseract distribution with DEM matrix DEMH and syndrome s'''
+    StimDEM = Stabs2StimDEM(DEMH)
+    defaultParams = {
+        'parallelize':False,
+        'window_length':0,
+        'window_slide_length':0,
+        'merge_errors':True
+    }
+    setDefaultParams(params, defaultParams)
+    config = ts.simplex.SimplexConfig(
+        dem=StimDEM,
+        parallelize=params['parallelize'],
+        window_length=params['window_length'],
+        window_slide_length=params['window_slide_length'],
+        merge_errors=params['merge_errors']
+    )
+    decoder = ts.simplex.SimplexDecoder(config)
+    decoder.init_ilp()
+    # print('init_ilp')
     decoder.decode_to_errors(syndrome=np.array(s,dtype=bool))
+    # print('decode_to_errors')
     ## Tesseract jumbles the order of the errors - need to restore order!!
     nErr = len(DEMH.T)
     DEMDict = {tuple(bin2Set(DEMH[:,i])):i for i in range(nErr)}
-    errMap = Z2MatZeros(nErr)
+    errMap = ZMatZeros(nErr)
     ## decoder.errors are the errors and symptom.detector tells us which detectors they fire
+    # print('error weight',len(decoder.predicted_errors_buffer))
     for i,myObj in enumerate(decoder.errors):
         errMap[i] = DEMDict[tuple(myObj.symptom.detectors)]
     return set2Bin(nErr,errMap[decoder.predicted_errors_buffer],dtype=np.int8)
@@ -2074,7 +2164,8 @@ def dist_qubitserf(S,L=None,tB=1,params={}):
     defaultParams={
         'method':'qubitserfMM',
         'maxTime' : 8 * 60 * 60,
-        'nThreads' : 1
+        'nThreads' : 1,
+        'LOCheck': 0
     }
     method = 1 if params['method'] == 'qubitserfBZ' else 2
     params = setDefaultParams(params,defaultParams)

{codedistance-0.0.4 → codedistance-0.0.6}/examples/exampleCSS.py

@@ -21,11 +21,12 @@ params = {
     'iterCount': 10000,     ## number of iterations - eg QDistRnd, decoderDist
     'maxTime': 3600*8,      ## max runtime for CLI methods (eg SAT, m4ri, )
     'nThreads': 1,          ## cater for multi-threaded methods
+    'LOCheck': 0            ## check logical operators
 }
 
 ## Magma distance finding: requires Magma licence and magma executable in PATH
-# method = 'magmaMinWeight'
-method = 'magmaMinWord'
+method = 'magmaMinWeight'
+# method = 'magmaMinWord'
 # method = 'magmaWEDist'
 
 ## Serban Cercelescu C Library https://github.com/qubitserfed/Qubitserf
@@ -104,9 +105,9 @@ allMethods = ['magmaMinWeight',
               'GraphLikeErrorMW',
               'ColourCodeDistMW',
               'decoderDist',
-              'GurobiDist',
               'MIPDist',
-              'pySATDist']
+              'pySATDist',
+              'GurobiDist']
 
 ## Single Method
 methods = [method]
@@ -122,11 +123,4 @@ for method in methods:
     if (res['T'] > 1):
         print(f'Total Trials: {res['T']}')
         print(f'Trials at d={res['d']}: {res['R']}')
-    lo = res['L']
-    if (np.sum(lo)) > 0:
-        r1,V = HowRes(Hz,lo,2)
-        print(f'lo: {bin2Set(lo)}')
-        lo = ZMat2D(lo)
-        r2 = matMul(lo,Hx.T,2)
-        print(f'Logical Operator Check: commutes with stabilsers {np.sum(r2)==0}; non-trivial {np.sum(r1)!=0}')
     print("###########################################\n")

{codedistance-0.0.4 → codedistance-0.0.6}/examples/exampleCircuit.py

@@ -15,6 +15,7 @@ params = {
     'iterCount': 100,     ## number of iterations - eg QDistRnd, decoderDist
     'maxTime': 3600*8,      ## max runtime for CLI methods (eg SAT, m4ri, )
     'nThreads': 1,          ## cater for multi-threaded methods
+    'LOCheck': 0            ## check logical operators
 }
 
 ## Magma distance finding: requires Magma licence and magma executable in PATH

codedistance-0.0.6/examples/exampleCodeDecomp.py

@@ -0,0 +1,54 @@
+import numpy as np
+from codedistance import *
+
+## Illustrate Decomposition of Codes into Direct Sums - Slepian, 1960
+
+
+## Eberhardt108
+n,k,d = 108,16,6
+l,m,ALen = 6,9,3
+uVec = '0 0 0 0 2 4'
+vVec = '0 1 2 3 0 0'
+
+## Eberhardt128
+n,k,d = 128,14,12
+l,m,ALen = 8,8,4
+uVec = '2 0 0 0 0 1 3 4'
+vVec = '0 1 3 4 2 0 0 0'
+
+## Eberhardt162-4
+n,k,d = 162,4,16
+l,m,ALen = 9,9,3
+uVec = '0 1 0 3 0 0'
+vVec = '0 0 1 0 1 2'
+
+## Eberhardt162-12
+n,k,d = 162,12,8
+l,m,ALen = 9,9,3
+uVec = '0 1 0 0 2 3'
+vVec = '0 0 6 3 0 0'
+
+## Eberhardt162-24
+n,k,d = 162,24,6
+l,m,ALen = 9,9,3
+uVec = '0 0 0 0 3 6'
+vVec = '0 1 2 3 0 0'
+
+uVec = list(map(int,uVec.split(" ")))
+vVec = list(map(int,vVec.split(" ")))
+SX,SZ = BBCSSCode(l,m,uVec,vVec,ALen)
+qubitPartitions = codeDecomp(ZMatVstack([SX,SZ]))
+if len(qubitPartitions) == 1:
+    print('No partitions found')
+else:
+    print(f'{len(qubitPartitions)} partitions found')
+    for i,ix in enumerate(qubitPartitions):
+        ix = sorted(ix)
+        print(f'Subcode {i}:',ix)
+        print('SX')
+        print(ZMatPrint(RemoveZeroRows(SX[:,ix])))
+        print('SZ')
+        print(ZMatPrint(RemoveZeroRows(SZ[:,ix])))
+
+
+

{codedistance-0.0.4 → codedistance-0.0.6}/examples/exampleQECC.py

@@ -36,6 +36,7 @@ params = {
     'iterCount': 100,     ## number of iterations - eg QDistRnd, decoderDist
     'maxTime': 3600*8,      ## max runtime for CLI methods (eg SAT, m4ri, )
     'nThreads': 1,          ## cater for multi-threaded methods
+    'LOCheck': 0            ## check logical operators
 }
 
 ## Magma distance finding: requires Magma licence and magma executable in PATH

{codedistance-0.0.4 → codedistance-0.0.6}/examples/runTest.py

@@ -69,6 +69,8 @@ def defaultParser():
     parser.add_argument("--decoder", help="Type of decoder - for decoderDist only. Options are bposd, bplsd, sebplsd, tesseract, tesseractLongbeam",type=str, default='bposd')
     parser.add_argument("--addStabs",help="Add stabilisers to randomly generated error",type=int,default=0) 
     parser.add_argument("--permuteDEM",help="Apply random permutation to columns of DEM",type=int,default=1) 
+    parser.add_argument("--randomLO",help="Generate random LO",type=int,default=1) 
+    
                         
     ## method=='decoderDist' and decoder in {'bposd','bplsd','sebplsd'} only
     ## product_sum good for code capacity, bad for circuit level noise - don't have sparse matrices in this case

{codedistance-0.0.4 → codedistance-0.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "codedistance"
-version = "0.0.4"
+version = "0.0.6"
 description = "Code and Circuit Distance Algorithms."
 license = "GNUv3"
 authors = ["Mark Webster <mark.acacia@gmail.com>","Abraham Jacob <abraham.jacob.17@ucl.ac.uk>","Oscar Higgott <oscarhiggott@google.com>"]