pqlattice 0.1.2__py3-none-any.whl

pqlattice/lattice/_lattice.py

@@ -0,0 +1,137 @@
+import math
+from functools import reduce
+
+import numpy as np
+
+from .._utils import as_integer
+from ..linalg._linalg import det
+from ..linalg._utils import norm2, per_row_norm
+from ..typing import SquareMatrix, Vector, validate_aliases
+
+
+@validate_aliases
+def volume(lattice_basis: SquareMatrix) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    return abs(det(lattice_basis))
+
+
+@validate_aliases
+def rank(lattice_basis: SquareMatrix) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    return lattice_basis.shape[0]
+
+
+@validate_aliases
+def discriminant(lattice_basis: SquareMatrix) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    v = volume(lattice_basis)
+    return v * v
+
+
+@validate_aliases
+def hadamard_ratio(lattice_basis: SquareMatrix) -> float:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    float
+        _description_
+    """
+    return (volume(lattice_basis) / reduce(lambda a, b: a * b, per_row_norm(lattice_basis))) ** (1 / rank(lattice_basis))
+
+
+@validate_aliases
+def gaussian_heuristic(lattice_basis: SquareMatrix) -> float:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    float
+        _description_
+    """
+    n = rank(lattice_basis)
+    return math.sqrt(n / (2 * math.pi * math.e)) * (volume(lattice_basis) ** (1 / n))
+
+
+@validate_aliases
+def glr_2dim(lattice_basis: SquareMatrix) -> SquareMatrix:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    SquareMatrix
+        _description_
+
+    Raises
+    ------
+    ValueError
+        _description_
+    """
+    if lattice_basis.shape != (2, 2):
+        raise ValueError("Lattice has to have rank 2 for gaussian reduction")
+
+    w1: Vector = lattice_basis[0]
+    w2: Vector = lattice_basis[1]
+
+    v1 = w1.astype(float)
+    v2 = w2.astype(float)
+    if norm2(v1) > norm2(v2):
+        v1, v2 = v2, v1
+
+    while norm2(v2) > norm2(v1):
+        m = np.rint(np.dot(v1, v2) / np.dot(v1, v1))
+        if m == 0:
+            return as_integer([v1, v2])
+        v2 = v2 - m * v1
+        if norm2(v1) > norm2(v2):
+            v1, v2 = v2, v1
+
+    return np.array([v1, v2])

pqlattice/lattice/_lll.py

@@ -0,0 +1,93 @@
+from fractions import Fraction
+
+import numpy as np
+
+from .._utils import as_integer
+from ..typing import Matrix, SquareMatrix, validate_aliases
+from ._gso import gso, project_coeffs
+
+
+@validate_aliases
+def lll(lattice_basis: Matrix, delta: float = 0.99) -> Matrix:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : Matrix
+        _description_
+    delta : float, optional
+        _description_, by default 0.99
+
+    Returns
+    -------
+    Matrix
+        _description_
+    """
+    rows, _ = lattice_basis.shape
+    B: Matrix = as_integer(lattice_basis)
+    while True:
+        B_star, _ = gso(B)
+        # Reduction Step
+        for i in range(1, rows):
+            for j in range(i - 1, -1, -1):
+                c_ij = round(project_coeffs(B_star[j], B[i]))
+                assert isinstance(c_ij, int)
+                B[i] = B[i] - c_ij * B[j]
+        # Swap step
+        exists = False
+        for i in range(rows - 1):
+            u = project_coeffs(B_star[i], B[i + 1])
+            r = u * B_star[i] + B_star[i + 1]
+            if delta * np.dot(B_star[i], B_star[i]) > np.dot(r, r):
+                B[[i, i + 1]] = B[[i + 1, i]]
+                exists = True
+                break
+        if not exists:
+            break
+    return B
+
+
+@validate_aliases
+def is_size_reduced(lattice_basis: SquareMatrix) -> bool:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    bool
+        _description_
+    """
+    _, U = gso(lattice_basis)
+    return bool(np.all(np.triu(U, 1) <= Fraction(1, 2)))
+
+
+@validate_aliases
+def lovasz_condition(lattice_basis: SquareMatrix, delta: float) -> bool:
+    norm2 = lambda a: np.sum(a * a, axis=1)  # type: ignore
+    G, U = gso(lattice_basis)
+    lhs = delta * norm2(G[:-1])
+    rhs = norm2(G[1:] + np.diag(U, 1)[:, np.newaxis] * G[:-1])
+    return bool(np.all(lhs <= rhs))
+
+
+@validate_aliases
+def is_lll_reduced(lattice_basis: SquareMatrix, delta: float = 0.99) -> bool:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : SquareMatrix
+        _description_
+    delta : float, optional
+        _description_, by default 0.99
+
+    Returns
+    -------
+    bool
+        _description_
+    """
+    return is_size_reduced(lattice_basis) and lovasz_condition(lattice_basis, delta)

pqlattice/lattice/_svp.py

