pqlattice 0.1.2__py3-none-any.whl

pqlattice/__init__.py

@@ -0,0 +1,6 @@
+from fractions import Fraction
+
+from . import integer, lattice, linalg, polynomial, random, settings, typing
+from ._utils import as_integer, as_rational, show
+
+__all__ = ["settings", "integer", "lattice", "linalg", "polynomial", "random", "typing", "as_integer", "as_rational", "Fraction", "show"]

pqlattice/_backends/_fast.py

@@ -0,0 +1,75 @@
+from typing import Any, override
+
+from .._utils import as_integer
+from ..typing import Array, Matrix, SquareMatrix, Vector
+from ._protocol import BackendInterface
+
+try:
+    import fpylll
+
+    HAS_FPYLLL = True
+except ImportError:
+    HAS_FPYLLL = False
+
+try:
+    import flint
+
+    HAS_FLINT = True
+except ImportError:
+    HAS_FLINT = False
+
+
+class FastBackend(BackendInterface):
+    def __init__(self) -> None:
+        if not (HAS_FPYLLL and HAS_FLINT):
+            raise RuntimeError("Fast backend is unavailable - dependencies missing")
+
+    def _to_fpylll(self, a: Array) -> Any:
+        return fpylll.IntegerMatrix.from_matrix(a.tolist())
+
+    def _from_fpylll(self, mat: Any) -> Array:
+        data = [list(row) for row in mat]
+        return as_integer(data)
+
+    def _to_flint(self, a: Array) -> Any:
+        return flint.fmpz_mat(a.tolist())
+
+    def _from_flint(self, mat: Any) -> Array:
+        return as_integer(mat.table())
+
+    @override
+    def lll(self, lattice_basis: SquareMatrix, delta: float) -> SquareMatrix:
+        mat = self._to_fpylll(lattice_basis)
+        fpylll.LLL.reduction(mat, delta=delta)
+        return self._from_fpylll(mat)
+
+    @override
+    def bkz(self, lattice_basis: SquareMatrix, block_size: int, delta: float) -> SquareMatrix:
+        mat = self._to_fpylll(lattice_basis)
+        # fpylll.BKZ.reduction(mat, delta=delta)
+        mat_bkz = fpylll.BKZ.reduction(mat, fpylll.BKZ.Param(block_size=block_size))
+        return self._from_fpylll(mat_bkz)
+
+    @override
+    def hkz(self, lattice_basis: SquareMatrix, delta: float) -> SquareMatrix:
+        return self.bkz(lattice_basis, len(lattice_basis), delta)
+
+    @override
+    def shortest_vector(self, lattice_basis: SquareMatrix) -> Vector:
+        mat = self._to_fpylll(lattice_basis)
+        fpylll.LLL.reduction(mat)
+        sv = fpylll.SVP.shortest_vector(mat, pruning=False, preprocess=False)
+        return as_integer(sv)
+
+    @override
+    def closest_vector(self, lattice_basis: SquareMatrix, target_vector: Vector) -> Vector:
+        A = self._from_fpylll(lattice_basis)
+        t = target_vector.tolist()
+        v0 = fpylll.CVP.closest_vector(A, t)
+        return as_integer(v0)
+
+    @override
+    def hnf(self, matrix: Matrix) -> tuple[Matrix, SquareMatrix]:
+        mat = self._to_flint(matrix)
+        H, U = mat.hnf(transform=True)
+        return self._from_flint(H), self._from_flint(U)

pqlattice/_backends/_native.py

@@ -0,0 +1,33 @@
+from typing import override
+
+from ..lattice._bkz import bkz
+from ..lattice._hkz import hkz
+from ..lattice._lll import lll
+from ..lattice._svp import shortest_vector
+from ..linalg._linalg import hnf
+from ..typing import Matrix, SquareMatrix, Vector
+from ._protocol import BackendInterface
+
+
+class NativeBackend(BackendInterface):
+    @override
+    def lll(self, lattice_basis: SquareMatrix, delta: float) -> SquareMatrix:
+        return lll(lattice_basis, delta)
+
+    @override
+    def bkz(self, lattice_basis: SquareMatrix, block_size: int, delta: float) -> SquareMatrix:
+        _ = delta
+        return bkz(lattice_basis, block_size)
+
+    @override
+    def hkz(self, lattice_basis: SquareMatrix, delta: float) -> SquareMatrix:
+        _ = delta
+        return hkz(lattice_basis)
+
+    @override
+    def shortest_vector(self, lattice_basis: SquareMatrix) -> Vector:
+        return shortest_vector(lattice_basis)
+
+    @override
+    def hnf(self, matrix: Matrix) -> tuple[Matrix, SquareMatrix]:
+        return hnf(matrix)

