pqlattice 0.1.2__py3-none-any.whl

pqlattice/linalg/_modint.py

@@ -0,0 +1,209 @@
+import numpy as np
+
+from .._utils import as_integer
+from ..integer._modintring import ModIntRing
+from ..typing import Matrix, SquareMatrix, Vector, validate_aliases
+from ._utils import row_add, row_scale, row_swap
+
+
+@validate_aliases
+def mod_ref(A: Matrix, modulus: int) -> tuple[Matrix, SquareMatrix]:
+    """_summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+    modulus : int
+        _description_
+
+    Returns
+    -------
+    tuple[Matrix, SquareMatrix]
+        _description_
+    """
+    R = ModIntRing(modulus)
+    m, n = A.shape
+
+    M = R.mod(as_integer(A))
+    U = as_integer(np.identity(m))
+
+    for j in range(min(m, n)):
+        col = M[:, j]
+        nonzero = np.nonzero(col[j:])[0]
+        if len(nonzero) == 0:
+            continue
+        pivot_i = nonzero[0] + j
+
+        if pivot_i != j:
+            row_swap(M, pivot_i, j)
+            row_swap(U, pivot_i, j)
+
+        pivot: int = M[j, j]
+        pivot_inv = R.inv(pivot)
+        row_scale(M, j, pivot_inv)
+        row_scale(U, j, pivot_inv)
+
+        M = R.mod(M)
+        U = R.mod(U)
+
+        for i in range(j + 1, m):
+            if M[i, j] != 0:
+                row_add(U, i, j, -M[i, j])
+                row_add(M, i, j, -M[i, j])
+                M = R.mod(M)
+                U = R.mod(U)
+
+    return R.mod(M), R.mod(U)
+
+
+@validate_aliases
+def mod_rref(A: Matrix, modulus: int) -> tuple[Matrix, SquareMatrix]:
+    """_summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+    modulus : int
+        _description_
+
+    Returns
+    -------
+    tuple[Matrix, SquareMatrix]
+        _description_
+    """
+    R = ModIntRing(modulus)
+    m, n = A.shape
+    M, U = mod_ref(A, modulus)
+
+    h = m - 1
+    for j in range(n - 1, -1, -1):
+        if M[h, j] != 1:
+            if M[h, j] == 0:
+                h -= 1
+            continue
+
+        for i in range(h - 1, -1, -1):
+            coeff = M[i, j]
+            row_add(M, i, h, -coeff)
+            row_add(U, i, h, -coeff)
+
+        h -= 1
+
+    return R.mod(M), R.mod(U)
+
+
+@validate_aliases
+def mod_left_kernel(A: Matrix, modulus: int) -> Matrix:
+    """_summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+    modulus : int
+        _description_
+
+    Returns
+    -------
+    Matrix
+        _description_
+    """
+    return mod_right_kernel(A.T, modulus)
+
+
+@validate_aliases
+def mod_right_kernel(A: Matrix, modulus: int) -> Matrix:
+    """_summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+    modulus : int
+        _description_
+
+    Returns
+    -------
+    Matrix
+        _description_
+    """
+    M, U = mod_rref(A.T, modulus)
+    kernel_basis: list[Vector] = []
+
+    m, _ = M.shape
+    for i in range(m):
+        if np.all(M[i] == 0):
+            kernel_basis.append(U[i])
+
+    return as_integer(kernel_basis)
+
+
+def mod_left_image(A: Matrix, modulus: int) -> Matrix:
+    raise NotImplementedError()
+
+
+def mod_right_image(A: Matrix, modulus: int) -> Matrix:
+    raise NotImplementedError()
+
+
+@validate_aliases
+def mod_left_nullity(A: Matrix, modulus: int) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+    modulus : int
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    kernel = mod_left_kernel(A, modulus)
+    return kernel.shape[0]
+
+
+@validate_aliases
+def mod_right_nullity(A: Matrix, modulus: int) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+    modulus : int
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    kernel = mod_right_kernel(A, modulus)
+    return kernel.shape[0]
+
+
+def mod_matinv(A: SquareMatrix, modulus: int) -> SquareMatrix:
+    """_summary_
+
+    Parameters
+    ----------
+    A : SquareMatrix
+        _description_
+    modulus : int
+        _description_
+
+    Returns
+    -------
+    SquareMatrix
+        _description_
+    """
+    n = A.shape[0]
+    AId = np.hstack((A, as_integer(np.identity(n))))
+    R, _ = mod_rref(AId, modulus)
+    return as_integer(R[:, n:])

pqlattice/linalg/_utils.py

