kryptools 0.9__tar.gz → 0.9.2__tar.gz

{kryptools-0.9 → kryptools-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9
+Version: 0.9.2
 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.9 → kryptools-0.9.2}/kryptools/__init__.py

@@ -2,9 +2,9 @@
 Implemenation of same basic algorithms used in cryptography.
 """
 
-from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, order, crt
-from .primes import sieve_eratosthenes, is_prime, next_prime, random_prime, random_strongprime, is_safeprime, random_safeprime
-from .factor import factorint
+from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, order, crt
+from .primes import sieve_eratosthenes, is_prime, next_prime, previous_prime, random_prime, random_strongprime, is_safeprime, random_safeprime
+from .factor import factorint, divisors
 from .dlp import dlog
 from .ec import EC_Weierstrass
 from .la import Matrix, zeros, eye

{kryptools-0.9 → kryptools-0.9.2}/kryptools/factor.py

@@ -1,9 +1,10 @@
 """
 Factorization of integers:
     factorint(n) factorize the integer n into prime factors
+    divisors(n) unsorted list of all divisors of the integer n
 """
 
-from math import isqrt, gcd
+from math import isqrt, gcd, prod
 from .primes import sieve_eratosthenes, is_prime
 from .factor_pm1 import _pm1_parameters, factor_pm1
 from .factor_ecm import _ecm_parameters, factor_ecm
@@ -13,7 +14,6 @@ from .factor_ecm import _ecm_parameters, factor_ecm
 # Factoring
 
 
-
 def _factor_fermat(n: int, steps: int = 10) -> list:
     "Fermat method"
     parameters = {11: (12, 6), 23: (12, 0),
@@ -29,12 +29,12 @@ def _factor_fermat(n: int, steps: int = 10) -> list:
             return a - b
 
 def factorint(n: int, verbose: int = 0) -> dict:
-    "Factor a the ineger `n`."
+    "Factor an ineger `n` into prime factors."
     prime_factors = {}
     if not isinstance(n, int):
         raise ValueError("Number to be factored must be an integer!")
     if n == 0:
-        return prime_factors
+        return {0: 1}
     if n < 0:
         n *= -1
         prime_factors[-1] = 1
@@ -140,3 +140,34 @@ def factorint(n: int, verbose: int = 0) -> dict:
             return prime_factors
 
     raise ValueError("Incomplete factorization:", prime_factors, remaining_factors, new_factors)
+
+# Divisors
+
+def divisors(n:int, proper:bool = False) -> int:
+    """Returns an unsorted list of all divisors of an integer `n`."""
+    facctordict= factorint(n)
+    primes = [p for p in facctordict]
+    nprimes = len(primes)
+    multiplicites = [facctordict[p] for p in primes]
+
+    exponents = [0] * nprimes
+    if proper:
+        divisors = []
+    else:
+        divisors = [1]
+    i = 0
+    while True:
+        exponents[i] += 1
+        if exponents[i] > multiplicites[i]:
+            while exponents[i] > multiplicites[i]:
+                exponents[i] = 0
+                i += 1
+                exponents[i] += 1
+            i = 0
+        d = prod(primes[i] ** exponents[i] for i in range(nprimes))
+        if d == n:
+            if proper:
+                return divisors
+            divisors.append(n)
+            return divisors
+        divisors.append(d)

{kryptools-0.9 → kryptools-0.9.2}/kryptools/la.py

@@ -211,7 +211,7 @@ class Matrix:
 
     def det(self) -> int:
         "Compute the determinant of a matrix M."
-        if self.rows != self.rows:
+        if self.rows != self.cols:
             raise ValueError("Matrix must be square!")
         n, m = self.cols, self.rows
         R = self[:, :]
@@ -239,7 +239,7 @@ class Matrix:
 
     def inv(self) -> "Matrix":
         "Compute the inverse of a square matrix M."
-        if self.rows != self.rows:
+        if self.rows != self.cols:
             raise ValueError("Matrix must be square!")
         n = self.cols
         MM = Matrix([[0 for _ in range(2*n)] for _ in range(n)])
@@ -253,7 +253,7 @@ class Matrix:
 
     def is_unimodular(self) -> bool:
         "Test if the matrix is unimodular."
-        if self.rows != self.rows:
+        if self.rows != self.cols:
             return False
         def is_integer(i):
             if isinstance(i, int) or (isinstance(i, Fraction) and i.denominator == 1):
@@ -262,7 +262,7 @@ class Matrix:
         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"
+        "Returns a zero matrix of the same dimension."
         if not m and not n:
             n, m = self.cols, self.rows
         elif not n:
@@ -274,7 +274,7 @@ class Matrix:
         return Matrix([[ zero for j in range(n) ] for i in range(m) ])
 
     def eye(self, m: int = None, n: int = None):
-        "Returns an identity matrix of the same dimension"
+        "Returns an identity matrix of the same dimension."
         def delta(i, j):
             if i == j:
                 return one
@@ -292,13 +292,13 @@ class Matrix:
 
 
 def zeros(m: int, n: int = None, zero = 0) -> "Matrix":
-    "Returns a zero matrix of the given dimension"
+    "Returns a zero matrix of the given dimension."
     if not n:
         n = m
     return Matrix([[ zero for j in range(n) ] for i in range(m) ])
 
 def eye(m:int, n: int = None) -> "Matrix":
-    "Returns an identity matrix of the given dimension"
+    "Returns an identity matrix of the given dimension."
     def delta(i, j):
         if i == j:
             return 1

{kryptools-0.9 → kryptools-0.9.2}/kryptools/lat.py

@@ -42,6 +42,8 @@ def hermite_nf(M: Matrix) -> Matrix:
             H[:, jj] -= tmp * H[:, j]
         #print(H)
         j -= 1
+        if j < 0:
+            break
     while H.cols> 1 and all(not H[i, 0] for i in range(m)): # remove zero columns
         H = H[:,1:]
     return H
@@ -79,7 +81,7 @@ def babai_round_cvp(x: Matrix, U: Matrix) -> Matrix:
     return U * k
 
 def babai_round_bnd(U: Matrix) -> float:
-    "Bound for Babai's rounding algorithm for solving the CVP."
+    "Bound for Babai's rounding algorithm for solving the CVPwith respect to the sup norm."
     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:
@@ -91,7 +93,7 @@ def babai_plane_cvp(x: Matrix, U: Matrix) -> Matrix:
     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."
+    "Bound for Babai's closest plane algorithm for solving the CVP with respect to the Euclidean norm (p=2) or sup norm (p=inf)."
     Us = gram_schmidt(U)[0]
     return float(0.5 * min([Us[:, i].norm(p) for i in range(Us.rows)]))
 

{kryptools-0.9 → kryptools-0.9.2}/kryptools/nt.py

@@ -8,6 +8,7 @@ Number theory tools:
     sqrt_mod(n, p) square root of n modulo a prime p
     euler_phi(n) Euler phi function of n
     carmichael_lambda(n) Carmichael lambda function of n
+    moebius_mu(n) Moebius function of n
     order(a, n) oder of a in the multiplicative group Z_n^*
     crt([a1, a2, ...],[m1, m2, ...]) Chinese Remainder Theorem
 """