pqlattice/_backends/_protocol.py

@@ -0,0 +1,15 @@
+from typing import Protocol
+
+from ..typing import Matrix, SquareMatrix, Vector
+
+
+class BackendInterface(Protocol):
+    def lll(self, lattice_basis: SquareMatrix, delta: float) -> SquareMatrix: ...
+
+    def bkz(self, lattice_basis: SquareMatrix, block_size: int, delta: float) -> SquareMatrix: ...
+
+    def hkz(self, lattice_basis: SquareMatrix, delta: float) -> SquareMatrix: ...
+
+    def shortest_vector(self, lattice_basis: SquareMatrix) -> Vector: ...
+
+    def hnf(self, matrix: Matrix) -> tuple[Matrix, SquareMatrix]: ...

pqlattice/_utils.py

@@ -0,0 +1,201 @@
+from fractions import Fraction
+from typing import Any
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+from .typing import Array, Matrix, Vector, is_integer, is_Matrix, is_rational, is_Vector, validate_aliases
+
+
+def as_integer(obj: ArrayLike) -> Array:
+    """
+    Helper function that converts given obj to numpy's array of python's ints allowing arbitrary large elements
+
+    Parameters
+    ----------
+    obj : ArrayLike
+        object to be converted to numpy's array
+
+    Returns
+    -------
+    Array
+        numpy's array with dtype=object and elements converted to int
+
+    Examples
+    --------
+    >>> import pqlattice as pq
+    >>> pq.as_integer([3**100, 2**100, 5**50])
+    array([515377520732011331036461129765621272702107522001,
+       1267650600228229401496703205376,
+       88817841970012523233890533447265625], dtype=object)
+    """
+    arr = np.array(obj, dtype=object)
+    if arr.size == 0:
+        return arr
+    else:
+        return (np.vectorize(int)(arr.flat).reshape(arr.shape)).astype(object)
+
+
+def as_rational(obj: ArrayLike) -> Array:
+    """
+    Helper function that converts given obj to numpy's array of python's fractions.Fraction allowing arbitrary big rational elements
+
+    Parameters
+    ----------
+    obj : ArrayLike
+        object to be converted to numpy's array
+
+    Returns
+    -------
+    Array
+        numpy's array with dtype=object and elements converted to fractions.Fraction
+
+    Examples
+    --------
+    >>> import pqlattice as pq
+    >>> pq.as_rational([3**100, 2**100, 5**50])
+    array([Fraction(515377520732011331036461129765621272702107522001, 1),
+       Fraction(1267650600228229401496703205376, 1),
+       Fraction(88817841970012523233890533447265625, 1)], dtype=object)
+    """
+    arr = np.array(obj, dtype=object)
+    if arr.size == 0:
+        return arr
+    else:
+        return (np.vectorize(Fraction)(arr.flat).reshape(arr.shape)).astype(object)
+
+
+def zeros_vec(n: int) -> Vector:
+    return as_integer(np.zeros((n,)))
+
+
+def zeros_mat(rows: int, cols: int | None = None) -> Matrix:
+    if cols is None:
+        cols = rows
+    return as_integer(np.zeros((rows, cols)))
+
+
+@validate_aliases
+def show(a: Array, max_rows: int = 10, max_cols: int = 10, val_width: int = 15):
+    """
+    Helper function that prints the numpy's array in a human redable format
+
+    Parameters
+    ----------
+    a : Array
+        The array to print
+    max_rows : int, optional
+        Max number of rows to display before truncating, by default 10
+    max_cols : int, optional
+        Max number of columns to display before truncating, by default 10
+    val_width : int, optional
+        Max characters per cell, by default 15. If a string representation of element is longer, it is truncated e.g 1234...5678
+
+    Examples
+    --------
+    >>> import pqlattice as pq
+    >>> M = pq.random.distribution.Uniform(0, 2**50, seed=0).sample_matrix(7, 5)
+    >>> pq.show(M)
+    Matrix of integers with shape: 7 x 5
+    ====================================
+                    [0]              [1]              [2]              [3]              [4]
+    [0]  867496826243021   91162487198805  109421..4040930  806253307773444  491889324856851
+    [1]  313616384600182  314680579360371  213540430176889  330931104930059  222394738660569
+    [2]  166055160201467  743539086037546  796665326308852  712012953150114  460445890320316
+    [3]  996855368208390  140240390954947  210028256050344  750154124310314  141827853726696
+    [4]  499232256057935  320872572303314  205400145011268  110177..2031755  678794279728913
+    [5]  655478801553847  281048514639229  749289460799082  457570956347073  647748016542327
+    [6]  206336435080453  713924001980837  545175556185458  414036094290124   74247901643189
+    """
+
+    def format_val(val: Any) -> str:
+        s = str(val)
+        if len(s) > val_width:
+            mid = (val_width - 2) // 2
+            remainder = (val_width - 2) % 2
+            return f"{s[:mid]}..{s[-(mid + remainder) :]}"
+        return s
+
+    element_type: str = f"{a.dtype}"
+    if is_integer(a):
+        element_type = "integers"
+    if is_rational(a):
+        element_type = "rationals"
+
+    info_header = f"numpy array of {element_type} with shape: {a.shape}"
+
+    is_v = False
+    if is_Matrix(a):
+        rows, cols = a.shape
+        info_header = f"Matrix of {element_type} with shape: {rows} x {cols}"
+    elif is_Vector(a):
+        dim = a.shape[0]
+        info_header = f"Vector of {element_type} with shape: {dim}"
+        is_v = True
+        rows, cols = 1, dim
+    else:
+        print(info_header)
+        print("=" * len(info_header))
+        print(f"{a}")
+        return
+
+    print(info_header)
+    print("=" * len(info_header))
+
+    ellipsis_col_idx: int | None = None
+    ellipsis_row_idx: int | None = None
+    if rows <= max_rows:
+        row_indices = list(range(rows))
+        show_row_ellipsis = False
+    else:
+        # Top half and bottom half
+        r_cut = max_rows // 2
+        row_indices = list(range(r_cut)) + list(range(rows - r_cut, rows))
+        show_row_ellipsis = True
+        ellipsis_row_idx = r_cut
+
+    if cols <= max_cols:
+        col_indices = list(range(cols))
+        show_col_ellipsis = False
+    else:
+        c_cut = max_cols // 2
+        col_indices = list(range(c_cut)) + list(range(cols - c_cut, cols))
+        show_col_ellipsis = True
+        ellipsis_col_idx = c_cut
+
+    header = [""]
+    for i, c_idx in enumerate(col_indices):
+        if show_col_ellipsis and i == ellipsis_col_idx:
+            header.append("...")
+        header.append(f"[{c_idx}]")
+
+    table_data = [header]
+
+    for i, r_idx in enumerate(row_indices):
+        if show_row_ellipsis and i == ellipsis_row_idx:
+            ellipsis_row = ["..."] + ["..."] * (len(header) - 1)
+            table_data.append(ellipsis_row)
+
+        row_str = [f"[{r_idx}]"]
+
+        for j, c_idx in enumerate(col_indices):
+            if show_col_ellipsis and j == ellipsis_col_idx:
+                row_str.append("...")
+
+            val = a[c_idx] if is_v else a[r_idx, c_idx]
+            row_str.append(format_val(val))
+
+        table_data.append(row_str)
+
+    num_display_cols = len(table_data[0])
+    col_widths = [0] * num_display_cols
+
+    for row in table_data:
+        for idx, cell in enumerate(row):
+            col_widths[idx] = max(col_widths[idx], len(cell))
+
+    for row in table_data:
+        formatted_row: list[str] = []
+        for idx, cell in enumerate(row):
+            formatted_row.append(cell.rjust(col_widths[idx]))
+        print("  ".join(formatted_row))

