pqlattice 0.1.2__py3-none-any.whl

pqlattice/random/_distribution.py

@@ -0,0 +1,303 @@
+import math
+import random
+from abc import ABC, abstractmethod
+from typing import Any, override
+
+from .._utils import as_integer
+from ..typing import Matrix, Vector
+
+
+class Distribution(ABC):
+    def __init__(self, seed: int | None = None):
+        self._pyrng = random.Random(seed)
+
+    def set_seed(self, seed: int | None) -> None:
+        if seed is not None:
+            self._pyrng.seed(seed)
+
+    @abstractmethod
+    def sample_int(self, seed: int | None) -> int: ...
+
+    @abstractmethod
+    def sample_vector(self, n: int, seed: int | None = None) -> Vector: ...
+
+    @abstractmethod
+    def sample_matrix(self, rows: int, cols: int | None = None, seed: int | None = None) -> Matrix: ...
+
+    @abstractmethod
+    def set_params(self, *args: Any) -> None: ...
+
+    @abstractmethod
+    def get_params(self) -> dict[str, Any]: ...
+
+
+class Uniform(Distribution):
+    def __init__(self, range_beg: int, range_end: int, seed: int | None = None):
+        """
+        Creates a uniform sampler from range [range_beg; range_end].
+
+        Parameters
+        ----------
+        range_beg : int
+            begin of sampling range. Inclusive
+        range_end : int
+            end of sampling range. Inclusive
+        seed : int | None, optional
+            seed for random number generator.
+        """
+        super().__init__(seed)
+        self._range_beg = range_beg
+        self._range_end = range_end
+
+    @override
+    def sample_int(self, seed: int | None = None) -> int:
+        """
+        Get uniform random int from range [self.beg_range, self.end_range]
+
+        Parameters
+        ----------
+        seed : int | None, optional
+            set the new seed, if None does nothing
+
+        Returns
+        -------
+        int
+            random integer from range [self.beg_range, self.end_range]
+        """
+        self.set_seed(seed)
+        return self._pyrng.randint(self._range_beg, self._range_end)
+
+    @override
+    def sample_vector(self, n: int, seed: int | None = None) -> Vector:
+        """
+        _summary_
+
+        Parameters
+        ----------
+        n : int
+            _description_
+        seed : int | None, optional
+            _description_, by default None
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        self.set_seed(seed)
+        return as_integer([self.sample_int() for _ in range(n)])
+
+    @override
+    def sample_matrix(self, rows: int, cols: int | None = None, seed: int | None = None) -> Matrix:
+        """
+        _summary_
+
+        Parameters
+        ----------
+        rows : int
+            _description_
+        cols : int | None, optional
+            _description_, by default None
+        seed : int | None, optional
+            _description_, by default None
+
+        Returns
+        -------
+        Matrix
+            _description_
+        """
+        self.set_seed(seed)
+        if cols is None:
+            cols = rows
+        return as_integer([[self.sample_int() for _ in range(cols)] for _ in range(rows)])
+
+    @override
+    def set_params(self, range_beg: int | None = None, range_end: int | None = None) -> None:  # type: ignore
+        """
+        _summary_
+
+        Parameters
+        ----------
+        range_beg : int | None, optional
+            _description_, by default None
+        range_end : int | None, optional
+            _description_, by default None
+        """
+        if range_beg is None:
+            range_beg = self._range_beg
+        if range_end is None:
+            range_end = self._range_end
+
+        self._range_beg = range_beg
+        self._range_end = range_end
+
+    @override
+    def get_params(self) -> dict[str, int]:
+        """
+        _summary_
+
+        Returns
+        -------
+        dict[str, int]
+            _description_
+        """
+        return {"range_beg": self._range_beg, "range_end": self._range_end}
+
+
+class DiscreteGaussian(Distribution):
+    def __init__(self, sigma: float, center: int | float = 0, tail_cut: float = 6.0, seed: int | None = None):
+        """
+        _summary_
+
+        Parameters
+        ----------
+        sigma : float
+            _description_
+        center : int | float, optional
+            _description_, by default 0
+        tail_cut : float, optional
+            _description_, by default 6.0
+        seed : int | None, optional
+            _description_, by default None
+        """
+        super().__init__(seed)
+        self.center = center
+        self.sigma = sigma
+        self.tail_cut = tail_cut
+
+        self._table: dict[int, float] = {}
+        self._recompute_table()
+
+    def _recompute_table(self) -> None:
+        self.bound = int(math.ceil(self.tail_cut * self.sigma))
+        self._table: dict[int, float] = {}
+        for x in range(-self.bound, self.bound + 1):
+            self._table[x] = math.exp(-(x**2) / (2 * self.sigma**2))
+
+    @override
+    def sample_int(self, seed: int | None = None) -> int:
+        """
+        _summary_
+
+        Parameters
+        ----------
+        seed : int | None, optional
+            _description_, by default None
+
+        Returns
+        -------
+        int
+            _description_
+        """
+        self.set_seed(seed)
+
+        if isinstance(self.center, int):
+            return self._sample_centered_fast() + self.center
+
+        return self._sample_dynamic_rejection(self.center)
+
+    @override
+    def sample_vector(self, n: int, seed: int | None = None) -> Vector:
+        """
+        _summary_
+
+        Parameters
+        ----------
+        n : int
+            _description_
+        seed : int | None, optional
+            _description_, by default None
+
+        Returns
+        -------
+        Vector
+            _description_
+        """
+        self.set_seed(seed)
+        return as_integer([self.sample_int() for _ in range(n)])
+
+    @override
+    def sample_matrix(self, rows: int, cols: int | None = None, seed: int | None = None) -> Matrix:
+        """
+        _summary_
+
+        Parameters
+        ----------
+        rows : int
+            _description_
+        cols : int | None, optional
+            _description_, by default None
+        seed : int | None, optional
+            _description_, by default None
+
+        Returns
+        -------
+        Matrix
+            _description_
+        """
+        self.set_seed(seed)
+        if cols is None:
+            cols = rows
+        return as_integer([[self.sample_int() for _ in range(cols)] for _ in range(rows)])
+
+    @override
+    def set_params(self, sigma: float | None = None, center: float | int | None = None, tail_cut: float | None = None) -> None:  # type: ignore
+        """
+        _summary_
+
+        Parameters
+        ----------
+        sigma : float | None, optional
+            _description_, by default None
+        center : float | int | None, optional
+            _description_, by default None
+        tail_cut : float | None, optional
+            _description_, by default None
+        """
+        if sigma is None:
+            sigma = self.sigma
+        if center is None:
+            center = self.center
+        if tail_cut is None:
+            tail_cut = self.tail_cut
+
+        self.sigma = sigma
+        self.tail_cut = tail_cut
+        self.center = center
+        self._recompute_table()
+
+    def get_params(self) -> dict[str, float]:
+        """
+        _summary_
+
+        Returns
+        -------
+        dict[str, float]
+            _description_
+        """
+        return {"sigma": self.sigma, "center": self.center, "tail_cut": self.tail_cut, "bound": self.bound}
+
+    def _sample_centered_fast(self) -> int:
+        max_iters = 1000
+        for _ in range(max_iters):
+            x = random.randint(-self.bound, self.bound)
+            prob = self._table.get(x, 0.0)
+            if random.random() < prob:
+                return x
+
+        raise RuntimeError("Failed to generate sample")
+
+    def _sample_dynamic_rejection(self, c: float) -> int:
+        start = int(math.floor(c - self.bound))
+        end = int(math.ceil(c + self.bound))
+
+        max_iters = 1000
+        for _ in range(max_iters):
+            x = random.randint(start, end)
+            dist_sq = (x - c) ** 2
+            prob = math.exp(-dist_sq / (2 * self.sigma**2))
+
+            if random.random() < prob:
+                return x
+
+        raise RuntimeError("Failed to generate sample")

pqlattice/random/_lattice.py

@@ -0,0 +1,53 @@
+import random
+
+import numpy as np
+
+from .._utils import as_integer, zeros_mat
+from ..typing import SquareMatrix
+
+
+def _gen_unimodular(n: int, rounds: int, rng: random.Random) -> SquareMatrix:
+    U = as_integer(np.eye(n))
+    for _ in range(rounds):
+        i, j = rng.sample(range(n), 2)
+        coeff = rng.sample([-1, 1], 1)
+
+        U[i] += coeff * U[j]
+
+    return U
+
+
+def randlattice(n: int, det_upper_bound: int | None = None, seed: int | None = None) -> SquareMatrix:
+    """
+    Generates lattice basis by, first generating random square matrix in Hermite normal form and then by transforming it using random unimodular matrix.
+
+    Parameters
+    ----------
+    n : int
+        lattice's rank
+    det_upper_bound : int | None, optional
+        upper bound of lattice volume, by default 2 ** n
+    seed : int | None, optional
+        seed for random number generator
+
+    Returns
+    -------
+    SquareMatrix
+        n x n matrix representing lattice basis
+    """
+    det_ub: int = 2**n if det_upper_bound is None else det_upper_bound
+
+    rng = random.Random(seed)
+    diagonals = [rng.randint(1, det_ub) for _ in range(n)]
+
+    H = zeros_mat(n)
+    for i in range(n):
+        H[i, i] = diagonals[i]
+        modulus = H[i, i]
+        for j in range(i + 1, n):
+            H[i, j] = rng.randint(0, modulus - 1)
+
+    U = _gen_unimodular(n, n * 5, rng)
+
+    basis = U @ H
+    return basis

pqlattice/random/_lwe.py

@@ -0,0 +1,109 @@
+import numpy as np
+
+from ..integer._modring import cmodl, mod
+from ..typing import Matrix, Vector
+from ._distribution import DiscreteGaussian, Uniform
+
+
+class LWE:
+    def __init__(self, n: int, q: int, sigma: float, secret_distribution: str, seed: int):
+        """
+        Creates LWE sampler with DiscreteGuassianDistribution centered at 0 as noise sampler
+
+        Parameters
+        ----------
+        n : int
+            length of secret vector
+        q : int
+            modulus
+        sigma : float
+            sigma value for DiscreteGaussianDistribution
+        seed : int
+            seed for random number generator
+        """
+        self.n = n
+        self.q = q
+        self.U = Uniform(0, q - 1, seed=seed)
+        self.D = DiscreteGaussian(sigma, seed=seed)
+
+        secret = self.U.sample_vector(n)
+        if secret_distribution == "uniform":
+            self._secret = secret
+        elif secret_distribution == "binary":
+            self._secret = mod(secret, 2)
+        elif secret_distribution == "ternary":
+            self._secret = cmodl(secret, 3)
+        else:
+            raise ValueError(f"Unknown distribution {secret_distribution}, expected uniform|binary|ternary")
+
+    @property
+    def secret(self) -> Vector:
+        """
+        Retrieve underlying secret
+
+        Returns
+        -------
+        Vector
+            s: n-vector
+        """
+        return self._secret
+
+    def set_secret(self, secret: Vector) -> None:
+        """
+        Set the underlying secret
+
+        Parameters
+        ----------
+        secret : Vector
+            secret vector to set
+
+        Raises
+        ------
+        ValueError
+            when lenght of the provided vector is not correct with the parameter of the LWE sampler
+        """
+        if secret.shape[0] != self.n:
+            raise ValueError(f"expected {self.n} dimension of secret, got {secret.shape[0]}")
+
+        self._secret = secret
+
+    def sample_matrix(self, m: int) -> tuple[Matrix, Vector]:
+        """
+        Generates a full matrix system (A, b) with 'm' samples.
+
+        Parameters
+        ----------
+        m : int
+            how many samples should the resulting matrix have
+
+        Returns
+        -------
+        tuple[Matrix, Vector]:
+
+            A (Matrix): m x n matrix (Uniform mod q)
+            b (Vector): m-vector (As + e mod q)
+        """
+        A = self.U.sample_matrix(m, self.n)
+        e = self.D.sample_vector(m)
+
+        b = mod(A @ self.secret + e, self.q)
+
+        return A, b
+
+    def next_sample(self) -> tuple[Vector, int]:
+        """
+        Generates a single sample pair (a, b).
+
+        Returns
+        -------
+        tuple[Vector, int]
+            a (Vector): n-vector (Uniform mod q)
+            b (int): as + e mod q
+        """
+        a = self.U.sample_vector(self.n)
+        e = self.D.sample_int()
+
+        _as: int = np.dot(a, self.secret)
+        b = mod(_as + e, self.q)
+
+        return a, b

pqlattice/random/_lwr.py

@@ -0,0 +1,41 @@
+from typing import overload
+
+from ..typing import Matrix, Vector
+
+
+class LWR:
+    def __init__(self):
+        """_summary_
+
+        Raises
+        ------
+        NotImplementedError
+            _description_
+        """
+        raise NotImplementedError()
+
+    @overload
+    def __call__(self, n: int) -> Matrix: ...
+
+    @overload
+    def __call__(self, n: None) -> Vector: ...
+
+    def __call__(self, n: int | None = None) -> Matrix | Vector:
+        """_summary_
+
+        Parameters
+        ----------
+        n : int | None, optional
+            _description_, by default None
+
+        Returns
+        -------
+        Matrix | Vector
+            _description_
+
+        Raises
+        ------
+        NotImplementedError
+            _description_
+        """
+        raise NotImplementedError()

pqlattice/random/_prime.py

@@ -0,0 +1,53 @@
+import math
+import random
+
+from ..integer._primality import is_prime
+
+
+def _randprime(a: int, b: int, seed: int | None = None) -> int:
+    def ilog(n: int, base: float = math.e) -> int:
+        return int((n.bit_length() - 1) / math.log2(base))
+
+    try:
+        approx_number_of_primes_to_a = 0 if a == 0 else a // ilog(a)
+        approx_number_of_primes_to_b = 0 if b == 0 else b // ilog(b)
+        approx_number_of_primes = approx_number_of_primes_to_b - approx_number_of_primes_to_a
+        prime_proba = approx_number_of_primes / (b - a)
+        number_of_samples = int(math.log(0.001) / math.log(1 - prime_proba)) + 1
+    except ZeroDivisionError:
+        number_of_samples = b - a
+
+    if b - a < 1000:
+        number_of_samples = b - a
+
+    random.seed(seed)
+    for i in range(number_of_samples):
+        prime_candidate = random.randint(a, b)
+        if is_prime(prime_candidate):
+            return prime_candidate
+        if is_prime(a + i):
+            return a + i
+
+    raise ValueError(f"Couldn't find a prime number in interval [{a}, {b})")
+
+
+def randprime(kbits: int, seed: int | None = None) -> int:
+    """
+    Generates random prime number from range [2 ** (kbits - 1); 2 ** (kbist)].
+    Uses Miller-Rabin primality test.
+
+    Parameters
+    ----------
+    kbits : int
+        number of bits the prime number should have
+    seed : int | None, optional
+        seed for random number generator, by default None
+
+    Returns
+    -------
+    int
+        prime number
+    """
+    a = 2 ** (kbits - 1)
+    b = 2**kbits
+    return _randprime(a, b, seed=seed)

pqlattice/random/distribution.py

@@ -0,0 +1,3 @@
+from ._distribution import DiscreteGaussian, Uniform
+
+__all__ = ["Uniform", "DiscreteGaussian"]

pqlattice/settings.py

@@ -0,0 +1,66 @@
+import contextlib
+from collections.abc import Generator
+from typing import Literal
+
+from ._backends._fast import FastBackend
+from ._backends._native import NativeBackend
+from ._backends._protocol import BackendInterface
+
+BackendName = Literal["native", "fast"]
+
+
+class _Settings:
+    def __init__(self) -> None:
+        self._active_backend_name: BackendName = "native"
+        self._native_backend = NativeBackend()
+        self._fast_backend: FastBackend | None = None
+
+    @property
+    def backend_name(self) -> BackendName:
+        return self._active_backend_name
+
+    @property
+    def backend(self) -> BackendInterface:
+        if self.backend_name == "native":
+            return self._native_backend
+        elif self.backend_name == "fast":
+            if self._fast_backend is None:
+                self._fast_backend = FastBackend()
+            return self._fast_backend
+
+        raise RuntimeError(f"No backend {self.backend_name}")
+
+    def set_backend(self, name: BackendName) -> None:
+        self._active_backend_name = name
+
+
+_config = _Settings()
+
+
+def get_backend_name() -> BackendName:
+    return _config.backend_name
+
+
+def get_backend() -> BackendInterface:
+    return _config.backend
+
+
+def set_backend(name: BackendName) -> None:
+    _config.set_backend(name)
+
+
+@contextlib.contextmanager
+def backend(name: BackendName) -> Generator[None, None, None]:
+    """
+    Context manager to temporarily switch the backend.
+
+    Usage:
+        with pq.settings.backend("fpylll"):
+            pq.lattice.lll(B)
+    """
+    previous = _config.backend_name
+    try:
+        set_backend(name)
+        yield
+    finally:
+        set_backend(previous)

pqlattice/typing/__init__.py

@@ -0,0 +1,4 @@
+from ._types import Array, Matrix, SquareMatrix, Vector, is_integer, is_rational
+from ._types_validator import is_Matrix, is_SquareMatrix, is_Vector, validate_aliases
+
+__all__ = ["Array", "Matrix", "SquareMatrix", "Vector", "is_integer", "is_rational", "validate_aliases", "is_Vector", "is_Matrix", "is_SquareMatrix"]

pqlattice/typing/_types.py

@@ -0,0 +1,18 @@
+from fractions import Fraction
+from typing import Any
+
+from numpy.typing import NDArray
+
+type Array = NDArray[Any]
+
+type Vector = NDArray[Any]
+type Matrix = NDArray[Any]
+type SquareMatrix = NDArray[Any]
+
+
+def is_rational(a: Array) -> bool:
+    return isinstance(a.flat[0], Fraction)
+
+
+def is_integer(a: Array) -> bool:
+    return isinstance(a.flat[0], int)