kryptools 1.8__tar.gz → 1.8.2__tar.gz

{kryptools-1.8 → kryptools-1.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.8
+Version: 1.8.2
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -43,11 +43,11 @@ The tools contained are:
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
 * integer factorization (Fermat, Pollard p-1, Pollard rho, Lenstra's ECM, Dixon, basic quadratic sieve)
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
-* linear algebra: Hermite normal form, Gram-Schmidt
+* linear algebra: Hermite normal form, Smith normal form, Gram-Schmidt
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz), SIS, ISIS, LWE
 * linear codes: Hamming distance, left standard form, parity check matrix
 
-* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, etc.)
+* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, solving linear systems, etc.)
 * BinaryMatrix: a class for Matrices with binary entries (for much faster row operations)
 * Poly: a class for polynomials (division, modulo, factoring and irreducibility test over finite fields, Lagrange interpolation)
 * Zmod: a class for the ring of integers modulo an integer

{kryptools-1.8 → kryptools-1.8.2}/README.md

@@ -25,11 +25,11 @@ The tools contained are:
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
 * integer factorization (Fermat, Pollard p-1, Pollard rho, Lenstra's ECM, Dixon, basic quadratic sieve)
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
-* linear algebra: Hermite normal form, Gram-Schmidt
+* linear algebra: Hermite normal form, Smith normal form, Gram-Schmidt
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz), SIS, ISIS, LWE
 * linear codes: Hamming distance, left standard form, parity check matrix
 
-* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, etc.)
+* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, solving linear systems, etc.)
 * BinaryMatrix: a class for Matrices with binary entries (for much faster row operations)
 * Poly: a class for polynomials (division, modulo, factoring and irreducibility test over finite fields, Lagrange interpolation)
 * Zmod: a class for the ring of integers modulo an integer

{kryptools-1.8 → kryptools-1.8.2}/kryptools/Zmod.py

@@ -172,7 +172,7 @@ class ZmodPoint:
         return f"{x} (mod {self.ring.n})"
 
     def __eq__(self, other):
-        if not isinstance(other, self.__class__) or self.ring != other.ring:
+        if not isinstance(other, self.__class__) or self.ring.n != other.ring.n:
             return False
         return self.x == other.x
 