pqlattice/integer/__init__.py

@@ -0,0 +1,8 @@
+from math import gcd
+
+from ._integer import eea
+from ._modintring import ModIntRing
+from ._modring import cmodl, cmodr, mod, modinv, modpow
+from ._primality import is_prime
+
+__all__ = ["gcd", "eea", "mod", "cmodl", "cmodr", "modinv", "modpow", "ModIntRing", "is_prime"]

pqlattice/integer/_integer.py

@@ -0,0 +1,55 @@
+from typing import cast, overload
+
+from .._utils import as_integer
+from ..typing import Array
+
+
+@overload
+def eea(a: int, b: int) -> tuple[int, int, int]: ...
+
+
+@overload
+def eea(a: Array, b: int) -> tuple[Array, Array, Array]: ...
+
+
+def eea(a: int | Array, b: int) -> tuple[int, int, int] | tuple[Array, Array, Array]:
+    """_summary_
+
+    Parameters
+    ----------
+    a : int | Array
+        _description_
+    b : int
+        _description_
+
+    Returns
+    -------
+    tuple[int, int, int] | tuple[Array, Array, Array]
+        _description_
+    """
+    if isinstance(a, int):
+        return _eea(a, b)
+    else:
+        return tuple(as_integer([_eea(cast(int, el), b) for el in a]).T)
+
+
+def _eea(a: int, b: int) -> tuple[int, int, int]:
+    if a == 0 and b == 0:
+        raise ValueError("a and b can't be both zero")
+
+    old_s, s = 1, 0
+    old_r, r = a, b
+    while r != 0:
+        q = old_r // r
+        old_r, r = r, old_r - q * r
+        old_s, s = s, old_s - q * s
+
+    t = 0 if b == 0 else (old_r - old_s * a) // b
+    s = old_s
+    gcd = old_r
+    if gcd < 0:
+        gcd = -gcd
+        s = -s
+        t = -t
+
+    return gcd, s, t