@@ -0,0 +1,89 @@
+from fractions import Fraction
+
+from .._utils import as_integer, as_rational
+from ..typing import SquareMatrix, Vector, validate_aliases
+from ._gso import gso
+from ._lll import lll
+
+
+@validate_aliases
+def schnorr_euchner_svp(mu: SquareMatrix, B: Vector) -> Vector:
+    n = len(B)
+    best_norm: Fraction = B[0]
+    best_coeffs: Vector = as_integer([1] + [0] * (n - 1))
+
+    r: Vector = as_rational([0] * (n + 1))
+    c: Vector = as_rational([0] * n)
+    x: Vector = as_integer([0] * n)
+    v: Vector = as_rational([0] * n)
+
+    last_move = [0] * n
+    k = n - 1
+
+    r[n] = Fraction(0)
+    v[n - 1] = Fraction(0)
+    c[n - 1] = Fraction(0)
+    x[n - 1] = 0
+    last_move[n - 1] = 0
+
+    while True:
+        y: Fraction = x[k] - c[k]
+        current_norm: Fraction = r[k + 1] + (y * y * B[k])
+        # print(f"{k=}: {current_norm=:.5f}, {best_norm=:.5f}")
+        if current_norm < best_norm:
+            if k == 0:
+                if current_norm > 0:
+                    best_norm = current_norm
+                    best_coeffs = x.copy()
+
+                k += 1
+                last_move[k] += 1
+
+                step_sign = -1 if (last_move[k] % 2 == 0) else 1
+                step_mag = (last_move[k] + 1) // 2
+                x[k] = round(c[k]) + (step_sign * step_mag)
+
+            else:
+                k -= 1
+                center_val = Fraction(0)
+                for j in range(k + 1, n):
+                    center_val += mu[j][k] * x[j]
+
+                c[k] = -center_val
+                x[k] = round(c[k])
+                last_move[k] = 0
+                r[k + 1] = current_norm
+        else:
+            k += 1
+            if k == n:
+                break
+
+            last_move[k] += 1
+            step_sign = -1 if (last_move[k] % 2 == 0) else 1
+            step_mag = (last_move[k] + 1) // 2
+
+            x[k] = round(c[k]) + (step_sign * step_mag)
+
+    return best_coeffs
+
+
+@validate_aliases
+def shortest_vector(lattice_basis: SquareMatrix) -> Vector:
+    """_summary_
+
+    Parameters
+    ----------
+    lattice_basis : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    Vector
+        _description_
+    """
+    B = lll(lattice_basis)
+    B_star, U = gso(B)
+    B_norms2 = as_rational([sum(x * x for x in v) for v in B_star])
+    mu = U.T
+    coeffs = schnorr_euchner_svp(mu, B_norms2)
+    return coeffs @ B

pqlattice/lattice/embeddings.py

@@ -0,0 +1,3 @@
+from ._embeddings import bai_galbraith, kannan, lwe_basis, ntru, sis_basis, subset_sum
+
+__all__ = ["sis_basis", "lwe_basis", "ntru", "kannan", "bai_galbraith", "subset_sum"]

pqlattice/linalg/__init__.py

@@ -0,0 +1,37 @@
+from .. import settings
+from ..typing import Matrix, SquareMatrix
+from ._linalg import cofactor, cofactor_matrix, det, left_kernel, left_nullity, minor, rank, right_kernel, right_nullity
+from ._modint import mod_left_kernel, mod_left_nullity, mod_matinv, mod_ref, mod_right_kernel, mod_right_nullity, mod_rref
+from ._utils import norm, norm2, per_row_norm, per_row_norm2, row_add, row_scale, row_swap
+
+
+def hnf(matrix: SquareMatrix) -> tuple[Matrix, SquareMatrix]:
+    return settings.get_backend().hnf(matrix)
+
+
+__all__ = [
+    "hnf",
+    "det",
+    "left_kernel",
+    "right_kernel",
+    "left_nullity",
+    "right_nullity",
+    "rank",
+    "minor",
+    "cofactor",
+    "cofactor_matrix",
+    "norm",
+    "norm2",
+    "per_row_norm",
+    "per_row_norm2",
+    "row_add",
+    "row_scale",
+    "row_swap",
+    "mod_ref",
+    "mod_rref",
+    "mod_right_kernel",
+    "mod_left_kernel",
+    "mod_left_nullity",
+    "mod_right_nullity",
+    "mod_matinv",
+]

pqlattice/linalg/_linalg.py

