kryptools 1.9.2__tar.gz → 1.9.4__tar.gz

{kryptools-1.9.2 → kryptools-1.9.4}/PKG-INFO

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

{kryptools-1.9.2 → kryptools-1.9.4}/kryptools/__init__.py

@@ -5,7 +5,7 @@ Implemenation of same basic algorithms used in cryptography.
 __author__ = "Gerald Teschl"
 __copyright__ = "Copyright 2024-2026, Gerald Teschl"
 __license__ = "MIT License"
-__version__ = "1.9.2"
+__version__ = "1.9.4"
 __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
@@ -16,8 +16,8 @@ from .dlp import dlog
 from .ec import EC_Weierstrass
 from .la import Matrix, zeros, eye, circulant, BinaryMatrix
 from .lat import Lattice, random_unimodular_matrix
-from .lat2 import q_ary_lattice, gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_plane_cvp, babai_plane_bnd, lll, svp, cvp, sis, isis, sis_search, isis_search
-from .poly import Poly, PolyBinMult, lagrange_interpolation
+from .lat2 import q_ary_lattice, gram_det, hadamard_ratio, hermite_factor, root_hermite_factor, hermite_nf, gram_schmidt, babai_round_cvp, babai_plane_cvp, babai_plane_bnd, lll, svp, cvp, sis, isis, sis_search, isis_search
+from .poly import Poly, PolyBinMult, lagrange_interpolation, sylvester, resultant
 from .Zmod import Zmod
 from .GF2 import GF2, GF2_aes, GF2_miniaes, GF2_ghash
 from .code import gen2pchk, hamming_dist, BinaryCode, GolayCode, HammingCode, ReedMullerCode, GoppaCode, CyclicCode, ReedSolomonCode, BCHCode

{kryptools-1.9.2 → kryptools-1.9.4}/kryptools/la.py

@@ -709,7 +709,7 @@ class Matrix:
             R = [ list(map(lambda x: Fraction(int(x)), row)) for row in self.matrix ]
             zero, one = ring(0), 1
         elif self.is_integer():
-            ring = None
+            ring = int
             R = [ list(map(Fraction, row)) for row in self.matrix ]
             zero, one = 0, 1
         else:
@@ -868,17 +868,19 @@ def eye(m: int, n: int = None, zero=0, one=1, ring=None) -> "Matrix":
         raise ValueError(f"Matrix dimensions {m}x{n} must be positive!")
     return Matrix([[delta(i, j) for j in range(n)] for i in range(m)], ring=ring)
 
-def rotate(l: list, n: int) -> list:
+def rotate(l: list, n: int, skew=False) -> list:
     "Rotate a list cyclically n places to the left."
     n %= len(l)
+    if skew:
+        return l[n:] + [ -a for a in l[:n] ]
     return l[n:] + l[:n]
 
-def circulant(vector: list|tuple, m: int = None, ring=None) -> "Matrix":
-    "Returns a circulant matrix from the given vector."
+def circulant(vector: list|tuple, m: int = None, ring=None, skew=False) -> "Matrix":
+    "Returns a (skew) circulant matrix from the given vector."
     if m is None:
         m = len(vector)
     vector = list(reversed(vector))
