kryptools 0.1__py3-none-any.whl

kryptools/lat.py

@@ -0,0 +1,168 @@
+"""
+Lattice tools
+"""
+
+from math import prod
+from fractions import Fraction
+from .la import Matrix, zeros, eye
+
+def babai_round_cvp(x: Matrix, U: Matrix) -> Matrix:
+    "Babai's rounding algorithm for solving the CVP."
+    s = U.inv() * x
+    k = s.map(round)
+    return U * k
+
+def hermite_nf(M: Matrix) -> Matrix:
+    "Compute the Hermite normal form of a matrix M."
+    n, m = M.cols, M.rows
+    H = M[:, :]
+    j = n - 1
+    for i in reversed(range(m)):
+        j0 = j
+        minimum = abs(H[i, j])  # search for the pivot in the present row
+        for jj in range(j):
+            tmp = abs(H[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[:, j], H[:, j0] = (
+                H[:, j0],
+                H[:, j],
+            )  # swap columns, to move the pivot in place
+        if H[i, j] < 0:
+            H[:, j] *= -1  # make the pivot positive
+        jj = j - 1
+        while jj >= 0:  # make the row entries left to the pivot zero
+            tmp = H[i, jj] // H[i, j]
+            H[:, jj] -= tmp * H[:, j]
+            if H[i, jj]:
+                H[:, j], H[:, jj] = H[:, jj], H[:, j]  # swap columns
+            else:
+                jj -= 1
+        for jj in range(j + 1, n):  # reduce the row entries right to the pivot
+            tmp = H[i, jj] // H[i, j]
+            H[:, jj] -= tmp * H[:, j]
+        #print(H)
+        j -= 1
+    while H.cols> 1 and all(not H[i, 0] for i in range(m)): # remove zero columns
+        H = H[:,1:]
+    return H
+
+def norm2(v: Matrix) -> float:
+    "Square of the Euclidean norm of a vector v."
+    return sum(map(lambda x: x * x, v))
+
+def gram_schmidt(U: Matrix) -> (Matrix, Matrix):
+    "Compute the Gram-Schmidt orthogonalization of the column vectors of a matrix M."
+    M = eye(U.cols, U.rows)
+    Us = U[:, :]
+    for j in range(1, U.rows):
+        tmp = U[:, j]
+        for i in range(j):
+            M[i, j] = U[:, j].dot(Us[:, i]) / norm2(Us[:, i])
+            tmp -= M[i, j] * Us[:, i]
+        Us[:, j] = tmp
+    return Us, M
+
+def gram_det(U: Matrix) -> float:
+    Us = gram_schmidt(U)[0]
+    return prod([Us[:, i].norm() for i in range(U.rows)])
+
+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 babai_plane_cvp(x: Matrix, U: Matrix) -> Matrix:
+    "Babai's closest plane algorithm for 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 lll(V: Matrix, delta: float = 0.75, sort: bool = True) -> Matrix:
+    "lll algorithm for lattice reduction"
+
+    assert 0 < delta <= 1, f"LLL reqires 0 < delta={delta} <= 1"
+    j = 1
+    U = V[:, :]
+    Us = U[:, :]
+    Us.map(Fraction)
+    M = zeros(U.cols, U.rows)
+    M.map(Fraction)
+    M[0, 0] = norm2(Us[:, 0])  # we store the squared norms on the diagonal
+    for l in range(1, U.rows):  # Gram-Schmidt decomposition
+        tmp = U[:, l]
+        for i in range(l):
+            M[i, l] = U[:, l].dot(Us[:, i]) / M[i, i]
+            tmp -= M[i, l] * Us[:, i]
+        Us[:, l] = tmp
+        M[l, l] = norm2(Us[:, l])
+
+    while j < U.rows:
+        for i in range(j - 1, -1, -1):  # reduce the weights of the basis vectors
+            r = round(M[i, j])
+            if r:
+                U[:, j] -= r * U[:, i]
+                for k in range(j):
+                    if k == i:
+                        M[k, j] -= r
+                    else:
+                        M[k, j] -= r * M[k, i]
+
+        newM11 = M[j, j] + M[j - 1, j] ** 2 * M[j - 1, j - 1]
+        if (delta * M[j - 1, j - 1] <= newM11):  # Lovasz condition
+            j += 1
+            continue  # nothing to be done
+        # else swap vectors
+        U[:, j], U[:, j - 1] = U[:, j - 1], U[:, j]
+        # update the Gram-Schmidt decomposition
+        oldM11 = M[j - 1, j - 1]
+        oldM10 = M[j - 1, j]
+        oldM00 = M[j, j]
+        oldUs = Us[:, j - 1]
+        Us[:, j - 1] = Us[:, j] + M[j - 1, j] * Us[:, j - 1]
+        M[j - 1, j - 1] = newM11
+        M[j - 1, j] *= oldM11 / M[j - 1, j - 1]
+        Us[:, j] = oldUs - M[j - 1, j] * Us[:, j - 1]
+        M[j, j] = oldM11 - M[j - 1, j] ** 2 * M[j - 1, j - 1]
+        for l in range(j - 1):
+            M[l, j], M[l, j - 1] = M[l, j - 1], M[l, j]
+        tmp1 = oldM00 / M[j - 1, j - 1]
+        tmp2 = oldM10 * oldM11 / M[j - 1, j - 1]
+        for l in range(j + 1, U.rows):
+            M[j - 1, l], M[j, l] = (
+                tmp1 * M[j, l] + tmp2 * M[j - 1, l],
+                M[j - 1, l] - oldM10 * M[j, l],
+            )
+        j = max(j - 1, 1)  # redo the last step
+
+    if sort:  # sort the vectors according to their norm
+        tmp = [U[:, j] for j in range(U.rows)]
+        tmp.sort(key=norm2)
+        for j in range(U.rows):
+            U[:, j] = tmp[j]
+    return U
+
+from random import choice, sample
+
+def random_unimodular_matrix(n: int, iterations: int = 50, max_val: int = 9) -> Matrix:
+    "Create a random unimodular matrix of dimension n."
+    W = Matrix.zeros(n, n)
+    for i in range(n):
+        for j in range(i, n):
+            W[i, j] = choice([-1, 1])
+    W = W[sample(range(n), n), sample(range(n), n)]
+    for _ in range(iterations):
+        i, j = sample(range(n), 2)
+        tmp = W[i, :] + choice([-1, 1]) * W[j, :]
+        if max([abs(x) for x in tmp]) <= max_val:
+            W[i, :] = tmp
+        i, j = sample(range(n), 2)
+        tmp = W[:, i] + choice([-1, 1]) * W[:, j]
+        if max([abs(x) for x in tmp]) <= max_val:
+            W[:, i] = tmp
+    return W

kryptools/nt.py

@@ -0,0 +1,271 @@
+"""
+Number theory tools:
+    lcm(a, b) least common mutiple of a and b
+    egcd(a,b) extended Euclidean agorithm
+    crt([a1, a2, ...],[m1, m2, ...]) Chinese Remainder Theorem
+    cf(Fraction(m,n)) continued fraction expansions
+    convergents() convergents of a continued fraction
+    sqrt_mod(n, p) square root of n modulo a prime p
+    order(a, n) oder of a in the multiplicative group Z_n^*
+"""
+from math import gcd, prod
+from fractions import Fraction
+from .factor import factorint
+
+# Euclid and friends
+
+def lcm(a: int, b: int) -> int:
+    """Compute the least common multiple of a and b."""
+    if b == 0:
+        return 0
+    if bool(a > 0) != bool(b > 0):
+        a = -a
+    return (a // gcd(a, b)) * b
+
+
+def egcd(a: int, b: int) -> (int, int, int):
+    """Perform the extended Euclidean agorithm. Returns gcd, x, y such that a x + b y = gcd."""
+    r0, r1 = a, b
+    x0, x1, y0, y1 = 1, 0, 0, 1
+    while r1 != 0:
+        q, r = divmod(r0, r1)
+        r0, r1 = r1, r
+        x0, x1 = x1, x0 - q * x1
+        y0, y1 = y1, y0 - q * y1
+    return r0, x0, y0
+
+
+# Chinese remainder theorem
+
+def crt(a: list, m: list) -> int:
+    """Solve given linear congruences x[j] % m[j] == a[j] using the Chinese Remainder Theorem."""
+    l = len(a)
+    assert len(m) == l, "The lists of numbers and modules must have equal length."
+    M = prod(m)
+    Mi = [M // m[i] for i in range(l)]
+    MNi = [Mi[i] * pow(Mi[i], -1, m[i]) % M for i in range(l)]
+    return sum([a[i] * MNi[i] % M for i in range(l)]) % M
+
+# Continued fractions
+
+# class Fraction:
+#     "Rationl number"
+#
+#     def __init__(self, numerator: int, denominator: int = 1):
+#         assert denominator, "Denominator must be nozero."
+#         tmp = gcd(denominator, numerator)
+#         if tmp != 1:
+#             denominator //= tmp
+#             numerator //= tmp
+#         self.numerator = numerator
+#         self.denominator = denominator
+#
+#     def __repr__(self):
+#         if self.denominator == 1:
+#             return str(self.numerator)
+#         else:
+#             return str(self.numerator) + "/" + str(self.denominator)
+#
+#     def __eq__(self, other):
+#         if not isinstance(other, self.__class__):
+#             return False
+#         return self.denominator == other.denominator and self.numerator == other.numerator
+#
+#     def __bool__(self):
+#         return self.numerator != 0
+#
+#     def __add__(self, other: "Fraction") -> "Fraction":
+#         if isinstance(other, self.__class__):
+#             return Rational(self.numerator * other.denominator + other.numerator * self.denominator, self.denominator * other.denominator)
+#         if isinstance(other, int):
+#             return Rational(self.numerator + other * self.denominator, self.denominator)
+#         raise ValueError(f"Cannot add {self} and {other}.")
+#
+#     def __neg__(self) -> "Fraction":
+#         return Rational(- self.numerator, self.denominator)
+#
+#     def __sub__(self, other: "Fraction") -> "Fraction":
+#         if isinstance(other, self.__class__):
+#             return Rational(self.numerator * other.denominator - other.numerator * self.denominator, self.denominator * other.denominator)
+#         if isinstance(other, int):
+#             return Rational(self.numerator - other * self.denominator, self.denominator)
+#         raise ValueError(f"Cannot subtract {self} and {other}.")
+#
+#     def __mul__(self, other: "Fraction") -> "Fraction":
+#         if isinstance(other, self.__class__):
+#             return Rational(self.numerator * other.numerator, self.denominator * other.denominator)
+#         if isinstance(other, int):
+#             return Rational(self.numerator * other, self.denominator)
+#         raise ValueError(f"Cannot multiply {self} and {other}.")
+#
+#     def __rmul__(self, other: int) -> "Fraction":
+#         return Rational(self.denominator * other, self.numerator)
+#
+#     def __truediv__(self, other: "Fraction") -> "Fraction":
+#         if isinstance(other, self.__class__):
+#             return Rational(self.numerator * other.denominator, self.denominator * other.numerator)
+#         if isinstance(other, int):
+#             return Rational(self.numerator, self.denominator * other)
+#         raise ValueError(f"Cannot divide {self} and {other}.")
+#
+#     def __pow__(self, scalar: int) -> "Fraction":
+#         return Rational(self.numerator**scalar, self.denominator**scalar)
+
+
+def fraction_repr(self):
+    if self.denominator == 1:
+        return str(self.numerator)
+    else:
+        return str(self.numerator) + "/" + str(self.denominator)
+
+Fraction.__repr__ = fraction_repr
+
+
+def cf(x: Fraction) -> list[int]:
+    "Compute the continued fraction expansion of the rational number m/n."
+    res = []
+    m = x.numerator
+    n = x.denominator
+    while True:
+        d, m = divmod(m, n)
+        res.append(d)
+        if not m:
+            return res
+        m, n = n, m
+
+
+def convergents(cont_frac: list[int]) -> float:
+    "Compute the convergents of a continued fraction expansion."
+    res = []
+
+    def recursion(x: int, m: int, mm: int) -> (int, int):
+        return x * m + mm, m
+
+    m, mm = 1, 0
+    n, nn = 0, 1
+    for x in cont_frac:
+        m, mm = recursion(x, m, mm)
+        n, nn = recursion(x, n, nn)
+        res.append(Fraction(m, n))
+    return res
+
+
+# Legendre symbol
+
+def legendre_symbol(a: int, p: int) -> int:
+    """Compute the Legendre symbol of a with respect to the prime p."""
+    a = a % p
+    if a == 0:
+        return 0
+    if pow(a, (p - 1) // 2, p) == 1:
+        return 1
+    return -1
+
+def jacobi_symbol(a: int, n: int) -> int:
+    """Compute the Jacobi symbol of a with respect to the integer n."""
+    # Crandall/Pomerance Algorithm 2.3.5
+    a = a % n
+    t = 1
+    while a:
+        while a % 2 == 0:
+            a //= 2
+            tmp = n % 8
+            if tmp == 3 or tmp == 5:
+                t *= -1
+        a, n = n, a
+        if a % 4 == 3 and n % 4 == 3:
+            t *= -1
+        a %= n
+    if n == 1:
+        return t
+    return 0
+
+def sqrt_mod(a: int, p: int) -> list:
+    "Compute a square root of a modulo p unsing Cipolla's algorithm."
+    a %= p
+    if a == 0 or a == 1:
+        return a
+    if pow(a, (p - 1) // 2, p) != 1:  # Legendre symbol must be equal one
+        return None
+    if p % 4 == 3:  # easy case
+        return pow(a, (p + 1) // 4, p)
+    # Cipolla's algorithm
+    for c in range(1, p):  # find a field extension
+        tmp = (c * c - a) % p
+        if tmp == 0:
+            return c
+        if pow(tmp, (p - 1) // 2, p) == p - 1:
+            break
+    r = (c * c - a) % p
+    i = (p + 1) // 2
+    x1, x2 = c, 1  # compute x^i in Z_p(sqrt(r))
+    y1, y2 = 1, 0
+    while i > 0:
+        if i & 1:  # if i is odd, multiply with x
+            y1, y2 = (x1 * y1 + x2 * y2 * r) % p, (x1 * y2 + x2 * y1) % p
+        x1, x2 = (pow(x1, 2, p) + pow(x2, 2, p) * r) % p, 2 * (x1 * x2) % p  # now square
+        i = i >> 1  # i= i/2
+    return y1
+
+# Euler phi and Carmichael function
+
+from math import prod
+
+
+def euler_phi(n: int) -> int:
+    """Euler's phi function of n."""
+    k = factorint(n)
+    return prod([(p - 1) * p ** (k[p] - 1) for p in k])
+
+
+def carmichael_lambda(n: int) -> int:
+    """Carmichael's lambda function of n."""
+    k = factorint(n)
+    lam_all = []  # values corresponding to the prime factors
+    for p in k:
+        lam = (p - 1) * p ** (k[p] - 1)
+        if p == 2 and k[p] > 2:
+            lam = lam // 2
+        lam_all += [lam]
+    lam = lam_all[0]  # now take the least common multiple of all values
+    for l in lam_all[1:]:
+        lam = lcm(lam, l)
+    return lam
+
+# Order in Z_p^*
+
+def order(a: int, n: int, factor=False) -> int:
+    """Compute the order of a in the group Z_n^*."""
+    a %= n
+    assert a != 0 and gcd(a, n) == 1, f"{a} and {n} are not coprime!"
+    factors = dict()  # We compute euler_phi(n) and its factorization in one pass
+    for p, k in factorint(n).items():  # first factorize n
+        for pm, km in factorint(p - 1).items():  # factor p-1 and add the factors
+            if pm in factors:
+                factors[pm] += km
+            else:
+                factors[pm] = km
+        if k > 1:  # if the multiplicity of of p is >1, then we need to add p**(k-1)
+            if p in factors:
+                factors[p] += k - 1
+            else:
+                factors[p] = k - 1
+    order = 1  # compute the group order euler_phi(n) as our current guess
+    for p, k in factors.items():
+        order *= p**k
+    if factor:  # we compute the factorization of the order along the way
+        factors_order = {}  # factorization of the order
+    for p, k in factors.items():
+        i = 0
+        for _ in range(k):
+            order_try = order // p
+            if pow(a, order_try, n) == 1:
+                order = order_try
+                i += 1
+            else:
+                break
+        if factor and i < k:
+            factors_order[p] = k - i
+    if factor:
+        return order, factors_order
+    return order

kryptools/poly.py

@@ -0,0 +1,232 @@
+"""
+Polynomials
+"""
+
+class Poly:
+    """
+    Represents a polynomial as a list of coefficients.
+    
+    Example:
+    
+    To define a polynomial as alist of coefficients use
+    >>> Poly([1, 2, 3])
+    3 x^2 + 2 x + 1
+    """
+
+    def __init__(self, coeff: list, ring = None, modulus: list = None):
+        for i in range(len(coeff) - 1, 0, -1):
+            if coeff[i]:
+                break
+            coeff.pop(i)
+        self.coeff = coeff
+        self.modulus = modulus
+        if ring:
+            self.map(ring)
+        if modulus:
+            self.mod(modulus)
+
+    def __getitem__(self, item):
+        return self.coeff[item]
+
+    def __repr__(self):
+        def prx(i: int):
+            if i == 0:
+                return ""
+            if i == 1:
+                return "x"
+            return "x^" + str(i)
+
+        if len(self.coeff) == 1:
+            return str(int(self.coeff[0]))
+        plus = ""
+        tmp = ""
+        for i in reversed(range(len(self.coeff))):
+            s = self.coeff[i]
+            if not s:
+                continue
+            if not s - 1 and i != 0:
+                tmp += plus + prx(i)
+                plus = " + "
+                continue
+            try:
+                if s == -1 and i != 0:
+                    if plus:
+                        plus = " "
+                    tmp += plus + "- " + prx(i)
+                    plus = " + "
+                    continue
+            except:
+                pass
+            try:
+                if plus and s < 0:
+                    tmp += " - " + str(-s) + " " + prx(i)
+                    continue
+            except:
+                pass
+            tmp += plus + str(s) + " " + prx(i)
+            plus = " + "
+        return tmp.strip()
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        return self.coeff == other.coeff
+
+    def __bool__(self):
+        return bool(self.degree()) or bool(self.coeff[0])
+
+    def degree(self):
+        return len(self.coeff) - 1
+
+    def map(self, func):
+        self.coeff = list(map(func, self.coeff))
+
+    def __add__(self, other: "Poly") -> "Poly":
+        if not isinstance(other, self.__class__):
+            raise NotImplementedError(f"Cannot add {self} and {other}.")
+        ls, lo = len(self.coeff), len(other.coeff)
+        if ls < lo:
+            scoeff = self.coeff + (lo - ls) * [0]
+        else:
+            scoeff = self.coeff
+        if ls > lo:
+            ocoeff = other.coeff + (ls - lo) * [0]
+        else:
+            ocoeff = other.coeff
+        modulus = self.modulus
+        if not modulus and other.modulus:
+            modulus = other.modulus
+        return self.__class__([s + o for s, o in zip(scoeff, ocoeff)], modulus=modulus)
+
+    def __neg__(self) -> "Poly":
+        return Poly([-s for s in self.coeff], modulus=self.modulus)
+
+    def __sub__(self, other: "Poly") -> "Poly":
+        if not isinstance(other, self.__class__):
+            raise NotImplementedError(f"Cannot subtract {self} and {other}.")
+        ls, lo = len(self.coeff), len(other.coeff)
+        if ls < lo:
+            scoeff = self.coeff + (lo - ls) * [0]
+        else:
+            scoeff = self.coeff
+        if ls > lo:
+            ocoeff = other.coeff + (ls - lo) * [0]
+        else:
+            ocoeff = other.coeff
+        modulus = self.modulus
+        if not modulus and other.modulus:
+            modulus = other.modulus
+        return self.__class__([s - o for s, o in zip(scoeff, ocoeff)], modulus=modulus)
+
+    def __mul__(self, other: "Poly") -> "Poly":
+        if isinstance(other, int):
+            return Poly([other * s for s in self.coeff])
+        if not isinstance(other, self.__class__):
+            raise NotImplementedError(f"Cannot multiply {self} and {other}.")
+        ls, lo = len(self.coeff), len(other.coeff)
+        coeff = [0] * (ls + lo - 1)
+        for k in range(ls + lo - 1):
+            coeff[k] = sum(
+                [
+                    self.coeff[j] * other.coeff[k - j]
+                    for j in range(max(0, k - lo + 1), min(ls, k + 1))
+                ]
+            )
+        modulus = self.modulus
+        if not modulus and other.modulus:
+            modulus = other.modulus
+        return self.__class__(coeff, modulus=modulus)
+
+    def __rmul__(self, other: int) -> "Poly":
+        return self.__class__([other * s for s in self.coeff], modulus=self.modulus)
+
+    def __pow__(self, i: int) -> "Poly":
+        res = self.__class__([1], modulus=self.modulus)
+        if i < 0:
+            if not self.modulus:
+                raise NotImplementedError(f"Cannot divide.")
+            tmp = self.inv()
+        else:
+            tmp = self
+        for _ in range(i):
+            res *= tmp
+        return res
+
+    def divmod(self, other: "Poly") -> ("Poly", "Poly"):
+        if isinstance(other, list):
+            other = self.__class__(other)
+        elif not isinstance(other, self.__class__):
+            raise NotImplementedError(f"Cannot divide {self} and {other}.")
+        if not other:
+            raise ValueError(f"{other} must be nonzero.")
+        sd, od = self.degree(), other.degree()
+        if sd < od:
+            return self.__class__([0]), self
+        div = [0] * (sd - od + 1)
+        lco = other.coeff[-1]
+        if bool(lco - 1):
+            tmp = 1 / lco
+            oth = [c * tmp for c in other.coeff]
+            rem = [c * tmp for c in self.coeff]
+        else:
+            oth = other.coeff
+            rem = [c for c in self.coeff]
+        for i in range(sd - od + 1):
+            tmp = rem[sd - i]
+            div[sd - od - i] = tmp
+            for j in range(od + 1):
+                rem[sd - i - j] -= tmp * oth[od - j]
+        if bool(lco - 1):
+            rem = [c * lco for c in rem]
+        return self.__class__(div, modulus=self.modulus), self.__class__(
+            rem, modulus=self.modulus
+        )
+
+    def mod(self, other: "Poly") -> None:
+        if isinstance(other, list):
+            other = self.__class__(other)
+        elif not isinstance(other, self.__class__):
+            raise NotImplementedError(f"Cannot divide {self} and {other}.")
+        if not other:
+            raise NotImplementedError(f"{other} must be nonzero.")
+        sd, od = self.degree(), other.degree()
+        if sd < od:
+            return self
+        lco = other.coeff[-1]
+        if bool(lco - 1):
+            tmp = 1 / lco
+            oth = [c * tmp for c in other.coeff]
+        else:
+            oth = other.coeff
+        for i in range(sd - od + 1):
+            tmp = self.coeff[sd - i]
+            for j in range(od + 1):
+                self.coeff[sd - i - j] -= tmp * oth[od - j]
+        for i in range(len(self.coeff) - 1, 0, -1):
+            if self.coeff[i]:
+                break
+            self.coeff.pop(i)
+
+    def inv(self, other: "Poly" = None) -> "Poly":
+        if not other:
+            other = self.modulus
+        if isinstance(other, list):
+            other = self.__class__(other)
+        elif not isinstance(other, self.__class__):
+            raise NotImplementedError(f"Cannot invert {self} modulo {other}.")
+        if not other:
+            raise NotImplementedError(f"{other} must be nonzero.")
+        r0, r1 = other, self
+        y0, y1 = self.__class__([0], modulus=self.modulus), self.__class__(
+            [1], modulus=self.modulus
+        )
+        while r1:
+            q, r = r0.divmod(r1)
+            r0, r1 = r1, r
+            y0, y1 = y1, y0 - q * y1
+        if r0.degree() != 0:
+            raise ValueError(f"{self} is not invertible mod {other}.")
+        tmp = 1 / r0[0]
+        for i in range(y0.degree()):
+            y0.coeff[i] *= tmp
+        return y0