kryptools 0.5__tar.gz → 0.7__tar.gz

{kryptools-0.5 → kryptools-0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.5
+Version: 0.7
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 Project-URL: Homepage, https://github.com/teschlg/kryptools

{kryptools-0.5 → kryptools-0.7}/kryptools/Zmod.py

@@ -106,6 +106,9 @@ class ZmodPoint:
     def __neg__(self) -> "ZmodPoint":
         return self.__class__(-self.x, self.ring)
 
+    def __pos__(self) -> "ZmodPoint":
+        return self
+
     def __sub__(self, other: "ZmodPoint") -> "ZmodPoint":
         if isinstance(other, self.__class__):
             if self.ring != other.ring:
@@ -151,6 +154,9 @@ class ZmodPoint:
             return self.__class__(pow(self.x, scalar, self.ring.n), self.ring)
         return NotImplemented
 
+    def __abs__(self) -> int:
+        return abs(self.sharp())
+
     def sharp(self):
         "Returns a symmetric (w.r.t. 0) representative."
         tmp = (self.ring.n - 1) // 2

{kryptools-0.5 → kryptools-0.7}/kryptools/__init__.py

@@ -8,6 +8,6 @@ from .factor import factorint
 from .dlp import dlog
 from .ec import EC_Weierstrass
 from .la import Matrix, zeros, eye
-from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_plane_cvp, lagrange_lr, lll, random_unimodular_matrix
+from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_round_bnd, babai_plane_cvp, babai_plane_bnd, lagrange_lr, lll, random_unimodular_matrix
 from .poly import Poly
 from .Zmod import Zmod

{kryptools-0.5 → kryptools-0.7}/kryptools/la.py

@@ -4,7 +4,7 @@ Linear algebra
 
 from math import inf, sqrt, prod
 from numbers import Number
-
+from fractions import Fraction
 
 class Matrix:
     """
@@ -99,12 +99,12 @@ class Matrix:
         return self.matrix == other.matrix
 
     def map(self, func):
-        "Apply a function to all elements in place"
+        "Apply a function to all elements in place."
         for row in self.matrix:
             row[:] = map(func, row)
 
     def applyfunc(self, func):
-        "Apply a function to all elements"
+        "Apply a function to all elements."
         tmp = self[:,:]
         tmp.map(func)
         return tmp
@@ -148,6 +148,8 @@ class Matrix:
             for j in range(other.cols):
                 for k in range(other.rows):
                     result.matrix[i][j] += self.matrix[i][k] * other.matrix[k][j]
+        if self.rows == 1 and other.cols == 1:
+            return result.matrix[0][0]
         return result
 
     def __add__(self, other) -> "Matrix":
@@ -176,7 +178,7 @@ class Matrix:
 
     def __rmul__(self, other) -> "Matrix":
         if isinstance(other, Number) or type(other) == type(self.matrix[0][0]):
-             return Matrix([ [item * other for item in row] for row in self.matrix ])
+            return Matrix([ [item * other for item in row] for row in self.matrix ])
         return NotImplemented
 
     def rref(self) -> "Matrix":
@@ -246,6 +248,16 @@ class Matrix:
             raise ValueError("Matrix is not invertible!")
         return MM[:,n:]
 
+    def is_unimodular(self) -> bool:
+        "Test if the matrix is unimodular."
+        if self.rows != self.rows:
+            return False
+        def is_integer(i):
+            if isinstance(i, int) or (isinstance(i, Fraction) and i.denominator == 1):
+                return True
+            return False
+        return all([is_integer(i) for i in self]) and self.det()**2 == 1
+
     def zeros(self, m: int = None, n: int = None):
         "Returns a zero matrix of the same dimension"
         if not m and not n:

{kryptools-0.5 → kryptools-0.7}/kryptools/lat.py

@@ -2,7 +2,7 @@
 Lattice tools
 """
 
-from math import prod
+from math import prod, floor
 from fractions import Fraction
 from random import choice, sample
 from .la import Matrix, zeros
@@ -73,19 +73,28 @@ def hadamard_ratio(M: Matrix) -> float:
     return (gram_det(M) / prod([M[:, i].norm() for i in range(m)])) ** (1 / m)
 
 def babai_round_cvp(x: Matrix, U: Matrix) -> Matrix:
-    "Babai's rounding algorithm for solving the CVP."
+    "Babai's rounding algorithm for approximately solving the CVP."
     s = U.inv() * x
     k = s.applyfunc(round)
     return U * k
 
+def babai_round_bnd(U: Matrix) -> float:
+    "Bound for Babai's rounding algorithm for solving the CVP."
+    return floor(1 / (2 * max([ U.inv()[i,:].norm(1) for i in range(U.rows)])))
+
 def babai_plane_cvp(x: Matrix, U: Matrix) -> Matrix:
-    "Babai's closest plane algorithm for solving the CVP."
+    "Babai's closest plane algorithm for approximately solving the CVP."
     Us = gram_schmidt(U)[0]
     y = x
     for k in range(U.cols - 1, -1, -1):
         y = y - round(y.dot(Us[:, k]) / norm2(Us[:, k])) * U[:, k]
     return (x - y).applyfunc(round)
 
+def babai_plane_bnd(U: Matrix, p = 2) -> float:
+    "Bound for Babai's closest plane algorithm for solving the CVP."
+    Us = gram_schmidt(U)[0]
+    return float(0.5 * min([Us[:, i].norm(p) for i in range(Us.rows)]))
+
 def lagrange_lr(V: Matrix) -> Matrix:
     "Lagrange lattice reduction."
     assert (V.rows, V.cols) == (2, 2)
@@ -99,7 +108,7 @@ def lagrange_lr(V: Matrix) -> Matrix:
     return Matrix([list(v1), list(v3)]).transpose()
 
 def lll(V: Matrix, delta: float = 0.75, sort: bool = True) -> Matrix:
-    "lll algorithm for lattice reduction"
+    "LLL algorithm for lattice reduction."
 
     assert 0 < delta <= 1, f"LLL reqires 0 < delta={delta} <= 1"
     j = 1

{kryptools-0.5 → kryptools-0.7}/kryptools/poly.py

@@ -16,11 +16,11 @@ class Poly:
     """
 
     def __init__(self, coeff: list, ring = None, modulus: list = None):
-        for i in range(len(coeff) - 1, 0, -1):
-            if coeff[i]:
+        self.coeff = list(coeff)
+        for i in range(len(self.coeff) - 1, 0, -1):
+            if self.coeff[i]:
                 break
-            coeff.pop(i)
-        self.coeff = coeff
+            self.coeff.pop(i)
         self.modulus = modulus
         if ring:
             self.map(ring)
@@ -86,18 +86,25 @@ class Poly:
     def __bool__(self):
         return bool(self.degree()) or bool(self.coeff[0])
 
-    def degree(self):
+    def degree(self) -> int:
         "Return the degree."
         return len(self.coeff) - 1
 
     def map(self, func):
-        "Apply a given function to all coefficients."
+        "Apply a given function to all coefficients in place."
         self.coeff = list(map(func, self.coeff))
 
+    def applyfunc(self, func) -> "Poly":
+        "Apply a function to all coefficients."
+        return self.__class__(list(map(func, self.coeff)), modulus=self.modulus)
+
+    def _check_type(self, other):
+        return isinstance(other, int) or (isinstance(other, Number) and isinstance(self.coeff[0], Number)) or type(other) == type(self.coeff[0])
+
     def __add__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            tmp = self.coeff[:]
-            if isinstance(other, int) or type(other) == type(tmp[0]):
+            if self._check_type(other):
+                tmp = self.coeff[:]
                 tmp[0] += other
                 return self.__class__(tmp, modulus=self.modulus)
             return NotImplemented
@@ -117,7 +124,7 @@ class Poly:
 
     def __radd__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            if isinstance(other, Number) or type(other) == type(self.coeff[0]):
+            if self._check_type(other):
                 tmp = self.coeff[:]
                 tmp[0] += other
                 return self.__class__(tmp, modulus=self.modulus)
@@ -126,9 +133,12 @@ class Poly:
     def __neg__(self) -> "Poly":
         return Poly([-s for s in self.coeff], modulus=self.modulus)
 
+    def __pos__(self) -> "Poly":
+        return self
+
     def __sub__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            if isinstance(other, int) or type(other) == type(self.coeff[0]):
+            if self._check_type(other):
                 tmp = self.coeff[:]
                 tmp[0] -= other
                 return self.__class__(tmp, modulus=self.modulus)
@@ -149,7 +159,7 @@ class Poly:
 
     def __rsub__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            if isinstance(other, int) or type(other) == type(self.coeff[0]):
+            if self._check_type(other):
                 tmp = self.coeff[:]
                 tmp[0] -= other
                 return self.__class__(tmp, modulus=self.modulus)
@@ -157,7 +167,7 @@ class Poly:
 
     def __mul__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            if isinstance(other, int) or type(other) == type(self.coeff[0]):
+            if self._check_type(other):
                 return Poly([other * s for s in self.coeff], modulus = self.modulus)
             return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
@@ -174,11 +184,25 @@ class Poly:
             modulus = other.modulus
         return self.__class__(coeff, modulus = modulus)
 
-    def __rmul__(self, other: int) -> "Poly":
-        if isinstance(other, int) or type(other) == type(self.coeff[0]):
+    def __rmul__(self, other) -> "Poly":
+        if self._check_type(other):
             return self.__class__([other * s for s in self.coeff], modulus=self.modulus)
         return NotImplemented
 
+    def __truediv__(self, other) -> "Poly":
+        if self._check_type(other):
+            return self.__class__([s / other for s in self.coeff], modulus=self.modulus)
+        if isinstance(other, self.__class__):
+            if not other.modulus:
+                raise NotImplementedError("Cannot invert polynomials without modulus.")
+            return self * other.inv()
+        return NotImplemented
+
+    def __rtruediv__(self, other) -> "Poly":
+        if not self.modulus:
+            raise NotImplementedError("Cannot invert polynomials without modulus.")
+        return other * self.inv()
+
     def __pow__(self, i: int) -> "Poly":
         if not isinstance(i, int):
             return NotImplemented
@@ -196,6 +220,14 @@ class Poly:
             res *= tmp
         return res
 
+    def max(self) -> int:
+        "Maximum of the absolute value of all coefficients."
+        return max([abs(c) for c in self.coeff])
+
+    def sum(self) -> int:
+        "Sum of the absolute value of all coefficients."
+        return sum([abs(c) for c in self.coeff])
+
     def __floordiv__(self, other: "Poly") -> "Poly":
         return self.divmod(other)[0]
 

{kryptools-0.5 → kryptools-0.7}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.5
+Version: 0.7
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 Project-URL: Homepage, https://github.com/teschlg/kryptools

{kryptools-0.5 → kryptools-0.7}/pyproject.toml

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