@@ -0,0 +1,167 @@
+import math
+
+from ..typing import Matrix, Vector, validate_aliases
+
+
+@validate_aliases
+def row_swap(m: Matrix, i: int, k: int) -> None:
+    """_summary_
+
+    Parameters
+    ----------
+    m : Matrix
+        _description_
+    i : int
+        _description_
+    k : int
+        _description_
+    """
+    m[[i, k]] = m[[k, i]]
+
+
+@validate_aliases
+def row_scale(m: Matrix, i: int, s: float | int) -> None:
+    """_summary_
+
+    Parameters
+    ----------
+    m : Matrix
+        _description_
+    i : int
+        _description_
+    s : float | int
+        _description_
+    """
+    m[i] *= s
+
+
+@validate_aliases
+def row_add(m: Matrix, i: int, k: int, s: float | int) -> None:
+    """_summary_
+
+    Parameters
+    ----------
+    m : Matrix
+        _description_
+    i : int
+        _description_
+    k : int
+        _description_
+    s : float | int
+        _description_
+    """
+    m[i] += s * m[k]
+
+
+@validate_aliases
+def col_swap(m: Matrix, i: int, k: int) -> None:
+    """_summary_
+
+    Parameters
+    ----------
+    m : Matrix
+        _description_
+    i : int
+        _description_
+    k : int
+        _description_
+    """
+    m[:, [i, k]] = m[:, [k, i]]
+
+
+@validate_aliases
+def col_scale(m: Matrix, i: int, s: float | int) -> None:
+    """_summary_
+
+    Parameters
+    ----------
+    m : Matrix
+        _description_
+    i : int
+        _description_
+    s : float | int
+        _description_
+    """
+    m[:, i] *= s
+
+
+@validate_aliases
+def col_add(m: Matrix, i: int, k: int, s: float | int) -> None:
+    """_summary_
+
+    Parameters
+    ----------
+    m : Matrix
+        _description_
+    i : int
+        _description_
+    k : int
+        _description_
+    s : float | int
+        _description_
+    """
+    m[:, i] += s * m[:, k]
+
+
+def norm2(v: Vector) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    v : Vector
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    return int(v @ v.T)
+
+
+def norm(v: Vector) -> float:
+    """_summary_
+
+    Parameters
+    ----------
+    v : Vector
+        _description_
+
+    Returns
+    -------
+    float
+        _description_
+    """
+    return math.sqrt(norm2(v))
+
+
+def per_row_norm2(A: Matrix) -> list[int]:
+    """_summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+
+    Returns
+    -------
+    list[int]
+        _description_
+    """
+    return [norm2(row) for row in A]
+
+
+def per_row_norm(A: Matrix) -> list[float]:
+    """_summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+
+    Returns
+    -------
+    list[float]
+        _description_
+    """
+    return [math.sqrt(n2) for n2 in per_row_norm2(A)]

pqlattice/polynomial/__init__.py

@@ -0,0 +1,5 @@
+from . import poly
+from ._modpolyqring import ModIntPolyQuotientRing, construct_ring
+from ._modpolyring import ModIntPolyRing
+
+__all__ = ["poly", "ModIntPolyRing", "ModIntPolyQuotientRing", "construct_ring"]

pqlattice/polynomial/_modpolyqring.py

@@ -0,0 +1,185 @@
+from ..integer._modring import mod, modinv
+from ..typing import Vector, validate_aliases
+from ._modpolyring import ModIntPolyRing
+from ._poly import zero_poly
+
+
+class ModIntPolyQuotientRing:
+    @validate_aliases
+    def __init__(self, poly_modulus: Vector, int_modulus: int) -> None:
+        """_summary_
+
+        Parameters
+        ----------
+        poly_modulus : Vector
+            _description_
+        int_modulus : int
+            _description_
+        """
+        self.poly_modulus = poly_modulus
+        self.int_modulus = int_modulus
+        self.Zm = ModIntPolyRing(int_modulus)
+
+    @property
+    def quotient(self) -> Vector:
+        """_summary_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        return self.poly_modulus
+
+    @validate_aliases
+    def reduce(self, polynomial: Vector) -> Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        return self.Zm.rem(polynomial, self.poly_modulus)
+
+    @validate_aliases
+    def center_lift(self, polynomial: Vector) -> Vector:
+        """
+        Hoffstein page. 414 - 415
+
+        Parameters
+        ----------
+        polynomial : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        return mod(polynomial + self.int_modulus // 2, self.int_modulus) - self.int_modulus // 2
+
+    @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(self.Zm.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(self.Zm.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(self.Zm.mul(polynomial_a, polynomial_b))
+
+    @validate_aliases
+    def inv(self, polynomial: Vector) -> Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        polynomial : Vector
+            _description_
+
+        Returns
+        -------
+        Vector
+            _description_
+
+        Raises
+        ------
+        ValueError
+            _description_
+        """
+        if not self.Zm.coprime(polynomial, self.poly_modulus):
+            raise ValueError("Inverse does not exists")
+
+        gcd, u, _ = self.Zm.eea(polynomial, self.poly_modulus)
+
+        c = modinv(gcd, self.int_modulus)
+
+        return self.reduce(u * c)
+
+
+def construct_ring(p: str, N: int, q: int) -> ModIntPolyQuotientRing:
+    """_summary_
+
+    Parameters
+    ----------
+    p : str
+        _description_
+    N : int
+        _description_
+    q : int
+        _description_
+
+    Returns
+    -------
+    ModIntPolyQuotientRing
+        _description_
+
+    Raises
+    ------
+    ValueError
+        _description_
+    """
+    g = zero_poly(N)
+    match p:
+        case "-" | "X^N - 1":
+            g[[0, N]] = -1, 1
+            pass
+        case "+" | "X^N + 1":
+            g[[0, N]] = 1, 1
+            pass
+        case "prime" | "X^N - x - 1":
+            g[[0, 1, N]] = -1, -1, 1
+        case _:
+            raise ValueError(f"Unknown symbol: {p}")
+
+    return ModIntPolyQuotientRing(g, q)