@@ -0,0 +1,306 @@
+from functools import reduce
+
+import numpy as np
+
+from .._utils import as_integer
+from ..typing import Matrix, SquareMatrix, Vector, validate_aliases
+from ._utils import row_add, row_scale, row_swap
+
+
+@validate_aliases
+def hnf(A: Matrix) -> tuple[Matrix, SquareMatrix]:
+    """_summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+
+    Returns
+    -------
+    tuple[Matrix, SquareMatrix]
+        _description_
+    """
+    H, U, _ = _hnf(A)
+    return H, U
+
+
+@validate_aliases
+def _hnf(a: Matrix) -> tuple[Matrix, SquareMatrix, int]:
+    H = np.array(a, dtype=object)
+    m, n = H.shape
+    U = np.eye(m, dtype=object)
+    pivot_row = 0
+    pivot_col = 0
+    det_U = 1
+
+    while pivot_row < m and pivot_col < n:
+        # pivot selection
+        if np.all(H[pivot_row:, pivot_col] == 0):
+            pivot_col += 1
+            continue
+
+        candidates = [(abs(H[i, pivot_col]), i) for i in range(pivot_row, m) if H[i, pivot_col] != 0]
+        _, best_row = min(candidates)
+
+        row_swap(H, pivot_row, best_row)
+        row_swap(U, pivot_row, best_row)
+        det_U *= -1
+
+        # clear below pivot
+        for i in range(pivot_row + 1, m):
+            while H[i, pivot_col] != 0:
+                factor = H[i, pivot_col] // H[pivot_row, pivot_col]
+
+                row_add(H, i, pivot_row, -factor)
+                row_add(U, i, pivot_row, -factor)
+
+                if H[i, pivot_col] != 0:
+                    row_swap(H, pivot_row, i)
+                    row_swap(U, pivot_row, i)
+                    det_U *= -1
+
+        if H[pivot_row, pivot_col] < 0:
+            row_scale(H, pivot_row, -1)
+            row_scale(U, pivot_row, -1)
+            det_U *= -1
+
+        pivot_val = H[pivot_row, pivot_col]
+
+        for i in range(pivot_row):
+            factor = H[i, pivot_col] // pivot_val
+            row_add(H, i, pivot_row, -factor)
+            row_add(U, i, pivot_row, -factor)
+
+        pivot_row += 1
+        pivot_col += 1
+
+    return H, U, det_U
+
+
+@validate_aliases
+def right_image(A: Matrix) -> Matrix:
+    """
+    _summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+
+    Returns
+    -------
+    Matrix
+        _description_
+    """
+    return left_image(A.T).T
+
+
+@validate_aliases
+def left_image(A: Matrix) -> Matrix:
+    """
+    _summary_
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+
+    Returns
+    -------
+    Matrix
+        _description_
+    """
+    H, _ = hnf(A)
+
+    m, _ = H.shape
+    k = 0
+    for i in range(m):
+        if np.all(H[i] == 0):
+            k = i
+            break
+
+    return as_integer(H[:k])
+
+
+@validate_aliases
+def left_kernel(A: Matrix):
+    """
+    {x : xA = 0}
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+
+    Returns
+    -------
+    _type_
+        _description_
+    """
+    H, U = hnf(A)
+    kernel_basis: list[Vector] = []
+
+    m, _ = H.shape
+    for i in range(m):
+        if np.all(H[i] == 0):
+            kernel_basis.append(U[i])
+
+    return np.array(kernel_basis, dtype=object)
+
+
+@validate_aliases
+def right_kernel(A: Matrix) -> Matrix:
+    """
+    {x : Ax = 0}
+
+    Parameters
+    ----------
+    A : Matrix
+        _description_
+
+    Returns
+    -------
+    Matrix
+        _description_
+    """
+    return left_kernel(A.T)
+
+
+@validate_aliases
+def left_nullity(a: Matrix) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    a : Matrix
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    kernel = left_kernel(a)
+    return kernel.shape[0]
+
+
+@validate_aliases
+def right_nullity(a: Matrix) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    a : Matrix
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    kernel = right_kernel(a)
+    return kernel.shape[0]
+
+
+def rank(a: Matrix) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    a : Matrix
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    m, n = a.shape
+    l_rank = m - left_nullity(a)
+    r_rank = n - right_nullity(a)
+    assert l_rank == r_rank
+    return l_rank
+
+
+@validate_aliases
+def det(A: SquareMatrix) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    A : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    H, _, det_U = _hnf(A)
+
+    return reduce(lambda a, b: a * b, np.diagonal(H), 1) * det_U
+
+
+@validate_aliases
+def minor(A: SquareMatrix, i: int, j: int) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    A : SquareMatrix
+        _description_
+    i : int
+        _description_
+    j : int
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    return det(np.delete(np.delete(A, i, axis=0), j, axis=1))
+
+
+@validate_aliases
+def cofactor(A: SquareMatrix, i: int, j: int) -> int:
+    """_summary_
+
+    Parameters
+    ----------
+    A : SquareMatrix
+        _description_
+    i : int
+        _description_
+    j : int
+        _description_
+
+    Returns
+    -------
+    int
+        _description_
+    """
+    return minor(A, i, j) * ((-1) ** (i + 1 + j + 1))
+
+
+@validate_aliases
+def cofactor_matrix(A: SquareMatrix) -> SquareMatrix:
+    """_summary_
+
+    Parameters
+    ----------
+    A : SquareMatrix
+        _description_
+
+    Returns
+    -------
+    SquareMatrix
+        _description_
+    """
+    n = A.shape[0]
+    C = np.zeros((n, n), dtype=object)
+    for i in range(n):
+        for j in range(n):
+            C[i, j] = cofactor(A, i, j)
+    return C