@@ -328,18 +328,24 @@ class ZmodPoint:
             roots.append((p**(j//2) * x) % pk)
         return self.ring(crt(roots, powers))
 
-    def solve(self, b):
+    def solve(self, b, all_solutions: bool = False) -> "ZmodPoint":
         "Find a solution `x` of the linear equation `self * x == b` in Z_n."
         b = int(b)
         if not self:
             if b:
                 return None
+            if all_solutions:
+                return list(self.ring)
             return self.ring(0)
         g = gcd(self.x, self.ring.n)
         if b % g:
             return None
-        return self.ring(pow(self.x // g, -1, self.ring.n) * (b // g))
+        m = self.ring.n // g
+        sol = self.ring(pow(self.x // g, -1, m) * (b // g) % m)
+        if all_solutions:
+            return [ sol + j * m for j in range(g) ]
+        return sol
 
-    def is_generator(self):
+    def is_generator(self) -> bool:
         "Test if the point is a generator of the group Z_n^*."
         return self.ring.order() == self.order()

{kryptools-1.8 → kryptools-1.8.2}/kryptools/__init__.py

@@ -5,7 +5,7 @@ Implemenation of same basic algorithms used in cryptography.
 __author__ = "Gerald Teschl"
 __copyright__ = "Copyright 2024-2025, Gerald Teschl"
 __license__ = "MIT License"
-__version__ = "1.8"
+__version__ = "1.8.2"
 __email__ = "Gerald.Teschl@univie.ac.at"
 
 from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, is_carmichael_number, order, crt

{kryptools-1.8 → kryptools-1.8.2}/kryptools/la.py

@@ -6,6 +6,7 @@ Linear algebra
 from math import gcd, inf, sqrt
 from numbers import Number
 from fractions import Fraction
+from .nt import egcd
 from .Zmod import Zmod
 
 class Matrix:
@@ -215,19 +216,66 @@ class Matrix:
                     self.matrix[i].append(c)
             self.cols += 1
 
-    def permute_columns(self, permutation) -> None:
+    def swap_columns(self, i: int, j: int) -> None:
+        "Swap two columns."
+        for k in range(self.rows):
+            self.matrix[k][i], self.matrix[k][j] = self.matrix[k][j], self.matrix[k][i]
+
+    def swap_rows(self, i: int, j: int) -> None:
+        "Swap two rows."
+        self.matrix[i], self.matrix[j] = self.matrix[j], self.matrix[i]
+
+    def permute_columns(self, permutation: list) -> None:
         "Permute columns according to a list of new positions."
         if len(permutation) != self.cols:
             raise ValueError(f"The argument must be a list of indices of length {self.cols}.")
         for i in range(self.rows):
             self.matrix[i] = [ self.matrix[i][j] for j in permutation]
 
-    def permute_rows(self, permutation) -> None:
+    def permute_rows(self, permutation: list) -> None:
         "Permute rows according to a list of new positions."
         if len(permutation) != self.rows:
             raise ValueError(f"The argument must be a list of indices of length {self.rows}.")
         self.matrix = [ self.matrix[i] for i in permutation]
 
+    def scale_column(self, i: int, a: Number) -> None:
+        "Scale a column."
+        for k in range(self.rows):
+            self.matrix[k][i] *= a
+
+    def scale_row(self, i: int, a: Number) -> None:
+        "Scale a row."
+        for k in range(self.cols):
+            self.matrix[i][k] *= a
+
+    def addto_column(self, i: int, j: int, a: Number|None = None) -> None:
+        "Add a multiple of the first column to the second."
+        if a is None:
+            for k in range(self.rows):
+                self.matrix[k][i] += self.matrix[k][j]
+        else:
+            for k in range(self.rows):
+                self.matrix[k][i] += a * self.matrix[k][j]
+
+    def addto_row(self, i: int, j: int, a: Number|None = None) -> None:
+        "Add a multiple of the first row to the second."
+        if a is None:
+            for k in range(self.cols):
+                self.matrix[i][k] += self.matrix[j][k]
+        else:
+            for k in range(self.cols):
+                self.matrix[i][k] += a * self.matrix[j][k]
+
+    def maop_row(self, i: int, k: int, a: Number, b: Number, c: Number, d: Number) -> None:
+        "Replaces the i,j and k,j entry by  by using an matrix column operation."
+        for l in range(self.cols):
+            self.matrix[i][l], self.matrix[k][l] = a * self.matrix[i][l] + b * self.matrix[k][l], c * self.matrix[i][l] + d * self.matrix[k][l]
+
+    def maop_column(self, j: int, k: int, a: Number, b: Number, c: Number, d: Number) -> None:
+        "Replaces the i,j and i,k entry by using an matrix column operation."
+        for l in range(self.rows):
+            self.matrix[l][j], self.matrix[l][k] = a * self.matrix[l][j] + b * self.matrix[l][k], c * self.matrix[l][j] + d * self.matrix[l][k]
+
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False
@@ -381,72 +429,71 @@ class Matrix:
         "Compute the reduced echelon form if the base ring is Z_n and no field."
         ring = self.matrix[0][0].ring
         M = self.applyfunc(int)
-        done = False
-        while not done:
-            M = M.hermite_rnf(start = start, drop_zero_rows = drop_zero_rows)
-            done = True
+        done = start
+        while done < M.cols:
+            M = M.hrnf(start = start, drop_zero_rows = drop_zero_rows)
+            done = M.cols
             for i, j in enumerate(M.pivotcols):
+                if j < start:
+                    continue
                 pivot = M.matrix[i][j]
                 if pivot >= ring.n:
-                    done = False
+                    done = min(j, done)
                     pivot %= ring.n
-                if pivot!=1 and gcd(pivot, ring.n) == 1:  # we can make the pivot one
-                    done = False
-                    M.matrix[i][j] = 1
+                if pivot:  # find the invertible part
+                    g = gcd(pivot, ring.n)
+                    while g > 1:
+                        pivot //= g
+                        g = gcd(pivot, ring.n)
+                if pivot > 1:  # we can make the pivot smaller
+                    done = min(j, done)
                     tmp = pow(pivot, -1, ring.n)
-                    for k in range(j + 1, M.cols):
+                    for k in range(j, M.cols):
                         M.matrix[i][k] *= tmp
             M.map(lambda x: x % ring.n)
         M.map(ring)
         return M
 
-    def hermite_rnf(self, start = 0, drop_zero_rows: bool = False) -> "Matrix":
+
+    def hrnf(self, start = 0, drop_zero_rows: bool = True) -> "Matrix":
         "Compute the Hermite row normal form."
         n, m = self.cols, self.rows
         if not isinstance(self.matrix[0][0], int):
             raise ValueError("Hermite normal form requires integer entries!")
-        H = [ self.matrix[i][:] for i in range(m) ]
-        pivotcols = []
-        nonpivotcols = []
+        H = self[:,:]
+        H.pivotcols = []
+        H.nonpivotcols = []
         i = 0
         if start >= n:
             raise ValueError("Start value cannot be beyond the last column.")
         for j in range(start, n):
             i0 = i
-            minimum = abs(H[i][j])  # search for the pivot in the present column
+            minimum = abs(H.matrix[i][j])  # search for the pivot in the present column
             for ii in range(i + 1, m):
-                tmp = abs(H[ii][j])
+                tmp = abs(H.matrix[ii][j])
                 if tmp > 0 and (tmp < minimum or minimum == 0):
                     minimum = tmp
                     i0 = ii
             if minimum == 0:
-                nonpivotcols.append(j)
+                H.nonpivotcols.append(j)
                 continue  # all entrjes are zero
-            pivotcols.append(j)
+            H.pivotcols.append(j)
             if i0 > i:
-                H[i], H[i0] = H[i0], H[i]  # swap rows, to move the pivot jn place
-            if H[i][j] < 0:
-                for k in range(n):
-                    H[i][k] *= -1  # make the pivot positive
-            ii = i + 1
-            while ii < m:  # make the column entries below to the pivot zero
-                tmp = H[ii][j] // H[i][j]
-                for k in range(n):
-                    H[ii][k] -= tmp * H[i][k]
-                if H[ii][j]:
-                    H[i], H[ii] = H[ii], H[i]  # swap rows
-                else:
-                    ii += 1
+                H.swap_rows(i, i0)  # swap rows, to move the pivot in place
+            if H.matrix[i][j] < 0:
+                H.scale_row(i, -1)  # make the pivot positive
+            for ii in range(i + 1, m):  # make the column entries below to the pivot zero
+                if H.matrix[ii][j]:
+                    g, x, y = egcd(H.matrix[i][j], H.matrix[ii][j], minimal = True)
+                    xx = H.matrix[i][j] // g
+                    yy = - H.matrix[ii][j] // g
+                    H.maop_row(i, ii, x, y, yy, xx)
             for ii in range(i):  # reduce the column entries above to the pivot
-                tmp = H[ii][j] // H[i][j]
-                for k in range(n):
-                    H[ii][k] -= tmp * H[i][k]
+                H.addto_row(ii, i, -(H.matrix[ii][j] // H.matrix[i][j]))
             i += 1
             if i >= m:
                 break
-        H = Matrix(H)
-        H.pivotcols = pivotcols
-        H.nonpivotcols = nonpivotcols + list(range(j+1, H.cols))
+        H.nonpivotcols += list(range(j+1, H.cols))
         # purge zero rows
         if drop_zero_rows:
             l = len(H.pivotcols)
@@ -456,6 +503,141 @@ class Matrix:
             H.rows = l
         return H
 
+    def hnf(self, drop_zero_columns: bool = True) -> "Matrix":
+        "Compute the Hermite normal form."
+        n, m = self.cols, self.rows
+        if not isinstance(self.matrix[0][0], int):
+            raise ValueError("Hermite normal form requires integer entries!")
+        H = self[:,:]
+        j = n - 1
+        for i in range(m-1,-1,-1):
+            j0 = j
+            minimum = abs(H.matrix[i][j])  # search for the pivot in the present row
+            for jj in range(j):
+                tmp = abs(H.matrix[i][jj])
+                if tmp > 0 and (tmp < minimum or minimum == 0):
+                    minimum = tmp
+                    j0 = jj
+            if minimum == 0:
+                continue  # all entries are zero
+            if j0 < j:
+                H.swap_columns(j, j0)  # swap columns, to move the pivot in place
+            if H.matrix[i][j] < 0:
+                H.scale_column(j, -1)  # make the pivot positive
+            for jj in range(j):  # make the row left to the pivot zero
+                if H.matrix[i][jj]:
+                    g, x, y = egcd(H.matrix[i][j], H.matrix[i][jj], minimal = True)
+                    xx = H.matrix[i][j] // g
+                    yy = - H.matrix[i][jj] // g
+                    H.maop_column(j, jj, x, y, yy, xx)
+            for jj in range(j + 1, n):  # reduce the row entries right to the pivot
+                H.addto_column(jj, j, -(H.matrix[i][jj] // H.matrix[i][j]))
+            j -= 1
+            if j < 0:
+                break
+        if drop_zero_columns:
+            while H.cols > 1 and all(not H.matrix[i][0] for i in range(m)):  # remove zero columns
+                H = H[:, 1:]
+        return H
+
+    def snf(self, drop_zero_rows: bool = False, drop_zero_columns: bool = False, include_S: bool = True, include_T: bool = True) -> "Matrix":
+        "Computes the Smith normal form D of a matrix A with integer coefficients together with invertible matrices S and T such that D = S * A * T."
+        if not isinstance(self.matrix[0][0], int):
+            raise ValueError("Smith normal form requires integer entries!")
+        m, n = self.rows, self.cols
+        A = self[:,:]
+        if include_T:
+            T = A.eye(n)
+        if include_S:
+            S = A.eye(m)
+        for i in range(min(n,m)):
+            minimum = abs(A.matrix[i][i])  # search for the pivot
+            i0, j0 = i, i
+            for ii in range(i, m):
+                for jj in range(i, n):
+                    tmp = abs(A.matrix[ii][jj])
+                    if tmp > 0 and (tmp < minimum or minimum == 0):
+                        minimum = tmp
+                        i0, j0 = ii, jj
+            if not minimum:
+                break
+            if j0 != i:  # swap columns, to move the pivot in place
+                if include_T:
+                    T.swap_columns(i, j0)
+                A.swap_columns(i, j0)
+            if i0 != i:  # swap rows, to move the pivot in place
+                if include_S:
+                    S.swap_rows(i, i0)
+                A.swap_rows(i, i0)
+            if A[i, i] < 0:  # make the pivot positive
+                if include_S:
+                    S.scale_row(i, -1)
+                A.scale_row(i, -1)
+            done = False
+            while not done:
+                for jj in range(i+1, n):
+                    if A.matrix[i][jj] == 0:
+                        continue
+                    g, x, y = egcd(A.matrix[i][i], A.matrix[i][jj], minimal = True)
+                    xx = A.matrix[i][i] // g
+                    yy = A.matrix[i][jj] // g
+                    if include_T:
+                        T.maop_column(i, jj, x, y, -yy, xx)
+                    A.maop_column(i, jj, x, y, -yy, xx)
+                for ii in range(i+1, m):
+                    if A.matrix[ii][i] == 0:
+                        continue
+                    g, x, y = egcd(A.matrix[i][i], A.matrix[ii][i], minimal = True)
+                    xx = A.matrix[i][i] // g
+                    yy = -A.matrix[ii][i] // g
+                    if include_S:
+                        S.maop_row(i, ii, x, y, yy, xx)
+                    A.maop_row(i, ii, x, y, yy, xx)
+                done = True
+                for jj in range(i+1, n):
+                    if A[i,jj] != 0:
+                        done = False
+                        break
+        for l in range(min(n,m)-1, 0, -1):
+            for i in range(l):
+                if A.matrix[i][i] and A.matrix[i+1][i+1] % A.matrix[i][i]:
+                    g, x, y = egcd(A.matrix[i][i], A.matrix[i+1][i+1], minimal = True)
+                    aa= A.matrix[i][i] //g
+                    bb = -A.matrix[i+1][i+1]//g
+                    by = bb * y
+                    if include_T:
+                        T.addto_column(i, i+1)
+                        T.addto_column(i+1, i, by)
+                    A.addto_column(i, i+1)
+                    A.addto_column(i+1, i, by)
+                    if include_S:
+                        S.maop_row(i, i+1, x, y, bb, aa)
+                    A.maop_row(i, i+1, x, y, bb, aa)
+        if drop_zero_rows or drop_zero_columns:
+            for i in range(min(n,m)):
+                if A[i,i] == 0:
+                    break
+            else:
+                i += 1
+            i = max(i, 1)
+        if drop_zero_rows:
+            if i < m:
+                del A[i:, :]
+                if include_S:
+                    del S[i:, :]
+        if drop_zero_columns:
+            if i < n:
+                del A[:, i:]
+                if include_T:
+                    del T[:, i:]
+        if include_S and include_T:
+            return A, S, T
+        if include_S:
+            return A, S
+        if include_T:
+            return A, T
+        return A
+
     def left_standard_form(self) -> "Matrix":
         "Compute the left standard form."
         # reduced row echelon form
@@ -468,7 +650,24 @@ class Matrix:
     def kernel(self) -> "Matrix":
         "Compute a basis for the kernel."
         if hasattr(self.matrix[0][0], "ring") and not self.matrix[0][0].ring.is_field():
-            raise NotImplementedError("The matrix must be over a field, not a ring.")
+            ring = self.matrix[0][0].ring
+            M = self.applyfunc(int)
+            D, T = M.snf(include_S=False, drop_zero_rows=True)
+            D.map(ring)
+            T.map(ring)
+            K = D.eye(D.cols)
+            shift = 0
+            for i in range(D.rows):
+                g = gcd(int(D.matrix[i][i]), ring.n)
+                if g == 1:
+                    if shift == D.cols - 1:
+                        K.matrix[i][i - shift] = ring(0)
+                        break
+                    K.delete_columns(i - shift)
+                    shift += 1
+                elif g < ring.n:
+                    K.matrix[i][i-shift] = ring(ring.n // g)
+            return T * K
         _, one = self._guess_zero()
         M = self.rref(drop_zero_rows = True)
         K = M.zeros(M.cols, max(1,len(M.nonpivotcols)))
@@ -553,32 +752,36 @@ class Matrix:
     def solve(self, b: list|tuple) -> "Matrix":
         "Solve the linear system with given inhomogenous vector."
         if isinstance(b, list|tuple):
-            b = Matrix(b)
+            b = self.__class__(b)
         if self.rows != b.rows or b.cols != 1:
             raise ValueError("Matrix dimensions do not match.")
-        A = self.zeros(self.rows, self.cols + 1) # extended coefficient matrix
-        A[:, 0:self.cols] = self
-        A[:, self.cols] = b
-        A = A.rref(drop_zero_rows = True)
-        solution = self.zeros(self.cols, 1)
-        if not any(A.matrix[-1][:-1]):
-            if A.matrix[-1][-1]:
-                return None  # Not solvable
         if hasattr(self.matrix[0][0], "ring") and not self.matrix[0][0].ring.is_field():
             # the matrix is over a ring (not a field)
             ring = self.matrix[0][0].ring
-        else:
-            ring = None
-        for i in range(A.rows-1, -1, -1):
-            j = A.pivotcols[i]
-            b = A.matrix[i][-1]
-            if ring:
-                for k in range(j + 1, self.cols):
-                    b -= A.matrix[i][k] * solution[k]
-                b = A.matrix[i][j].solve(b)
-                if b is None:
+            A = self.applyfunc(int)
+            D, S, T = A.snf()
+            D.map(ring)
+            S.map(ring)
+            T.map(ring)
+            b = S * b
+            for i in range(min(A.rows, A.cols), A.rows):
+                if b[i]:
+                    return None
+            y = [ ring(0) ] * A.cols
+            for i in range(min(A.rows, A.cols)):
+                y[i] = D[i,i].solve(b[i])
+                if y[i] is None:
                     return None
-            solution[j] = b
+            return T * Matrix(y)
+        # the matrix is over a field
+        A = self[:,:]
+        A.append_column(b)
+        A = A.rref(drop_zero_rows = True)
+        if not any(A.matrix[-1][:-1]) and A.matrix[-1][-1]:
+            return None  # Not solvable
+        solution = self.zeros(self.cols, 1)
+        for i, j in enumerate(A.pivotcols):
+            solution[j] = A.matrix[i][-1]
         return solution
 
     def is_unimodular(self) -> bool:
@@ -879,7 +1082,18 @@ class BinaryMatrix:
         self.rows += 1
         self.matrix.append(row)
 
-    def permute_columns(self, permutation) -> None:
+    def swap_columns(self, i: int, j: int) -> None:
+        "Swap two columns."
+        for k in range(self.rows):
+            b = self.matrix[k]
+            x = ((b >> i) ^ (b >> j)) & 1
+            self.matrix[k] ^= ((x << i) | (x << j))
+
+    def swap_rows(self, i: int, j: int) -> None:
+        "Swap two rows."
+        self.matrix[i], self.matrix[j] = self.matrix[j], self.matrix[i]
+
+    def permute_columns(self, permutation: list) -> None:
         "Permute columns according to a list of new positions."
         if len(permutation) != self.cols:
             raise ValueError(f"The argument must be a list of indices of length {self.cols}.")
@@ -888,7 +1102,7 @@ class BinaryMatrix:
             bits = [ bits[j] for j in permutation]
             self.matrix[i] = self.from_bits(bits)
 
-    def permute_rows(self, permutation) -> None:
+    def permute_rows(self, permutation: list) -> None:
         "Permute rows according to a list of new positions."
         if len(permutation) != self.rows:
             raise ValueError(f"The argument must be a list of indices of length {self.rows}.")