pqlattice 0.1.2__py3-none-any.whl

pqlattice/polynomial/_modpolyring.py

@@ -0,0 +1,267 @@
+from ..integer._modring import mod, modinv
+from ..typing import Vector, validate_aliases
+from . import _poly as poly
+
+
+class ModIntPolyRing:
+    def __init__(self, modulus: int):
+        """_summary_
+
+        Parameters
+        ----------
+        modulus : int
+            _description_
+
+        Raises
+        ------
+        ValueError
+            _description_
+        """
+        if modulus <= 1:
+            raise ValueError("Modulus has to be greater than 1")
+
+        self.modulus = modulus
+
+    @validate_aliases
+    def reduce(self, polynomial: Vector) -> Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        return poly.trim(mod(polynomial, self.modulus))
+
+    @validate_aliases
+    def is_zero(self, polynomial: Vector) -> bool:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial : Vector
+            _description_
+
+        Returns
+        -------
+        bool
+            _description_
+        """
+        return poly.is_zero_poly(self.reduce(polynomial))
+
+    @validate_aliases
+    def deg(self, polynomial: Vector) -> int:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial : Vector
+            _description_
+
+        Returns
+        -------
+        int
+            _description_
+        """
+        return poly.deg(self.reduce(polynomial))
+
+    @validate_aliases
+    def add(self, polynomial_a: Vector, polynomial_b: Vector) -> Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial_a : Vector
+            _description_
+        polynomial_b : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        return self.reduce(poly.add(polynomial_a, polynomial_b))
+
+    @validate_aliases
+    def sub(self, polynomial_a: Vector, polynomial_b: Vector) -> Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial_a : Vector
+            _description_
+        polynomial_b : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        return self.reduce(poly.sub(polynomial_a, polynomial_b))
+
+    @validate_aliases
+    def mul(self, polynomial_a: Vector, polynomial_b: Vector) -> Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial_a : Vector
+            _description_
+        polynomial_b : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        return self.reduce(poly.mul(polynomial_a, polynomial_b))
+
+    @validate_aliases
+    def euclidean_div(self, polynomial_a: Vector, polynomial_b: Vector) -> tuple[Vector, Vector]:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial_a : Vector
+            _description_
+        polynomial_b : Vector
+            _description_
+
+        Returns
+        -------
+        tuple[Vector, Vector]
+            _description_
+
+        Raises
+        ------
+        ZeroDivisionError
+            _description_
+        """
+        if self.is_zero(polynomial_b):
+            raise ZeroDivisionError("Can't divide by zero polynomial")
+
+        q = poly.zero_poly()
+        r = self.reduce(polynomial_a)
+
+        d = self.deg(polynomial_b)
+        c: int = polynomial_b[d]
+        while (dr := self.deg(r)) >= d:
+            s = poly.monomial(r[dr] * modinv(c, self.modulus), dr - d)
+            q = self.add(q, s)
+            r = self.sub(r, self.mul(s, polynomial_b))
+
+        return q, r
+
+    @validate_aliases
+    def rem(self, polynomial_a: Vector, polynomial_b: Vector) -> Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial_a : Vector
+            _description_
+        polynomial_b : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        _, r = self.euclidean_div(polynomial_a, polynomial_b)
+        return r
+
+    def to_monic(self, polynomial: Vector) -> Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        leading_coeff: int = polynomial[self.deg(polynomial)]
+        return self.reduce(modinv(leading_coeff, self.modulus) * polynomial)
+
+    def gcd(self, polynomial_a: Vector, polynomial_b: Vector) -> Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial_a : Vector
+            _description_
+        polynomial_b : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        r0 = self.reduce(polynomial_a)
+        r1 = self.reduce(polynomial_b)
+        if poly.deg(r1) > poly.deg(r0):
+            r0, r1 = r1, r0
+
+        while not self.is_zero(r1):
+            r0, r1 = r1, self.rem(r0, r1)
+
+        return r0
+
+    def eea(self, polynomial_a: Vector, polynomial_b: Vector):
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial_a : Vector
+            _description_
+        polynomial_b : Vector
+            _description_
+
+        Returns
+        -------
+        _type_
+            _description_
+        """
+        f0, f1 = self.reduce(polynomial_a), self.reduce(polynomial_b)
+        a0, a1 = poly.monomial(1, 0), poly.zero_poly()
+        b0, b1 = poly.zero_poly(), poly.monomial(1, 0)
+
+        while not self.is_zero(f1):
+            q, r = self.euclidean_div(f0, f1)
+
+            f0, f1 = f1, r
+
+            a0, a1 = a1, self.sub(a0, self.mul(q, a1))
+            b0, b1 = b1, self.sub(b0, self.mul(q, b1))
+
+        return f0, a0, b0
+
+    def coprime(self, polynomial_a: Vector, polynomial_b: Vector) -> bool:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial_a : Vector
+            _description_
+        polynomial_b : Vector
+            _description_
+
+        Returns
+        -------
+        bool
+            _description_
+        """
+        return all(self.to_monic(self.gcd(polynomial_a, polynomial_b)) == poly.monomial(1, 0))

pqlattice/polynomial/_poly.py

@@ -0,0 +1,250 @@
+import numpy as np
+from numpy.typing import ArrayLike
+
+from .._utils import as_integer
+from ..typing import Vector, validate_aliases
+
+
+@validate_aliases
+def make_poly(data: ArrayLike) -> Vector:
+    """_summary_
+
+    Parameters
+    ----------
+    data : Iterable[int  |  float]
+        _description_
+
+    Returns
+    -------
+    Vector
+        _description_
+
+    Raises
+    ------
+    ValueError
+        _description_
+    """
+    arr = as_integer(data)
+
+    if arr.ndim != 1:
+        raise ValueError(f"Expected 1D iterable, got {arr.ndim}D")
+
+    return arr
+
+
+@validate_aliases
+def is_zero_poly(p: Vector) -> bool:
+    """_summary_
+
+    Parameters
+    ----------
+    p : Vector
+        _description_
+
+    Returns
+    -------
+    bool
+        _description_
+
+    Raises
+    ------
+    ValueError
+        _description_
+    """
+    if len(p) == 0:
+        raise ValueError("Empty coefficient array is not a proper polynomial")
+
+    return np.count_nonzero(p) == 0
+
+
+@validate_aliases
+def deg(p: Vector) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    p : Vector
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+
+    Raises
+    ------
+    ValueError
+        _description_
+    """
+    if len(p) == 0:
+        raise ValueError("Empty coefficient array is not a proper polynomial")
+    nonzeros = np.nonzero(p)[0]
+    if len(nonzeros) == 0:
+        return -1
+        # raise ValueError("Degree of zero polynomial is undefined")
+    else:
+        return nonzeros[-1]
+
+
+@validate_aliases
+def pad(p: Vector, max_deg: int) -> Vector:
+    """_summary_
+
+    Parameters
+    ----------
+    p : Vector
+        _description_
+    max_deg : int
+        _description_
+
+    Returns
+    -------
+    Vector
+        _description_
+
+    Raises
+    ------
+    ValueError
+        _description_
+    """
+    if is_zero_poly(p):
+        return zero_poly(max_deg)
+
+    d = deg(p)
+    if max_deg < d:
+        raise ValueError("max_deg has to be greater or equal to the degree of a given polynomial p")
+
+    return as_integer(np.pad(trim(p), (0, max_deg - d)))
+
+
+@validate_aliases
+def trim(p: Vector) -> Vector:
+    """_summary_
+
+    Parameters
+    ----------
+    p : Vector
+        _description_
+
+    Returns
+    -------
+    Vector
+        _description_
+    """
+    if is_zero_poly(p):
+        return as_integer([0])
+
+    return p[: deg(p) + 1].copy()
+
+
+@validate_aliases
+def add(p: Vector, q: Vector) -> Vector:
+    """_summary_
+
+    Parameters
+    ----------
+    p : Vector
+        _description_
+    q : Vector
+        _description_
+
+    Returns
+    -------
+    Vector
+        _description_
+    """
+    max_deg = max(deg(p), deg(q), 0)
+    return trim(pad(p, max_deg) + pad(q, max_deg))
+
+
+@validate_aliases
+def sub(p: Vector, q: Vector) -> Vector:
+    """_summary_
+
+    Parameters
+    ----------
+    p : Vector
+        _description_
+    q : Vector
+        _description_
+
+    Returns
+    -------
+    Vector
+        _description_
+    """
+    max_deg = max(deg(p), deg(q), 0)
+    return trim(pad(p, max_deg) - pad(q, max_deg))
+
+
+@validate_aliases
+def mul(p: Vector, q: Vector) -> Vector:
+    """_summary_
+
+    Parameters
+    ----------
+    p : Vector
+        _description_
+    q : Vector
+        _description_
+
+    Returns
+    -------
+    Vector
+        _description_
+    """
+    return trim(np.polymul(p[::-1], q[::-1])[::-1])
+
+
+@validate_aliases
+def monomial(coeff: int, degree: int) -> Vector:
+    """_summary_
+
+    Parameters
+    ----------
+    coeff : int
+        _description_
+    degree : int
+        _description_
+
+    Returns
+    -------
+    Vector
+        _description_
+
+    Raises
+    ------
+    ValueError
+        _description_
+    """
+    if degree < 0:
+        raise ValueError("degree has to be non negative")
+
+    p = as_integer([0] * (degree + 1))
+    p[degree] = coeff
+    return p
+
+
+@validate_aliases
+def zero_poly(max_deg: int = 0) -> Vector:
+    """_summary_
+
+    Parameters
+    ----------
+    max_deg : int, optional
+        _description_, by default 0
+
+    Returns
+    -------
+    Vector
+        _description_
+
+    Raises
+    ------
+    ValueError
+        _description_
+    """
+    if max_deg < 0:
+        raise ValueError("degree has to be non negative")
+
+    return as_integer([0] * (max_deg + 1))

pqlattice/polynomial/poly.py

@@ -0,0 +1,3 @@
+from ._poly import add, deg, is_zero_poly, make_poly, monomial, mul, pad, sub, trim, zero_poly
+
+__all__ = ["make_poly", "is_zero_poly", "deg", "pad", "trim", "add", "sub", "mul", "monomial", "zero_poly"]

pqlattice/random/__init__.py

@@ -0,0 +1,7 @@
+from . import distribution
+from ._lattice import randlattice
+from ._lwe import LWE
+from ._lwr import LWR
+from ._prime import randprime
+
+__all__ = ["randprime", "randlattice", "distribution", "LWE", "LWR"]