-    return Matrix([rotate(vector, -n-1) for n in range(m)], ring=ring)
+    return Matrix([rotate(vector, -n-1, skew=skew) for n in range(m)], ring=ring)
 
 class BinaryMatrix:
     """

{kryptools-1.9.2 → kryptools-1.9.4}/kryptools/lat.py

@@ -473,6 +473,18 @@ class Lattice():
         "Compute the Hadamard ratio of the current basis."
         return (self.gram_det() / prod(map(self.norm2, self.U)) ) ** (1 / self.len)
 
+    def hermite_factor(self) -> float:
+        "Compute the Hermit factor of the current basis."
+        if self.Nu is not None:
+            norm = self.Nu[0] ** (1/2)
+        else:
+            norm = self.norm2(self.U[0]) ** (1/2)
+        return norm / (self.gram_det() ** (1 / self.len))
+
+    def root_hermite_factor(self) -> float:
+        "Compute the root Hermit factor of the current basis."
+        return self.hermite_factor() ** (1 / (self.len - 1))
+
     def svp(self, method: str = 'all', delta: float = 0.75) -> Matrix:
         "Solve the SVP (approximately) using a given method."
         method = method.lower()

{kryptools-1.9.2 → kryptools-1.9.4}/kryptools/lat2.py

@@ -45,6 +45,14 @@ def hadamard_ratio(M: Matrix) -> float:
     m = M.rows
     return (gram_det(M) / prod([M[:, i].norm() for i in range(m)])) ** (1 / m)
 
+def hermite_factor(M: Matrix) -> float:
+    "Compute the Hermite factor of the current basis."
+    return M[:, 0].norm() / (gram_det(M) ** (1 / M.rows))
+
+def root_hermite_factor(M: Matrix) -> float:
+    "Compute the Hermite root factor of the current basis."
+    return hermite_factor(M) ** (1 / (M.rows - 1))
+
 def babai_round_cvp(x: Matrix, U: Matrix) -> Matrix:
     "Babai's rounding algorithm for approximately solving the CVP."
     s = U.inv() * x

{kryptools-1.9.2 → kryptools-1.9.4}/kryptools/poly.py

@@ -2,13 +2,15 @@
 Polynomials
 """
 
-from math import prod, comb
+from math import prod, gcd, lcm, comb, sqrt
+from fractions import Fraction
 from numbers import Number
 from random import randint
 from itertools import combinations
 from copy import copy
 from .Zmod import Zmod
 from .nt import crt