@@ -99,7 +100,7 @@ def jacobi_symbol(a: int, n: int) -> int:
     return 0
 
 def sqrt_mod(a: int, p: int) -> int:
-    "Compute a square root of `a` modulo `p` unsing Cipolla's algorithm."
+    """Compute a square root of `a` modulo `p` unsing Cipolla's algorithm."""
     a %= p
     if a == 0 or a == 1:
         return a
@@ -125,19 +126,23 @@ def sqrt_mod(a: int, p: int) -> int:
         i = i >> 1  # i= i/2
     return y1
 
-# Euler phi and Carmichael function
+# Euler phi, Carmichael function, Moebius function
 
 from .factor import factorint
 
 
 def euler_phi(n: int) -> int:
     """Euler's phi function of `n`."""
+    if not isinstance(n, int) or n < 1:
+        raise ValueError(f"{n} is not a positive integer")
     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`."""
+    if not isinstance(n, int) or n < 1:
+        raise ValueError(f"{n} is not a positive integer")
     k = factorint(n)
     lam_all = []  # values corresponding to the prime factors
     for p in k:
@@ -150,12 +155,26 @@ def carmichael_lambda(n: int) -> int:
         lam = lcm(lam, l)
     return lam
 
+def moebius_mu(n: int) -> int:
+    """Moebius' mu function of `n`."""
+    if not isinstance(n, int) or n < 0:
+        raise ValueError(f"{n} is not a nonegative integer")
+    if n == 0:
+        return 0
+    factors = factorint(n)
+    if any(i > 1 for i in factors.values()):
+        return 0
+    if len(factors) % 2 == 1:
+        return -1
+    return 1
+
 # 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!"
+    if a == 0 or gcd(a, n) != 1:
+        raise ValueError(f"{a} and {n} are not coprime!")
     factors = {}  # 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

{kryptools-0.9 → kryptools-0.9.2}/kryptools/primes.py

@@ -3,6 +3,7 @@ Tools for prime numbers:
     sieve_eratosthenes(B) a tuple of all primes up to including B
     is_prime(n) test if n is probably prime
     next_prime(n) find the next prime larger or equal n
+    previous_prime(n) find the previous prime smaller or equal n
     random_prime(l) find a pseudorandom prime with bit length at least l
     random_strongprime(l) find a pseudorandom strong prime with bit length at least l
     is_safeprime(n) test if n is a safe prime
@@ -17,14 +18,14 @@ from .nt import jacobi_symbol
 
 def sieve_eratosthenes(B: int) -> tuple:
     """Returns a tuple of all primes up to (including) `B`."""
-    B1 = (isqrt(B) -1)//2
+    B1 = (isqrt(B) - 1)//2
     B = (B - 1)//2
-    isprime = [True] * (B + 1)  # to begin with, all numbers are potentially prime
-    # sieve out the primes p=2*q+1 starting at 3 in steps of 2 (ignoring even numbers)
+    isprime = [True] * (B + 1)  # to begin with, all odd numbers are potentially prime
+    # sieve out the primes p=2*q+1 starting at q = 1
     for q in range(1, B1 + 1):
-        if isprime[q]: # sieve out all multiples; numbers p*q with q<p were already sieved out previously
-            qq = (q << 1) * (q + 1)
-            p = (q << 1) | 1
+        if isprime[q]: # sieve out all multiples; numbers p*r with r<p were already sieved out previously
+            qq = 2 * q * (q + 1)
+            p = 2 * q + 1
             isprime[qq :: p] = [False] * ((B - qq) // p + 1)
 
     return tuple([2] + [2 * q + 1 for q in range(1, B + 1) if isprime[q]])
@@ -67,11 +68,22 @@ def is_prime(n: int) -> bool:
 
 def next_prime(n: int) -> int:
     """Find the next prime larger or equal `n`."""
+    if n < 3:
+        return 2
     n |= 1  # make sure n is odd
     while not is_prime(n):
         n += 2
     return n
 
+def previous_prime(n: int) -> int:
+    """Find the previous prime smaller or equal `n`."""
+    if n < 3:
+        return 2
+    n += (n & 1) - 1  # make sure n is odd
+    while not is_prime(n):
+        n -= 2
+    return n
+
 def random_prime(l: int) -> int:
     """Find a pseudorandom prime with bit length at least `l`."""
     return next_prime(randint(2 ** (l - 1), 2**l - 1))

{kryptools-0.9 → kryptools-0.9.2}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9
+Version: 0.9.2
 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.9 → kryptools-0.9.2}/pyproject.toml

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