pqlattice/integer/_modintring.py

@@ -0,0 +1,246 @@
+from typing import overload
+
+from ..typing import Array
+from ._modring import cmodl, cmodr, mod, modinv, modpow
+
+
+class ModIntRing:
+    def __init__(self, modulus: int):
+        """_summary_
+
+        Parameters
+        ----------
+        modulus : int
+            _description_
+
+        Raises
+        ------
+        ValueError
+            _description_
+        """
+        if abs(modulus) < 2:
+            raise ValueError(f"absolute value of modulus has to greater than one, given modulus: {modulus}")
+
+        self._modulus = abs(modulus)
+
+    @property
+    def q(self) -> int:
+        """_summary_
+
+        Returns
+        -------
+        _type_
+            _description_
+        """
+        return self._modulus
+
+    def is_zero(self, a: int) -> bool:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int
+            _description_
+
+        Returns
+        -------
+        bool
+            _description_
+        """
+        return self.mod(a) == 0
+
+    @overload
+    def mod(self, a: int) -> int: ...
+
+    @overload
+    def mod(self, a: Array) -> Array: ...
+
+    def mod(self, a: int | Array) -> int | Array:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int | Array
+            _description_
+
+        Returns
+        -------
+        int | Array
+            _description_
+        """
+        return mod(a, self.q)
+
+    @overload
+    def pow(self, a: int, r: int) -> int: ...
+
+    @overload
+    def pow(self, a: Array, r: int) -> Array: ...
+
+    def pow(self, a: int | Array, r: int) -> int | Array:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int | Array
+            _description_
+        r : int
+            _description_
+
+        Returns
+        -------
+        int | Array
+            _description_
+        """
+        return self.mod(modpow(a, r, self.q))
+
+    @overload
+    def inv(self, a: int) -> int: ...
+
+    @overload
+    def inv(self, a: Array) -> Array: ...
+
+    def inv(self, a: int | Array) -> int | Array:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int | Array
+            _description_
+
+        Returns
+        -------
+        int | Array
+            _description_
+        """
+        return self.mod(modinv(a, self.q))
+
+    @overload
+    def neg(self, a: int) -> int: ...
+
+    @overload
+    def neg(self, a: Array) -> Array: ...
+
+    def neg(self, a: int | Array) -> int | Array:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int | Array
+            _description_
+
+        Returns
+        -------
+        int | Array
+            _description_
+        """
+        return self.mod(-a)
+
+    def add(self, a: int, b: int) -> int:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int
+            _description_
+        b : int
+            _description_
+
+        Returns
+        -------
+        int
+            _description_
+        """
+        return self.mod(a + b)
+
+    def mul(self, a: int, b: int) -> int:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int
+            _description_
+        b : int
+            _description_
+
+        Returns
+        -------
+        int
+            _description_
+        """
+        return self.mod(a * b)
+
+    def div(self, a: int, b: int) -> int:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int
+            _description_
+        b : int
+            _description_
+
+        Returns
+        -------
+        int
+            _description_
+        """
+        return self.mul(a, self.inv(b))
+
+    def sub(self, a: int, b: int) -> int:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int
+            _description_
+        b : int
+            _description_
+
+        Returns
+        -------
+        int
+            _description_
+        """
+        return self.mod(a - b)
+
+    @overload
+    def cmodl(self, a: int) -> int: ...
+
+    @overload
+    def cmodl(self, a: Array) -> Array: ...
+
+    def cmodl(self, a: int | Array) -> int | Array:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int | Array
+            _description_
+
+        Returns
+        -------
+        int | Array
+            _description_
+        """
+        return cmodl(a, self.q)
+
+    @overload
+    def cmodr(self, a: int) -> int: ...
+
+    @overload
+    def cmodr(self, a: Array) -> Array: ...
+
+    def cmodr(self, a: int | Array) -> int | Array:
+        """_summary_
+
+        Parameters
+        ----------
+        a : int | Array
+            _description_
+
+        Returns
+        -------
+        int | Array
+            _description_
+        """
+        return cmodr(a, self.q)