kryptools 0.9.1__tar.gz → 0.9.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.1
+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.1 → 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 .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
+from .factor import factorint, divisors
 from .dlp import dlog
 from .ec import EC_Weierstrass
 from .la import Matrix, zeros, eye

{kryptools-0.9.1 → 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.1 → kryptools-0.9.2}/kryptools/lat.py

@@ -81,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:
@@ -93,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.1 → 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.1 → kryptools-0.9.2}/kryptools.egg-info/PKG-INFO

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

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