+from .la import Matrix, zeros
 
 class Poly:
     """
@@ -102,7 +104,7 @@ class Poly:
     def __hash__(self):
         return hash(tuple(self.coeff))
 
-    def __repr__(self, latex=None):
+    def __repr__(self, latex: bool|None = None):
         def prx(i: int) -> str:
             if i == 0:
                 return ""
@@ -116,7 +118,7 @@ class Poly:
 
         if latex is None:
             latex = self.__class__.print_latex
-        if not self:
+        if len(self.coeff) == 1:
             return str(self.coeff[0])
         one = self.coeff[0]**0
         plus = ""
@@ -132,25 +134,17 @@ class Poly:
                 tmp += plus + prx(i)
                 plus = " + "
                 continue
-            try:
-                if not s + one and i != 0:
-                    if plus:
-                        plus = " "
-                    tmp += plus + "- " + prx(i)
-                    plus = " + "
-                    continue
-            except:  # pylint: disable=W0702
-                pass
-            try:
-                if hasattr(s, "ring") and hasattr(s.ring, "sharp") and s.ring.sharp:
-                    s = s.sharp()
-                if plus and s < 0:
-                    tmp += " - " + str(-s)
-                    if i != 0:
-                        tmp += " " + prx(i)
-                    continue
-            except:  # pylint: disable=W0702
-                pass
+            if not s + one and i != 0 and str(s)[0] == '-':
+                if plus:
+                    plus = " "
+                tmp += plus + "- " + prx(i)
+                plus = " + "
+                continue
+            if plus and str(s)[0] == '-':
+                tmp += " - " + str(-s)
+                if i != 0:
+                    tmp += " " + prx(i)
+                continue
             tmp += plus + str(s)
             if i != 0:
                 tmp += " " + prx(i)
@@ -181,7 +175,7 @@ class Poly:
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False
-        return not bool(self - other)
+        return self.coeff == other.coeff
 
     def __bool__(self):
         return bool(self.degree()) or bool(self.coeff[0])
@@ -306,7 +300,16 @@ class Poly:
                 return self.__class__([other * s for s in self.coeff], modulus = self.modulus, cyclic = self.cyclic, check = False)
             return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
-        if self.cyclic or other.cyclic:
+        modulus = self.modulus
+        if not modulus and other.modulus:
+            modulus = other.modulus
+        cyclic = self.cyclic
+        if not self.cyclic and other.cyclic:
+            cyclic = other.cyclic
+            modulus = other.modulus
+        if (ls == 1 and not self.coeff[0]) or (lo == 1 and not other.coeff[0]):
+            return self.__class__([zero], modulus = modulus, cyclic = cyclic, check = False)
+        if cyclic:
             if self.cyclic:
                 cyclic = self.cyclic
                 modulus = self.modulus
@@ -397,6 +400,22 @@ class Poly:
         "Sum of the absolute value of all coefficients."
         return sum(abs(c) for c in self.coeff)
 
+    def norm(self) -> int:
+        "Euclidean norm of the coefficients."
+        return sqrt(sum(abs(c)**2 for c in self.coeff))
+
+    def content(self) -> int:
+        "Return the content, the gcd of all coefficients, of a polynomial."
+        if not all(map(lambda _: isinstance(_, int), self.coeff)):
+            raise ValueError("Content requires integer coefficients.")
+        return gcd(*self.coeff)
+
+    def primitive_part(self) -> int:
+        "Return the primitive part of a polynomial."
+        if not all(map(lambda _: isinstance(_, int), self.coeff)):
+            raise ValueError("Primitive part requires integer coefficients.")
+        return self // gcd(*self.coeff)
+
     def __floordiv__(self, other: "Poly") -> "Poly":
         return self.divmod(other)[0]
 
@@ -554,18 +573,24 @@ class Poly:
         "Least common multiple with a given polynomial."
         return self * other // self.gcd(other)
 
-    def egcd(self, other: "Poly") -> ("Poly", "Poly", "Poly"):
-        """Perform the extended Euclidean agorithm for polynomials. Returns gcd, x, y such that other * x + self * y = gcd."""
+    def egcd(self, other: "Poly", integer:bool = False) -> ("Poly", "Poly", "Poly"):
+        """Perform the extended Euclidean agorithm for polynomials. Returns gcd, x, y such that self * x + other * y = gcd."""
         zero, one, _ = self._guess_ring()
         if not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot perform egcd: {other} must be a polynomial.")
+        if integer:
+            if not( all(map(lambda _: isinstance(_, int), self.coeff)) and all(map(lambda _: isinstance(_, int), other.coeff)) ):
+                raise ValueError("The option 'integer' requires integer coefficients.")
         if not self:
             if not other:
                 return self.__class__([zero], check = False), self.__class__([zero], check = False), self.__class__([zero], check = False)
-            if other.coeff[-1] == one:
+            if other.coeff[-1] == one or integer:
                 return other, self.__class__([zero], check = False), self.__class__([one], check = False)
             return other / other.coeff[-1], __class__([zero], check = False), self.__class__([one / other.coeff[-1]], check = False)
-        r0, r1 = other, self
+        if integer:
+            r0, r1 = self.applyfunc(Fraction), other.applyfunc(Fraction)
+        else:
+            r0, r1 = self, other
         x0, x1 = self.__class__([one], check = False), self.__class__([zero], check = False)
         y0, y1 = x1, x0
         while r1:
@@ -574,9 +599,17 @@ class Poly:
             x0, x1 = x1, x0 - x1 * q
             y0, y1 = y1, y0 - y1 * q
         lcr0 = r0.coeff[-1]
-        if lcr0 == one:
-            return r0, x0, y0
-        return r0 / lcr0, x0 / lcr0, y0 / lcr0
+        if lcr0 != one:
+            r0, x0, y0 = r0 / lcr0, x0 / lcr0, y0 / lcr0
+        if integer:
+            lcmx = lcm(*map(lambda _: _.denominator, x0.coeff))
+            lcmy = lcm(*map(lambda _: _.denominator, y0.coeff))
+            lcmxy = lcm(lcmx,lcmy)
+            r0, x0, y0 = lcmxy * r0, lcmxy * x0, lcmxy * y0
+            r0.map(int)
+            x0.map(int)
+            y0.map(int)
+        return r0, x0, y0
 
     def derivative(self) -> "Poly":
         "Returns the formal derivative."
@@ -767,7 +800,7 @@ class PolyBinMult():
                     self.monomials.append(combination)
                 i += 1
 
-    def __repr__(self, latex=None):
+    def __repr__(self, latex: bool|None = None):
         def prx(i: int) -> str:
             if len(self.__class__.print_x) >= self.m:
                 return self.__class__.print_x[i]
@@ -792,7 +825,7 @@ class PolyBinMult():
     def _repr_mimebundle_(self, **kwargs):  # pylint: disable=W0613
         return {
             "text/plain": repr(self),
-            "text/latex": "$" + self.__repr__(latex=True) + "$"  # pylint: disable=C2801
+            "text/latex": "$" + self.__repr__(latex = True) + "$"  # pylint: disable=C2801
         }
 
     def index2monomial(self, idx: int) -> tuple|None:
@@ -842,7 +875,7 @@ class PolyBinMult():
             val += prod(x[i] for i in monomial)
         return val % 2
 
-    def __eq__(self, other):
+    def __eq__(self, other: "PolyBinMult"):
         if not isinstance(other, self.__class__):
             return False
         return not bool(self + other)
@@ -850,7 +883,7 @@ class PolyBinMult():
     def __bool__(self):
         return bool(self.monomials)
 
-    def __add__(self, other) -> "PolyBinMult":
+    def __add__(self, other: "PolyBinMult") -> "PolyBinMult":
         if not isinstance(other, self.__class__):
             return NotImplemented
         if other.m != self.m:
@@ -870,7 +903,7 @@ class PolyBinMult():
 
     __neg__ = __pos__
 
-    def __mul__(self, other) -> "PolyBinMult":
+    def __mul__(self, other: "PolyBinMult") -> "PolyBinMult":
         if isinstance(other, self.__class__):
             return self.multiply(other)
         if isinstance(other, int):
@@ -879,14 +912,14 @@ class PolyBinMult():
             return self.__class__([], self.m)
         return NotImplemented
 
-    def __rmul__(self, other) -> "PolyBinMult":
+    def __rmul__(self, other: "PolyBinMult") -> "PolyBinMult":
         if isinstance(other, int):
             if other % 2:
                 return self
             return self.__class__([], self.m)
         return NotImplemented
 
-    def multiply(self, other) -> "PolyBinMult":
+    def multiply(self, other: "PolyBinMult") -> "PolyBinMult":
         "Polynomial Multiplication."
         res = []
         for monomials in self.monomials:
@@ -929,3 +962,28 @@ def lagrange_interpolation(x_coordinates: list, y_coordinates: list) -> "Poly":
         poly += (y /
                  prod([x - xx for xx in x_coordinates if xx != x], start=one)) * L
     return poly
+
+def sylvester(p: "Poly", q: "Poly") -> "Matrix":
+    "Sylvester matrix of the given polynomials."
+    n = q.degree()
+    m = p.degree()
+    S = zeros(m + n)
+    k = 0
+    for i in range(n):
+        j = k
+        for c in p.coeff:
+            S[j, i] = c
+            j += 1
+        k = k + 1
+    k = 0
+    for i in range(n, m + n):
+        j = k
+        for c in q.coeff:
+            S[j, i] = c
+            j += 1
+        k = k + 1
+    return S
+
+def resultant(p: "Poly", q: "Poly") -> int:
+    "Resultant of the given polynomials."
+    return sylvester(p,q).det()

{kryptools-1.9.2 → kryptools-1.9.4}/kryptools.egg-info/PKG-INFO

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

{kryptools-1.9.2 → kryptools-1.9.4}/pyproject.toml

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