kryptools 1.8__tar.gz → 1.8.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.8
+Version: 1.8.1
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT

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

@@ -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.1}/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.1"
 __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.1}/kryptools/la.py

@@ -381,26 +381,32 @@ 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 = False) -> "Matrix":
         "Compute the Hermite row normal form."
         n, m = self.cols, self.rows
         if not isinstance(self.matrix[0][0], int):
@@ -553,32 +559,58 @@ 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 = self[:,:]
+        A.append_column(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 not any(A.matrix[-1][:-1]) and 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:
+            # compute column normal form (TODO implement full Smith normal form)
+            b = A[:,-1]
+
+            A = A[:,:-1].transpose()
+            A.map(int)
+            A.append_column(A.eye(A.rows))
+            A = A.hrnf().transpose()
+            R = A[b.rows:,:b.rows]
+            A = A[:b.rows,:b.rows]
+            A.map(ring)
+
+            solution_nr = [ 0 ] * A.rows
+            solutions_left = True
+            next_solution = False  # start with the first solution
+            while solutions_left:
+                solution = solution = [ None ] * A.rows
+                solutions_left = False
+                for i in range(A.rows):
+                    bi = b[i]
+                    for k in range(i):
+                        bi -= A.matrix[i][k] * solution[k]
+                    c = A.matrix[i][i].solve(bi, all_solutions = True)
+                    if c is None:
+                        solution = None
+                        break
+                    if next_solution and solution_nr[i] < len(c) - 1:
+                        solution_nr[i] += 1
+                        next_solution = False
+                    if solution_nr[i] < len(c) -1:
+                        solutions_left = True
+                    solution[i] = c[solution_nr[i]]
+                if next_solution: # no more solutions left
                     return None
-            solution[j] = b
+                if solution is not None:
+                    return R * Matrix(solution)
+                next_solution = True
+            return None
+        # the matrix is over a field
+        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:

{kryptools-1.8 → kryptools-1.8.1}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.8
+Version: 1.8.1
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT

{kryptools-1.8 → kryptools-1.8.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kryptools"
-version = "1.8"
+version = "1.8.1"
 authors = [
   { name="Gerald Teschl", email="gerald.teschl@univie.ac.at" },
 ]

{kryptools-1.8 → kryptools-1.8.1}/tests/test_la.py

@@ -1,5 +1,6 @@
 # pragma pylint: disable=C0114,C0116
 import pytest  # pylint: disable=W0611
+from math import gcd  # pylint: disable=C0411
 from random import randint, seed  # pylint: disable=C0411
 from fractions import Fraction  # pylint: disable=C0411
 from kryptools import Matrix, Zmod, GF2, eye, circulant, BinaryMatrix
@@ -36,11 +37,39 @@ def test_Matrix():
     Mi = M.inv()
     assert M * Mi == M.eye()
 
+def test_Matrix2():
+    num_tests = 100
+    seed(0)
+    for ring in Zmod(7), Zmod(8), Zmod(10):
+        for m,n in ((3, 5), (5, 3), (3, 3)):
+            for _ in range(num_tests):
+                A = Matrix([[ring.random() for _ in range(m)] for _ in range(n)])
+                b = Matrix([ring.random() for _ in range(n)])
+                AA = A.applyfunc(lambda x: Fraction(int(x)))
+                if n == m:
+                    d = A.det()
+                    assert d == ring(AA.det())
+                    if gcd(d.x, ring.n) == 1:
+                        assert A.inv() * A == A.eye()
+                    else:
+                        with pytest.raises(ValueError):
+                            A.inv()
+                x = A.solve(b)
+                if x is not None:
+                    assert A * x == b
+                else:
+                    if n == m:
+                        assert gcd(d.x, ring.n) != 1
+                xx = Matrix([ring.random() for _ in range(m)])
+                b = A * xx
+                x = A.solve(b)
+                assert A * x == b
+
 def test_kernel():
     for gf in Zmod(2), Zmod(7), GF2(1), GF2(8):
         for m,n in ((3, 5), (5, 3), (3, 3)):
             for _ in range(25):
-                A = Matrix([[gf.random() for _ in range(m)] for _ in range(n)], ring = gf)
+                A = Matrix([[gf.random() for _ in range(m)] for _ in range(n)])
                 K = A.kernel()
                 assert not A * K
                 assert K.rows == A.cols