phanerozoic commited on Jul 19

Commit

bc94f1d

verified ·

1 Parent(s): 92f7d9a

Uploaded using `kernel-builder`.

Browse files

Files changed (45) hide show

build/torch211-cxx11-cu126-x86_64-linux/__init__.py +267 -0
build/torch211-cxx11-cu126-x86_64-linux/_groebner_cuda_0bb395a.abi3.so +3 -0
build/torch211-cxx11-cu126-x86_64-linux/_ops.py +9 -0
build/torch211-cxx11-cu126-x86_64-linux/groebner/__init__.py +26 -0
build/torch211-cxx11-cu126-x86_64-linux/metadata.json +36 -0
build/torch211-cxx11-cu128-x86_64-linux/__init__.py +267 -0
build/torch211-cxx11-cu128-x86_64-linux/_groebner_cuda_0bb395a.abi3.so +3 -0
build/torch211-cxx11-cu128-x86_64-linux/_ops.py +9 -0
build/torch211-cxx11-cu128-x86_64-linux/groebner/__init__.py +26 -0
build/torch211-cxx11-cu128-x86_64-linux/metadata.json +38 -0
build/torch211-cxx11-cu130-x86_64-linux/__init__.py +267 -0
build/torch211-cxx11-cu130-x86_64-linux/_groebner_cuda_0bb395a.abi3.so +3 -0
build/torch211-cxx11-cu130-x86_64-linux/_ops.py +9 -0
build/torch211-cxx11-cu130-x86_64-linux/groebner/__init__.py +26 -0
build/torch211-cxx11-cu130-x86_64-linux/metadata.json +38 -0
build/torch212-cxx11-cu126-x86_64-linux/__init__.py +267 -0
build/torch212-cxx11-cu126-x86_64-linux/_groebner_cuda_0bb395a.abi3.so +3 -0
build/torch212-cxx11-cu126-x86_64-linux/_ops.py +9 -0
build/torch212-cxx11-cu126-x86_64-linux/groebner/__init__.py +26 -0
build/torch212-cxx11-cu126-x86_64-linux/metadata.json +36 -0
build/torch212-cxx11-cu130-x86_64-linux/__init__.py +267 -0
build/torch212-cxx11-cu130-x86_64-linux/_groebner_cuda_0bb395a.abi3.so +3 -0
build/torch212-cxx11-cu130-x86_64-linux/_ops.py +9 -0
build/torch212-cxx11-cu130-x86_64-linux/groebner/__init__.py +26 -0
build/torch212-cxx11-cu130-x86_64-linux/metadata.json +38 -0
build/torch212-cxx11-cu132-x86_64-linux/__init__.py +267 -0
build/torch212-cxx11-cu132-x86_64-linux/_groebner_cuda_0bb395a.abi3.so +3 -0
build/torch212-cxx11-cu132-x86_64-linux/_ops.py +9 -0
build/torch212-cxx11-cu132-x86_64-linux/groebner/__init__.py +26 -0
build/torch212-cxx11-cu132-x86_64-linux/metadata.json +38 -0
build/torch213-cxx11-cu126-x86_64-linux/__init__.py +267 -0
build/torch213-cxx11-cu126-x86_64-linux/_groebner_cuda_0bb395a.abi3.so +3 -0
build/torch213-cxx11-cu126-x86_64-linux/_ops.py +9 -0
build/torch213-cxx11-cu126-x86_64-linux/groebner/__init__.py +26 -0
build/torch213-cxx11-cu126-x86_64-linux/metadata.json +36 -0
build/torch213-cxx11-cu130-x86_64-linux/__init__.py +267 -0
build/torch213-cxx11-cu130-x86_64-linux/_groebner_cuda_0bb395a.abi3.so +3 -0
build/torch213-cxx11-cu130-x86_64-linux/_ops.py +9 -0
build/torch213-cxx11-cu130-x86_64-linux/groebner/__init__.py +26 -0
build/torch213-cxx11-cu130-x86_64-linux/metadata.json +38 -0
build/torch213-cxx11-cu132-x86_64-linux/__init__.py +267 -0
build/torch213-cxx11-cu132-x86_64-linux/_groebner_cuda_0bb395a.abi3.so +3 -0
build/torch213-cxx11-cu132-x86_64-linux/_ops.py +9 -0
build/torch213-cxx11-cu132-x86_64-linux/groebner/__init__.py +26 -0
build/torch213-cxx11-cu132-x86_64-linux/metadata.json +38 -0

build/torch211-cxx11-cu126-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,267 @@

+"""groebner: Groebner bases over F_p with GPU Macaulay matrix reduction.
+Implements an F4-style algorithm in degree-reverse-lexicographic order. Critical
+pairs of minimal lcm degree are processed as a batch: their S-polynomial rows
+plus every reductor found by symbolic preprocessing form a Macaulay matrix whose
+columns are monomials, and that matrix is reduced to reduced row echelon form on
+the GPU. Rows whose leading monomial is not already divisible by a leading
+monomial of the basis become new basis elements.
+    groebner_basis(polys, nvars, prime)  -> reduced Groebner basis
+Polynomials are dicts mapping exponent tuples to coefficients in F_p.
+Reference baselines: msolve, Singular ``std``.
+"""
+from itertools import combinations
+import torch
+from ._ops import ops
+__all__ = ["groebner_basis", "monomial_key", "spoly", "normal_form", "is_groebner_basis"]
+# ---------------------------------------------------------------- monomials
+def monomial_key(exps):
+    """Sort key for degree-reverse-lexicographic order, ascending."""
+    return (sum(exps), tuple(-e for e in reversed(exps)))
+def _mul(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+def _div(a, b):
+    """a / b when b divides a, else None."""
+    out = []
+    for x, y in zip(a, b):
+        if x < y:
+            return None
+        out.append(x - y)
+    return tuple(out)
+def _lcm(a, b):
+    return tuple(max(x, y) for x, y in zip(a, b))
+def _divides(b, a):
+    return all(y <= x for x, y in zip(a, b))
+def _lead(poly):
+    """Leading monomial in degrevlex."""
+    return max(poly, key=monomial_key)
+# ---------------------------------------------------------------- polynomials
+def _normalize(poly, p):
+    out = {}
+    for m, c in poly.items():
+        c %= p
+        if c:
+            out[m] = c
+    return out
+def _scale_shift(poly, mono, coeff, p):
+    return {_mul(m, mono): (c * coeff) % p for m, c in poly.items()}
+def _sub(f, g, p):
+    out = dict(f)
+    for m, c in g.items():
+        v = (out.get(m, 0) - c) % p
+        if v:
+            out[m] = v
+        elif m in out:
+            del out[m]
+    return out
+def spoly(f, g, p):
+    """S-polynomial of two nonzero polynomials over F_p."""
+    lf, lg = _lead(f), _lead(g)
+    L = _lcm(lf, lg)
+    a = _scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p)
+    b = _scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p)
+    return _sub(a, b, p)
+def normal_form(f, basis, p):
+    """Fully reduce ``f`` modulo ``basis`` in degrevlex."""
+    f = _normalize(f, p)
+    out = {}
+    while f:
+        m = _lead(f)
+        c = f[m]
+        for g in basis:
+            lg = _lead(g)
+            q = _div(m, lg)
+            if q is not None:
+                factor = (c * pow(g[lg], -1, p)) % p
+                f = _sub(f, _scale_shift(g, q, factor, p), p)
+                break
+        else:
+            out[m] = c
+            del f[m]
+    return out
+# ---------------------------------------------------------------- reduction
+def _reduce_matrix(rows, monomials, prime, device):
+    """Reduce the Macaulay matrix on the GPU, returning its nonzero rows."""
+    index = {m: i for i, m in enumerate(monomials)}
+    m, n = len(rows), len(monomials)
+    dense = torch.zeros(m, n, dtype=torch.int32)
+    flat = dense.view(-1)
+    for r, poly in enumerate(rows):
+        base = r * n
+        for mono, coeff in poly.items():
+            flat[base + index[mono]] = coeff % prime
+    dense = dense.to(device).contiguous()
+    rank = torch.zeros(1, dtype=torch.int32, device=device)
+    piv = torch.full((m,), -1, dtype=torch.int32, device=device)
+    ops.groebner_reduce(dense, rank, piv, prime)
+    r = int(rank.item())
+    if r == 0:
+        return []
+    host = dense[:r].cpu().numpy()
+    out = []
+    for i in range(r):
+        row = host[i]
+        nz = row.nonzero()[0]
+        out.append({monomials[j]: int(row[j]) for j in nz})
+    return out
+def _symbolic_preprocess(rows, basis, p):
+    """Close the row set under reduction by the basis leading monomials."""
+    monomials = set()
+    for poly in rows:
+        monomials.update(poly)
+    done = set()
+    rows = list(rows)
+    while True:
+        pending = monomials - done
+        if not pending:
+            break
+        for mono in sorted(pending, key=monomial_key, reverse=True):
+            done.add(mono)
+            for g in basis:
+                lg = _lead(g)
+                q = _div(mono, lg)
+                if q is not None:
+                    row = _scale_shift(g, q, pow(g[lg], -1, p), p)
+                    rows.append(row)
+                    monomials.update(row)
+                    break
+    return rows, monomials
+# ---------------------------------------------------------------- driver
+def groebner_basis(polys, nvars, prime, device=None):
+    """Reduced Groebner basis of the ideal generated by ``polys`` over F_p.
+    Args:
+        polys: iterable of dicts mapping length-``nvars`` exponent tuples to
+            integer coefficients.
+        nvars: number of variables.
+        prime: field characteristic, an odd prime below 2^31.
+        device: torch device; defaults to ``cuda``.
+    Returns:
+        the reduced Groebner basis in degree-reverse-lexicographic order, each
+        element monic, sorted by descending leading monomial.
+    """
+    device = torch.device("cuda") if device is None else device
+    p = int(prime)
+    basis = [_normalize(f, p) for f in polys]
+    basis = [f for f in basis if f]
+    if not basis:
+        return []
+    for f in basis:
+        if len(_lead(f)) != nvars:
+            raise ValueError("every exponent tuple must have length nvars")
+    pairs = {frozenset((i, j)) for i, j in combinations(range(len(basis)), 2)}
+    while pairs:
+        # Normal selection: take every pair whose lcm has minimal degree.
+        info = []
+        for pair in pairs:
+            i, j = tuple(pair) if len(pair) == 2 else (min(pair), min(pair))
+            L = _lcm(_lead(basis[i]), _lead(basis[j]))
+            info.append((sum(L), L, i, j, pair))
+        mindeg = min(x[0] for x in info)
+        batch = [x for x in info if x[0] == mindeg]
+        for x in batch:
+            pairs.discard(x[4])
+        rows = []
+        for _, L, i, j, _ in batch:
+            f, g = basis[i], basis[j]
+            lf, lg = _lead(f), _lead(g)
+            # Coprime leading monomials give an S-polynomial that reduces to
+            # zero by Buchberger's first criterion; the pair carries no
+            # information and is skipped.
+            if _mul(lf, lg) == L:
+                continue
+            rows.append(_scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p))
+            rows.append(_scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p))
+        if not rows:
+            continue
+        rows, monomials = _symbolic_preprocess(rows, basis, p)
+        ordered = sorted(monomials, key=monomial_key, reverse=True)
+        reduced = _reduce_matrix(rows, ordered, p, device)
+        leads = [_lead(g) for g in basis]
+        for row in reduced:
+            lm = _lead(row)
+            if any(_divides(l, lm) for l in leads):
+                continue
+            basis.append(row)
+            leads.append(lm)
+            new = len(basis) - 1
+            for k in range(new):
+                pairs.add(frozenset((k, new)))
+    return _interreduce(basis, p)
+def _interreduce(basis, p):
+    """Drop redundant elements and fully reduce the survivors."""
+    leads = [_lead(g) for g in basis]
+    keep = []
+    for i, g in enumerate(basis):
+        if any(j != i and _divides(leads[j], leads[i]) and
+               (leads[j] != leads[i] or j < i) for j in range(len(basis))):
+            continue
+        keep.append(g)
+    out = []
+    for i, g in enumerate(keep):
+        others = keep[:i] + keep[i + 1:] + out
+        r = normal_form(g, [h for h in others if h], p)
+        if r:
+            lm = _lead(r)
+            out.append(_scale_shift(r, tuple([0] * len(lm)), pow(r[lm], -1, p), p))
+    return sorted(out, key=lambda g: monomial_key(_lead(g)), reverse=True)
+def is_groebner_basis(basis, prime):
+    """True when every S-polynomial of the basis reduces to zero."""
+    p = int(prime)
+    for f, g in combinations(basis, 2):
+        if normal_form(spoly(f, g, p), basis, p):
+            return False
+    return True

build/torch211-cxx11-cu126-x86_64-linux/_groebner_cuda_0bb395a.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:02499b3bf1c8ad4a4e1ab540e409f869174d6e710b0c55a5e2ffa330a2f51850
+size 166200

build/torch211-cxx11-cu126-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _groebner_cuda_0bb395a
+ops = torch.ops._groebner_cuda_0bb395a
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_groebner_cuda_0bb395a::{op_name}"

build/torch211-cxx11-cu126-x86_64-linux/groebner/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch211-cxx11-cu126-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,36 @@

+{
+  "name": "groebner",
+  "id": "_groebner_cuda_0bb395a",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "CpsyiOVGquYAg8QliZu4XdtavY7LBxkm/VqYtFWi+1o=",
+      "_groebner_cuda_0bb395a.abi3.so": "AkmbO/HIrUpOGrVA5An4aRdNbnELDFWl4v+jMKL1GFA=",
+      "_ops.py": "HBf/A1FZVh5Vgeu7QDu0SfwcwNiTAPBSdQ0M9mx+p7M=",
+      "groebner/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "0bb395ae2658cdd9257c1433b06492b34c1a1378",
+      "dirty": false
+    }
+  }
+}

build/torch211-cxx11-cu128-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,267 @@

+"""groebner: Groebner bases over F_p with GPU Macaulay matrix reduction.
+Implements an F4-style algorithm in degree-reverse-lexicographic order. Critical
+pairs of minimal lcm degree are processed as a batch: their S-polynomial rows
+plus every reductor found by symbolic preprocessing form a Macaulay matrix whose
+columns are monomials, and that matrix is reduced to reduced row echelon form on
+the GPU. Rows whose leading monomial is not already divisible by a leading
+monomial of the basis become new basis elements.
+    groebner_basis(polys, nvars, prime)  -> reduced Groebner basis
+Polynomials are dicts mapping exponent tuples to coefficients in F_p.
+Reference baselines: msolve, Singular ``std``.
+"""
+from itertools import combinations
+import torch
+from ._ops import ops
+__all__ = ["groebner_basis", "monomial_key", "spoly", "normal_form", "is_groebner_basis"]
+# ---------------------------------------------------------------- monomials
+def monomial_key(exps):
+    """Sort key for degree-reverse-lexicographic order, ascending."""
+    return (sum(exps), tuple(-e for e in reversed(exps)))
+def _mul(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+def _div(a, b):
+    """a / b when b divides a, else None."""
+    out = []
+    for x, y in zip(a, b):
+        if x < y:
+            return None
+        out.append(x - y)
+    return tuple(out)
+def _lcm(a, b):
+    return tuple(max(x, y) for x, y in zip(a, b))
+def _divides(b, a):
+    return all(y <= x for x, y in zip(a, b))
+def _lead(poly):
+    """Leading monomial in degrevlex."""
+    return max(poly, key=monomial_key)
+# ---------------------------------------------------------------- polynomials
+def _normalize(poly, p):
+    out = {}
+    for m, c in poly.items():
+        c %= p
+        if c:
+            out[m] = c
+    return out
+def _scale_shift(poly, mono, coeff, p):
+    return {_mul(m, mono): (c * coeff) % p for m, c in poly.items()}
+def _sub(f, g, p):
+    out = dict(f)
+    for m, c in g.items():
+        v = (out.get(m, 0) - c) % p
+        if v:
+            out[m] = v
+        elif m in out:
+            del out[m]
+    return out
+def spoly(f, g, p):
+    """S-polynomial of two nonzero polynomials over F_p."""
+    lf, lg = _lead(f), _lead(g)
+    L = _lcm(lf, lg)
+    a = _scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p)
+    b = _scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p)
+    return _sub(a, b, p)
+def normal_form(f, basis, p):
+    """Fully reduce ``f`` modulo ``basis`` in degrevlex."""
+    f = _normalize(f, p)
+    out = {}
+    while f:
+        m = _lead(f)
+        c = f[m]
+        for g in basis:
+            lg = _lead(g)
+            q = _div(m, lg)
+            if q is not None:
+                factor = (c * pow(g[lg], -1, p)) % p
+                f = _sub(f, _scale_shift(g, q, factor, p), p)
+                break
+        else:
+            out[m] = c
+            del f[m]
+    return out
+# ---------------------------------------------------------------- reduction
+def _reduce_matrix(rows, monomials, prime, device):
+    """Reduce the Macaulay matrix on the GPU, returning its nonzero rows."""
+    index = {m: i for i, m in enumerate(monomials)}
+    m, n = len(rows), len(monomials)
+    dense = torch.zeros(m, n, dtype=torch.int32)
+    flat = dense.view(-1)
+    for r, poly in enumerate(rows):
+        base = r * n
+        for mono, coeff in poly.items():
+            flat[base + index[mono]] = coeff % prime
+    dense = dense.to(device).contiguous()
+    rank = torch.zeros(1, dtype=torch.int32, device=device)
+    piv = torch.full((m,), -1, dtype=torch.int32, device=device)
+    ops.groebner_reduce(dense, rank, piv, prime)
+    r = int(rank.item())
+    if r == 0:
+        return []
+    host = dense[:r].cpu().numpy()
+    out = []
+    for i in range(r):
+        row = host[i]
+        nz = row.nonzero()[0]
+        out.append({monomials[j]: int(row[j]) for j in nz})
+    return out
+def _symbolic_preprocess(rows, basis, p):
+    """Close the row set under reduction by the basis leading monomials."""
+    monomials = set()
+    for poly in rows:
+        monomials.update(poly)
+    done = set()
+    rows = list(rows)
+    while True:
+        pending = monomials - done
+        if not pending:
+            break
+        for mono in sorted(pending, key=monomial_key, reverse=True):
+            done.add(mono)
+            for g in basis:
+                lg = _lead(g)
+                q = _div(mono, lg)
+                if q is not None:
+                    row = _scale_shift(g, q, pow(g[lg], -1, p), p)
+                    rows.append(row)
+                    monomials.update(row)
+                    break
+    return rows, monomials
+# ---------------------------------------------------------------- driver
+def groebner_basis(polys, nvars, prime, device=None):
+    """Reduced Groebner basis of the ideal generated by ``polys`` over F_p.
+    Args:
+        polys: iterable of dicts mapping length-``nvars`` exponent tuples to
+            integer coefficients.
+        nvars: number of variables.
+        prime: field characteristic, an odd prime below 2^31.
+        device: torch device; defaults to ``cuda``.
+    Returns:
+        the reduced Groebner basis in degree-reverse-lexicographic order, each
+        element monic, sorted by descending leading monomial.
+    """
+    device = torch.device("cuda") if device is None else device
+    p = int(prime)
+    basis = [_normalize(f, p) for f in polys]
+    basis = [f for f in basis if f]
+    if not basis:
+        return []
+    for f in basis:
+        if len(_lead(f)) != nvars:
+            raise ValueError("every exponent tuple must have length nvars")
+    pairs = {frozenset((i, j)) for i, j in combinations(range(len(basis)), 2)}
+    while pairs:
+        # Normal selection: take every pair whose lcm has minimal degree.
+        info = []
+        for pair in pairs:
+            i, j = tuple(pair) if len(pair) == 2 else (min(pair), min(pair))
+            L = _lcm(_lead(basis[i]), _lead(basis[j]))
+            info.append((sum(L), L, i, j, pair))
+        mindeg = min(x[0] for x in info)
+        batch = [x for x in info if x[0] == mindeg]
+        for x in batch:
+            pairs.discard(x[4])
+        rows = []
+        for _, L, i, j, _ in batch:
+            f, g = basis[i], basis[j]
+            lf, lg = _lead(f), _lead(g)
+            # Coprime leading monomials give an S-polynomial that reduces to
+            # zero by Buchberger's first criterion; the pair carries no
+            # information and is skipped.
+            if _mul(lf, lg) == L:
+                continue
+            rows.append(_scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p))
+            rows.append(_scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p))
+        if not rows:
+            continue
+        rows, monomials = _symbolic_preprocess(rows, basis, p)
+        ordered = sorted(monomials, key=monomial_key, reverse=True)
+        reduced = _reduce_matrix(rows, ordered, p, device)
+        leads = [_lead(g) for g in basis]
+        for row in reduced:
+            lm = _lead(row)
+            if any(_divides(l, lm) for l in leads):
+                continue
+            basis.append(row)
+            leads.append(lm)
+            new = len(basis) - 1
+            for k in range(new):
+                pairs.add(frozenset((k, new)))
+    return _interreduce(basis, p)
+def _interreduce(basis, p):
+    """Drop redundant elements and fully reduce the survivors."""
+    leads = [_lead(g) for g in basis]
+    keep = []
+    for i, g in enumerate(basis):
+        if any(j != i and _divides(leads[j], leads[i]) and
+               (leads[j] != leads[i] or j < i) for j in range(len(basis))):
+            continue
+        keep.append(g)
+    out = []
+    for i, g in enumerate(keep):
+        others = keep[:i] + keep[i + 1:] + out
+        r = normal_form(g, [h for h in others if h], p)
+        if r:
+            lm = _lead(r)
+            out.append(_scale_shift(r, tuple([0] * len(lm)), pow(r[lm], -1, p), p))
+    return sorted(out, key=lambda g: monomial_key(_lead(g)), reverse=True)
+def is_groebner_basis(basis, prime):
+    """True when every S-polynomial of the basis reduces to zero."""
+    p = int(prime)
+    for f, g in combinations(basis, 2):
+        if normal_form(spoly(f, g, p), basis, p):
+            return False
+    return True

build/torch211-cxx11-cu128-x86_64-linux/_groebner_cuda_0bb395a.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:b257474cc92ab20316c00b8c65f403ea8a06b8d42b7d29f0fd69861b5404e240
+size 224096

build/torch211-cxx11-cu128-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _groebner_cuda_0bb395a
+ops = torch.ops._groebner_cuda_0bb395a
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_groebner_cuda_0bb395a::{op_name}"

build/torch211-cxx11-cu128-x86_64-linux/groebner/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch211-cxx11-cu128-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "groebner",
+  "id": "_groebner_cuda_0bb395a",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "CpsyiOVGquYAg8QliZu4XdtavY7LBxkm/VqYtFWi+1o=",
+      "_groebner_cuda_0bb395a.abi3.so": "sldHTMkqsgMWwAuMZfQD6ooGuNQrfSnw/WmGG1QE4kA=",
+      "_ops.py": "HBf/A1FZVh5Vgeu7QDu0SfwcwNiTAPBSdQ0M9mx+p7M=",
+      "groebner/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "0bb395ae2658cdd9257c1433b06492b34c1a1378",
+      "dirty": false
+    }
+  }
+}

build/torch211-cxx11-cu130-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,267 @@

+"""groebner: Groebner bases over F_p with GPU Macaulay matrix reduction.
+Implements an F4-style algorithm in degree-reverse-lexicographic order. Critical
+pairs of minimal lcm degree are processed as a batch: their S-polynomial rows
+plus every reductor found by symbolic preprocessing form a Macaulay matrix whose
+columns are monomials, and that matrix is reduced to reduced row echelon form on
+the GPU. Rows whose leading monomial is not already divisible by a leading
+monomial of the basis become new basis elements.
+    groebner_basis(polys, nvars, prime)  -> reduced Groebner basis
+Polynomials are dicts mapping exponent tuples to coefficients in F_p.
+Reference baselines: msolve, Singular ``std``.
+"""
+from itertools import combinations
+import torch
+from ._ops import ops
+__all__ = ["groebner_basis", "monomial_key", "spoly", "normal_form", "is_groebner_basis"]
+# ---------------------------------------------------------------- monomials
+def monomial_key(exps):
+    """Sort key for degree-reverse-lexicographic order, ascending."""
+    return (sum(exps), tuple(-e for e in reversed(exps)))
+def _mul(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+def _div(a, b):
+    """a / b when b divides a, else None."""
+    out = []
+    for x, y in zip(a, b):
+        if x < y:
+            return None
+        out.append(x - y)
+    return tuple(out)
+def _lcm(a, b):
+    return tuple(max(x, y) for x, y in zip(a, b))
+def _divides(b, a):
+    return all(y <= x for x, y in zip(a, b))
+def _lead(poly):
+    """Leading monomial in degrevlex."""
+    return max(poly, key=monomial_key)
+# ---------------------------------------------------------------- polynomials
+def _normalize(poly, p):
+    out = {}
+    for m, c in poly.items():
+        c %= p
+        if c:
+            out[m] = c
+    return out
+def _scale_shift(poly, mono, coeff, p):
+    return {_mul(m, mono): (c * coeff) % p for m, c in poly.items()}
+def _sub(f, g, p):
+    out = dict(f)
+    for m, c in g.items():
+        v = (out.get(m, 0) - c) % p
+        if v:
+            out[m] = v
+        elif m in out:
+            del out[m]
+    return out
+def spoly(f, g, p):
+    """S-polynomial of two nonzero polynomials over F_p."""
+    lf, lg = _lead(f), _lead(g)
+    L = _lcm(lf, lg)
+    a = _scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p)
+    b = _scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p)
+    return _sub(a, b, p)
+def normal_form(f, basis, p):
+    """Fully reduce ``f`` modulo ``basis`` in degrevlex."""
+    f = _normalize(f, p)
+    out = {}
+    while f:
+        m = _lead(f)
+        c = f[m]
+        for g in basis:
+            lg = _lead(g)
+            q = _div(m, lg)
+            if q is not None:
+                factor = (c * pow(g[lg], -1, p)) % p
+                f = _sub(f, _scale_shift(g, q, factor, p), p)
+                break
+        else:
+            out[m] = c
+            del f[m]
+    return out
+# ---------------------------------------------------------------- reduction
+def _reduce_matrix(rows, monomials, prime, device):
+    """Reduce the Macaulay matrix on the GPU, returning its nonzero rows."""
+    index = {m: i for i, m in enumerate(monomials)}
+    m, n = len(rows), len(monomials)
+    dense = torch.zeros(m, n, dtype=torch.int32)
+    flat = dense.view(-1)
+    for r, poly in enumerate(rows):
+        base = r * n
+        for mono, coeff in poly.items():
+            flat[base + index[mono]] = coeff % prime
+    dense = dense.to(device).contiguous()
+    rank = torch.zeros(1, dtype=torch.int32, device=device)
+    piv = torch.full((m,), -1, dtype=torch.int32, device=device)
+    ops.groebner_reduce(dense, rank, piv, prime)
+    r = int(rank.item())
+    if r == 0:
+        return []
+    host = dense[:r].cpu().numpy()
+    out = []
+    for i in range(r):
+        row = host[i]
+        nz = row.nonzero()[0]
+        out.append({monomials[j]: int(row[j]) for j in nz})
+    return out
+def _symbolic_preprocess(rows, basis, p):
+    """Close the row set under reduction by the basis leading monomials."""
+    monomials = set()
+    for poly in rows:
+        monomials.update(poly)
+    done = set()
+    rows = list(rows)
+    while True:
+        pending = monomials - done
+        if not pending:
+            break
+        for mono in sorted(pending, key=monomial_key, reverse=True):
+            done.add(mono)
+            for g in basis:
+                lg = _lead(g)
+                q = _div(mono, lg)
+                if q is not None:
+                    row = _scale_shift(g, q, pow(g[lg], -1, p), p)
+                    rows.append(row)
+                    monomials.update(row)
+                    break
+    return rows, monomials
+# ---------------------------------------------------------------- driver
+def groebner_basis(polys, nvars, prime, device=None):
+    """Reduced Groebner basis of the ideal generated by ``polys`` over F_p.
+    Args:
+        polys: iterable of dicts mapping length-``nvars`` exponent tuples to
+            integer coefficients.
+        nvars: number of variables.
+        prime: field characteristic, an odd prime below 2^31.
+        device: torch device; defaults to ``cuda``.
+    Returns:
+        the reduced Groebner basis in degree-reverse-lexicographic order, each
+        element monic, sorted by descending leading monomial.
+    """
+    device = torch.device("cuda") if device is None else device
+    p = int(prime)
+    basis = [_normalize(f, p) for f in polys]
+    basis = [f for f in basis if f]
+    if not basis:
+        return []
+    for f in basis:
+        if len(_lead(f)) != nvars:
+            raise ValueError("every exponent tuple must have length nvars")
+    pairs = {frozenset((i, j)) for i, j in combinations(range(len(basis)), 2)}
+    while pairs:
+        # Normal selection: take every pair whose lcm has minimal degree.
+        info = []
+        for pair in pairs:
+            i, j = tuple(pair) if len(pair) == 2 else (min(pair), min(pair))
+            L = _lcm(_lead(basis[i]), _lead(basis[j]))
+            info.append((sum(L), L, i, j, pair))
+        mindeg = min(x[0] for x in info)
+        batch = [x for x in info if x[0] == mindeg]
+        for x in batch:
+            pairs.discard(x[4])
+        rows = []
+        for _, L, i, j, _ in batch:
+            f, g = basis[i], basis[j]
+            lf, lg = _lead(f), _lead(g)
+            # Coprime leading monomials give an S-polynomial that reduces to
+            # zero by Buchberger's first criterion; the pair carries no
+            # information and is skipped.
+            if _mul(lf, lg) == L:
+                continue
+            rows.append(_scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p))
+            rows.append(_scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p))
+        if not rows:
+            continue
+        rows, monomials = _symbolic_preprocess(rows, basis, p)
+        ordered = sorted(monomials, key=monomial_key, reverse=True)
+        reduced = _reduce_matrix(rows, ordered, p, device)
+        leads = [_lead(g) for g in basis]
+        for row in reduced:
+            lm = _lead(row)
+            if any(_divides(l, lm) for l in leads):
+                continue
+            basis.append(row)
+            leads.append(lm)
+            new = len(basis) - 1
+            for k in range(new):
+                pairs.add(frozenset((k, new)))
+    return _interreduce(basis, p)
+def _interreduce(basis, p):
+    """Drop redundant elements and fully reduce the survivors."""
+    leads = [_lead(g) for g in basis]
+    keep = []
+    for i, g in enumerate(basis):
+        if any(j != i and _divides(leads[j], leads[i]) and
+               (leads[j] != leads[i] or j < i) for j in range(len(basis))):
+            continue
+        keep.append(g)
+    out = []
+    for i, g in enumerate(keep):
+        others = keep[:i] + keep[i + 1:] + out
+        r = normal_form(g, [h for h in others if h], p)
+        if r:
+            lm = _lead(r)
+            out.append(_scale_shift(r, tuple([0] * len(lm)), pow(r[lm], -1, p), p))
+    return sorted(out, key=lambda g: monomial_key(_lead(g)), reverse=True)
+def is_groebner_basis(basis, prime):
+    """True when every S-polynomial of the basis reduces to zero."""
+    p = int(prime)
+    for f, g in combinations(basis, 2):
+        if normal_form(spoly(f, g, p), basis, p):
+            return False
+    return True

build/torch211-cxx11-cu130-x86_64-linux/_groebner_cuda_0bb395a.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:33d5a334a57e555aa2e83e343b1915ab1eafef9bc70706bb9e9f1e192846e23b
+size 252512

build/torch211-cxx11-cu130-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _groebner_cuda_0bb395a
+ops = torch.ops._groebner_cuda_0bb395a
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_groebner_cuda_0bb395a::{op_name}"

build/torch211-cxx11-cu130-x86_64-linux/groebner/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch211-cxx11-cu130-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "groebner",
+  "id": "_groebner_cuda_0bb395a",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "CpsyiOVGquYAg8QliZu4XdtavY7LBxkm/VqYtFWi+1o=",
+      "_groebner_cuda_0bb395a.abi3.so": "M9WjNKV+VVqi6D40OxkVqx6v75vHBwa7np8eGShG4js=",
+      "_ops.py": "HBf/A1FZVh5Vgeu7QDu0SfwcwNiTAPBSdQ0M9mx+p7M=",
+      "groebner/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "0bb395ae2658cdd9257c1433b06492b34c1a1378",
+      "dirty": false
+    }
+  }
+}

build/torch212-cxx11-cu126-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,267 @@

+"""groebner: Groebner bases over F_p with GPU Macaulay matrix reduction.
+Implements an F4-style algorithm in degree-reverse-lexicographic order. Critical
+pairs of minimal lcm degree are processed as a batch: their S-polynomial rows
+plus every reductor found by symbolic preprocessing form a Macaulay matrix whose
+columns are monomials, and that matrix is reduced to reduced row echelon form on
+the GPU. Rows whose leading monomial is not already divisible by a leading
+monomial of the basis become new basis elements.
+    groebner_basis(polys, nvars, prime)  -> reduced Groebner basis
+Polynomials are dicts mapping exponent tuples to coefficients in F_p.
+Reference baselines: msolve, Singular ``std``.
+"""
+from itertools import combinations
+import torch
+from ._ops import ops
+__all__ = ["groebner_basis", "monomial_key", "spoly", "normal_form", "is_groebner_basis"]
+# ---------------------------------------------------------------- monomials
+def monomial_key(exps):
+    """Sort key for degree-reverse-lexicographic order, ascending."""
+    return (sum(exps), tuple(-e for e in reversed(exps)))
+def _mul(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+def _div(a, b):
+    """a / b when b divides a, else None."""
+    out = []
+    for x, y in zip(a, b):
+        if x < y:
+            return None
+        out.append(x - y)
+    return tuple(out)
+def _lcm(a, b):
+    return tuple(max(x, y) for x, y in zip(a, b))
+def _divides(b, a):
+    return all(y <= x for x, y in zip(a, b))
+def _lead(poly):
+    """Leading monomial in degrevlex."""
+    return max(poly, key=monomial_key)
+# ---------------------------------------------------------------- polynomials
+def _normalize(poly, p):
+    out = {}
+    for m, c in poly.items():
+        c %= p
+        if c:
+            out[m] = c
+    return out
+def _scale_shift(poly, mono, coeff, p):
+    return {_mul(m, mono): (c * coeff) % p for m, c in poly.items()}
+def _sub(f, g, p):
+    out = dict(f)
+    for m, c in g.items():
+        v = (out.get(m, 0) - c) % p
+        if v:
+            out[m] = v
+        elif m in out:
+            del out[m]
+    return out
+def spoly(f, g, p):
+    """S-polynomial of two nonzero polynomials over F_p."""
+    lf, lg = _lead(f), _lead(g)
+    L = _lcm(lf, lg)
+    a = _scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p)
+    b = _scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p)
+    return _sub(a, b, p)
+def normal_form(f, basis, p):
+    """Fully reduce ``f`` modulo ``basis`` in degrevlex."""
+    f = _normalize(f, p)
+    out = {}
+    while f:
+        m = _lead(f)
+        c = f[m]
+        for g in basis:
+            lg = _lead(g)
+            q = _div(m, lg)
+            if q is not None:
+                factor = (c * pow(g[lg], -1, p)) % p
+                f = _sub(f, _scale_shift(g, q, factor, p), p)
+                break
+        else:
+            out[m] = c
+            del f[m]
+    return out
+# ---------------------------------------------------------------- reduction
+def _reduce_matrix(rows, monomials, prime, device):
+    """Reduce the Macaulay matrix on the GPU, returning its nonzero rows."""
+    index = {m: i for i, m in enumerate(monomials)}
+    m, n = len(rows), len(monomials)
+    dense = torch.zeros(m, n, dtype=torch.int32)
+    flat = dense.view(-1)
+    for r, poly in enumerate(rows):
+        base = r * n
+        for mono, coeff in poly.items():
+            flat[base + index[mono]] = coeff % prime
+    dense = dense.to(device).contiguous()
+    rank = torch.zeros(1, dtype=torch.int32, device=device)
+    piv = torch.full((m,), -1, dtype=torch.int32, device=device)
+    ops.groebner_reduce(dense, rank, piv, prime)
+    r = int(rank.item())
+    if r == 0:
+        return []
+    host = dense[:r].cpu().numpy()
+    out = []
+    for i in range(r):
+        row = host[i]
+        nz = row.nonzero()[0]
+        out.append({monomials[j]: int(row[j]) for j in nz})
+    return out
+def _symbolic_preprocess(rows, basis, p):
+    """Close the row set under reduction by the basis leading monomials."""
+    monomials = set()
+    for poly in rows:
+        monomials.update(poly)
+    done = set()
+    rows = list(rows)
+    while True:
+        pending = monomials - done
+        if not pending:
+            break
+        for mono in sorted(pending, key=monomial_key, reverse=True):
+            done.add(mono)
+            for g in basis:
+                lg = _lead(g)
+                q = _div(mono, lg)
+                if q is not None:
+                    row = _scale_shift(g, q, pow(g[lg], -1, p), p)
+                    rows.append(row)
+                    monomials.update(row)
+                    break
+    return rows, monomials
+# ---------------------------------------------------------------- driver
+def groebner_basis(polys, nvars, prime, device=None):
+    """Reduced Groebner basis of the ideal generated by ``polys`` over F_p.
+    Args:
+        polys: iterable of dicts mapping length-``nvars`` exponent tuples to
+            integer coefficients.
+        nvars: number of variables.
+        prime: field characteristic, an odd prime below 2^31.
+        device: torch device; defaults to ``cuda``.
+    Returns:
+        the reduced Groebner basis in degree-reverse-lexicographic order, each
+        element monic, sorted by descending leading monomial.
+    """
+    device = torch.device("cuda") if device is None else device
+    p = int(prime)
+    basis = [_normalize(f, p) for f in polys]
+    basis = [f for f in basis if f]
+    if not basis:
+        return []
+    for f in basis:
+        if len(_lead(f)) != nvars:
+            raise ValueError("every exponent tuple must have length nvars")
+    pairs = {frozenset((i, j)) for i, j in combinations(range(len(basis)), 2)}
+    while pairs:
+        # Normal selection: take every pair whose lcm has minimal degree.
+        info = []
+        for pair in pairs:
+            i, j = tuple(pair) if len(pair) == 2 else (min(pair), min(pair))
+            L = _lcm(_lead(basis[i]), _lead(basis[j]))
+            info.append((sum(L), L, i, j, pair))
+        mindeg = min(x[0] for x in info)
+        batch = [x for x in info if x[0] == mindeg]
+        for x in batch:
+            pairs.discard(x[4])
+        rows = []
+        for _, L, i, j, _ in batch:
+            f, g = basis[i], basis[j]
+            lf, lg = _lead(f), _lead(g)
+            # Coprime leading monomials give an S-polynomial that reduces to
+            # zero by Buchberger's first criterion; the pair carries no
+            # information and is skipped.
+            if _mul(lf, lg) == L:
+                continue
+            rows.append(_scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p))
+            rows.append(_scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p))
+        if not rows:
+            continue
+        rows, monomials = _symbolic_preprocess(rows, basis, p)
+        ordered = sorted(monomials, key=monomial_key, reverse=True)
+        reduced = _reduce_matrix(rows, ordered, p, device)
+        leads = [_lead(g) for g in basis]
+        for row in reduced:
+            lm = _lead(row)
+            if any(_divides(l, lm) for l in leads):
+                continue
+            basis.append(row)
+            leads.append(lm)
+            new = len(basis) - 1
+            for k in range(new):
+                pairs.add(frozenset((k, new)))
+    return _interreduce(basis, p)
+def _interreduce(basis, p):
+    """Drop redundant elements and fully reduce the survivors."""
+    leads = [_lead(g) for g in basis]
+    keep = []
+    for i, g in enumerate(basis):
+        if any(j != i and _divides(leads[j], leads[i]) and
+               (leads[j] != leads[i] or j < i) for j in range(len(basis))):
+            continue
+        keep.append(g)
+    out = []
+    for i, g in enumerate(keep):
+        others = keep[:i] + keep[i + 1:] + out
+        r = normal_form(g, [h for h in others if h], p)
+        if r:
+            lm = _lead(r)
+            out.append(_scale_shift(r, tuple([0] * len(lm)), pow(r[lm], -1, p), p))
+    return sorted(out, key=lambda g: monomial_key(_lead(g)), reverse=True)
+def is_groebner_basis(basis, prime):
+    """True when every S-polynomial of the basis reduces to zero."""
+    p = int(prime)
+    for f, g in combinations(basis, 2):
+        if normal_form(spoly(f, g, p), basis, p):
+            return False
+    return True

build/torch212-cxx11-cu126-x86_64-linux/_groebner_cuda_0bb395a.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:858c0fc1e15106567adf8ff66bacea5e5315b866b7b841585a8b4f8160036383
+size 177112

build/torch212-cxx11-cu126-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _groebner_cuda_0bb395a
+ops = torch.ops._groebner_cuda_0bb395a
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_groebner_cuda_0bb395a::{op_name}"

build/torch212-cxx11-cu126-x86_64-linux/groebner/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch212-cxx11-cu126-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,36 @@

+{
+  "name": "groebner",
+  "id": "_groebner_cuda_0bb395a",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "CpsyiOVGquYAg8QliZu4XdtavY7LBxkm/VqYtFWi+1o=",
+      "_groebner_cuda_0bb395a.abi3.so": "hYwPweFRBlZ634/2a6zqXlMVuGa3uEFYWotPgWADY4M=",
+      "_ops.py": "HBf/A1FZVh5Vgeu7QDu0SfwcwNiTAPBSdQ0M9mx+p7M=",
+      "groebner/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "0bb395ae2658cdd9257c1433b06492b34c1a1378",
+      "dirty": false
+    }
+  }
+}

build/torch212-cxx11-cu130-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,267 @@

+"""groebner: Groebner bases over F_p with GPU Macaulay matrix reduction.
+Implements an F4-style algorithm in degree-reverse-lexicographic order. Critical
+pairs of minimal lcm degree are processed as a batch: their S-polynomial rows
+plus every reductor found by symbolic preprocessing form a Macaulay matrix whose
+columns are monomials, and that matrix is reduced to reduced row echelon form on
+the GPU. Rows whose leading monomial is not already divisible by a leading
+monomial of the basis become new basis elements.
+    groebner_basis(polys, nvars, prime)  -> reduced Groebner basis
+Polynomials are dicts mapping exponent tuples to coefficients in F_p.
+Reference baselines: msolve, Singular ``std``.
+"""
+from itertools import combinations
+import torch
+from ._ops import ops
+__all__ = ["groebner_basis", "monomial_key", "spoly", "normal_form", "is_groebner_basis"]
+# ---------------------------------------------------------------- monomials
+def monomial_key(exps):
+    """Sort key for degree-reverse-lexicographic order, ascending."""
+    return (sum(exps), tuple(-e for e in reversed(exps)))
+def _mul(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+def _div(a, b):
+    """a / b when b divides a, else None."""
+    out = []
+    for x, y in zip(a, b):
+        if x < y:
+            return None
+        out.append(x - y)
+    return tuple(out)
+def _lcm(a, b):
+    return tuple(max(x, y) for x, y in zip(a, b))
+def _divides(b, a):
+    return all(y <= x for x, y in zip(a, b))
+def _lead(poly):
+    """Leading monomial in degrevlex."""
+    return max(poly, key=monomial_key)
+# ---------------------------------------------------------------- polynomials
+def _normalize(poly, p):
+    out = {}
+    for m, c in poly.items():
+        c %= p
+        if c:
+            out[m] = c
+    return out
+def _scale_shift(poly, mono, coeff, p):
+    return {_mul(m, mono): (c * coeff) % p for m, c in poly.items()}
+def _sub(f, g, p):
+    out = dict(f)
+    for m, c in g.items():
+        v = (out.get(m, 0) - c) % p
+        if v:
+            out[m] = v
+        elif m in out:
+            del out[m]
+    return out
+def spoly(f, g, p):
+    """S-polynomial of two nonzero polynomials over F_p."""
+    lf, lg = _lead(f), _lead(g)
+    L = _lcm(lf, lg)
+    a = _scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p)
+    b = _scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p)
+    return _sub(a, b, p)
+def normal_form(f, basis, p):
+    """Fully reduce ``f`` modulo ``basis`` in degrevlex."""
+    f = _normalize(f, p)
+    out = {}
+    while f:
+        m = _lead(f)
+        c = f[m]
+        for g in basis:
+            lg = _lead(g)
+            q = _div(m, lg)
+            if q is not None:
+                factor = (c * pow(g[lg], -1, p)) % p
+                f = _sub(f, _scale_shift(g, q, factor, p), p)
+                break
+        else:
+            out[m] = c
+            del f[m]
+    return out
+# ---------------------------------------------------------------- reduction
+def _reduce_matrix(rows, monomials, prime, device):
+    """Reduce the Macaulay matrix on the GPU, returning its nonzero rows."""
+    index = {m: i for i, m in enumerate(monomials)}
+    m, n = len(rows), len(monomials)
+    dense = torch.zeros(m, n, dtype=torch.int32)
+    flat = dense.view(-1)
+    for r, poly in enumerate(rows):
+        base = r * n
+        for mono, coeff in poly.items():
+            flat[base + index[mono]] = coeff % prime
+    dense = dense.to(device).contiguous()
+    rank = torch.zeros(1, dtype=torch.int32, device=device)
+    piv = torch.full((m,), -1, dtype=torch.int32, device=device)
+    ops.groebner_reduce(dense, rank, piv, prime)
+    r = int(rank.item())
+    if r == 0:
+        return []
+    host = dense[:r].cpu().numpy()
+    out = []
+    for i in range(r):
+        row = host[i]
+        nz = row.nonzero()[0]
+        out.append({monomials[j]: int(row[j]) for j in nz})
+    return out
+def _symbolic_preprocess(rows, basis, p):
+    """Close the row set under reduction by the basis leading monomials."""
+    monomials = set()
+    for poly in rows:
+        monomials.update(poly)
+    done = set()
+    rows = list(rows)
+    while True:
+        pending = monomials - done
+        if not pending:
+            break
+        for mono in sorted(pending, key=monomial_key, reverse=True):
+            done.add(mono)
+            for g in basis:
+                lg = _lead(g)
+                q = _div(mono, lg)
+                if q is not None:
+                    row = _scale_shift(g, q, pow(g[lg], -1, p), p)
+                    rows.append(row)
+                    monomials.update(row)
+                    break
+    return rows, monomials
+# ---------------------------------------------------------------- driver
+def groebner_basis(polys, nvars, prime, device=None):
+    """Reduced Groebner basis of the ideal generated by ``polys`` over F_p.
+    Args:
+        polys: iterable of dicts mapping length-``nvars`` exponent tuples to
+            integer coefficients.
+        nvars: number of variables.
+        prime: field characteristic, an odd prime below 2^31.
+        device: torch device; defaults to ``cuda``.
+    Returns:
+        the reduced Groebner basis in degree-reverse-lexicographic order, each
+        element monic, sorted by descending leading monomial.
+    """
+    device = torch.device("cuda") if device is None else device
+    p = int(prime)
+    basis = [_normalize(f, p) for f in polys]
+    basis = [f for f in basis if f]
+    if not basis:
+        return []
+    for f in basis:
+        if len(_lead(f)) != nvars:
+            raise ValueError("every exponent tuple must have length nvars")
+    pairs = {frozenset((i, j)) for i, j in combinations(range(len(basis)), 2)}
+    while pairs:
+        # Normal selection: take every pair whose lcm has minimal degree.
+        info = []
+        for pair in pairs:
+            i, j = tuple(pair) if len(pair) == 2 else (min(pair), min(pair))
+            L = _lcm(_lead(basis[i]), _lead(basis[j]))
+            info.append((sum(L), L, i, j, pair))
+        mindeg = min(x[0] for x in info)
+        batch = [x for x in info if x[0] == mindeg]
+        for x in batch:
+            pairs.discard(x[4])
+        rows = []
+        for _, L, i, j, _ in batch:
+            f, g = basis[i], basis[j]
+            lf, lg = _lead(f), _lead(g)
+            # Coprime leading monomials give an S-polynomial that reduces to
+            # zero by Buchberger's first criterion; the pair carries no
+            # information and is skipped.
+            if _mul(lf, lg) == L:
+                continue
+            rows.append(_scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p))
+            rows.append(_scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p))
+        if not rows:
+            continue
+        rows, monomials = _symbolic_preprocess(rows, basis, p)
+        ordered = sorted(monomials, key=monomial_key, reverse=True)
+        reduced = _reduce_matrix(rows, ordered, p, device)
+        leads = [_lead(g) for g in basis]
+        for row in reduced:
+            lm = _lead(row)
+            if any(_divides(l, lm) for l in leads):
+                continue
+            basis.append(row)
+            leads.append(lm)
+            new = len(basis) - 1
+            for k in range(new):
+                pairs.add(frozenset((k, new)))
+    return _interreduce(basis, p)
+def _interreduce(basis, p):
+    """Drop redundant elements and fully reduce the survivors."""
+    leads = [_lead(g) for g in basis]
+    keep = []
+    for i, g in enumerate(basis):
+        if any(j != i and _divides(leads[j], leads[i]) and
+               (leads[j] != leads[i] or j < i) for j in range(len(basis))):
+            continue
+        keep.append(g)
+    out = []
+    for i, g in enumerate(keep):
+        others = keep[:i] + keep[i + 1:] + out
+        r = normal_form(g, [h for h in others if h], p)
+        if r:
+            lm = _lead(r)
+            out.append(_scale_shift(r, tuple([0] * len(lm)), pow(r[lm], -1, p), p))
+    return sorted(out, key=lambda g: monomial_key(_lead(g)), reverse=True)
+def is_groebner_basis(basis, prime):
+    """True when every S-polynomial of the basis reduces to zero."""
+    p = int(prime)
+    for f, g in combinations(basis, 2):
+        if normal_form(spoly(f, g, p), basis, p):
+            return False
+    return True

build/torch212-cxx11-cu130-x86_64-linux/_groebner_cuda_0bb395a.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:99ec4de9e56b9be851630cca7430c0688e88911c5144e395c6886b23eb9f4854
+size 263312

build/torch212-cxx11-cu130-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _groebner_cuda_0bb395a
+ops = torch.ops._groebner_cuda_0bb395a
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_groebner_cuda_0bb395a::{op_name}"

build/torch212-cxx11-cu130-x86_64-linux/groebner/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch212-cxx11-cu130-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "groebner",
+  "id": "_groebner_cuda_0bb395a",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "CpsyiOVGquYAg8QliZu4XdtavY7LBxkm/VqYtFWi+1o=",
+      "_groebner_cuda_0bb395a.abi3.so": "mexN6eVrm+hRYwzKdDDAaI6IkRxRROOVxohrI+ufSFQ=",
+      "_ops.py": "HBf/A1FZVh5Vgeu7QDu0SfwcwNiTAPBSdQ0M9mx+p7M=",
+      "groebner/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "0bb395ae2658cdd9257c1433b06492b34c1a1378",
+      "dirty": false
+    }
+  }
+}

build/torch212-cxx11-cu132-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,267 @@

+"""groebner: Groebner bases over F_p with GPU Macaulay matrix reduction.
+Implements an F4-style algorithm in degree-reverse-lexicographic order. Critical
+pairs of minimal lcm degree are processed as a batch: their S-polynomial rows
+plus every reductor found by symbolic preprocessing form a Macaulay matrix whose
+columns are monomials, and that matrix is reduced to reduced row echelon form on
+the GPU. Rows whose leading monomial is not already divisible by a leading
+monomial of the basis become new basis elements.
+    groebner_basis(polys, nvars, prime)  -> reduced Groebner basis
+Polynomials are dicts mapping exponent tuples to coefficients in F_p.
+Reference baselines: msolve, Singular ``std``.
+"""
+from itertools import combinations
+import torch
+from ._ops import ops
+__all__ = ["groebner_basis", "monomial_key", "spoly", "normal_form", "is_groebner_basis"]
+# ---------------------------------------------------------------- monomials
+def monomial_key(exps):
+    """Sort key for degree-reverse-lexicographic order, ascending."""
+    return (sum(exps), tuple(-e for e in reversed(exps)))
+def _mul(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+def _div(a, b):
+    """a / b when b divides a, else None."""
+    out = []
+    for x, y in zip(a, b):
+        if x < y:
+            return None
+        out.append(x - y)
+    return tuple(out)
+def _lcm(a, b):
+    return tuple(max(x, y) for x, y in zip(a, b))
+def _divides(b, a):
+    return all(y <= x for x, y in zip(a, b))
+def _lead(poly):
+    """Leading monomial in degrevlex."""
+    return max(poly, key=monomial_key)
+# ---------------------------------------------------------------- polynomials
+def _normalize(poly, p):
+    out = {}
+    for m, c in poly.items():
+        c %= p
+        if c:
+            out[m] = c
+    return out
+def _scale_shift(poly, mono, coeff, p):
+    return {_mul(m, mono): (c * coeff) % p for m, c in poly.items()}
+def _sub(f, g, p):
+    out = dict(f)
+    for m, c in g.items():
+        v = (out.get(m, 0) - c) % p
+        if v:
+            out[m] = v
+        elif m in out:
+            del out[m]
+    return out
+def spoly(f, g, p):
+    """S-polynomial of two nonzero polynomials over F_p."""
+    lf, lg = _lead(f), _lead(g)
+    L = _lcm(lf, lg)
+    a = _scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p)
+    b = _scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p)
+    return _sub(a, b, p)
+def normal_form(f, basis, p):
+    """Fully reduce ``f`` modulo ``basis`` in degrevlex."""
+    f = _normalize(f, p)
+    out = {}
+    while f:
+        m = _lead(f)
+        c = f[m]
+        for g in basis:
+            lg = _lead(g)
+            q = _div(m, lg)
+            if q is not None:
+                factor = (c * pow(g[lg], -1, p)) % p
+                f = _sub(f, _scale_shift(g, q, factor, p), p)
+                break
+        else:
+            out[m] = c
+            del f[m]
+    return out
+# ---------------------------------------------------------------- reduction
+def _reduce_matrix(rows, monomials, prime, device):
+    """Reduce the Macaulay matrix on the GPU, returning its nonzero rows."""
+    index = {m: i for i, m in enumerate(monomials)}
+    m, n = len(rows), len(monomials)
+    dense = torch.zeros(m, n, dtype=torch.int32)
+    flat = dense.view(-1)
+    for r, poly in enumerate(rows):
+        base = r * n
+        for mono, coeff in poly.items():
+            flat[base + index[mono]] = coeff % prime
+    dense = dense.to(device).contiguous()
+    rank = torch.zeros(1, dtype=torch.int32, device=device)
+    piv = torch.full((m,), -1, dtype=torch.int32, device=device)
+    ops.groebner_reduce(dense, rank, piv, prime)
+    r = int(rank.item())
+    if r == 0:
+        return []
+    host = dense[:r].cpu().numpy()
+    out = []
+    for i in range(r):
+        row = host[i]
+        nz = row.nonzero()[0]
+        out.append({monomials[j]: int(row[j]) for j in nz})
+    return out
+def _symbolic_preprocess(rows, basis, p):
+    """Close the row set under reduction by the basis leading monomials."""
+    monomials = set()
+    for poly in rows:
+        monomials.update(poly)
+    done = set()
+    rows = list(rows)
+    while True:
+        pending = monomials - done
+        if not pending:
+            break
+        for mono in sorted(pending, key=monomial_key, reverse=True):
+            done.add(mono)
+            for g in basis:
+                lg = _lead(g)
+                q = _div(mono, lg)
+                if q is not None:
+                    row = _scale_shift(g, q, pow(g[lg], -1, p), p)
+                    rows.append(row)
+                    monomials.update(row)
+                    break
+    return rows, monomials
+# ---------------------------------------------------------------- driver
+def groebner_basis(polys, nvars, prime, device=None):
+    """Reduced Groebner basis of the ideal generated by ``polys`` over F_p.
+    Args:
+        polys: iterable of dicts mapping length-``nvars`` exponent tuples to
+            integer coefficients.
+        nvars: number of variables.
+        prime: field characteristic, an odd prime below 2^31.
+        device: torch device; defaults to ``cuda``.
+    Returns:
+        the reduced Groebner basis in degree-reverse-lexicographic order, each
+        element monic, sorted by descending leading monomial.
+    """
+    device = torch.device("cuda") if device is None else device
+    p = int(prime)
+    basis = [_normalize(f, p) for f in polys]
+    basis = [f for f in basis if f]
+    if not basis:
+        return []
+    for f in basis:
+        if len(_lead(f)) != nvars:
+            raise ValueError("every exponent tuple must have length nvars")
+    pairs = {frozenset((i, j)) for i, j in combinations(range(len(basis)), 2)}
+    while pairs:
+        # Normal selection: take every pair whose lcm has minimal degree.
+        info = []
+        for pair in pairs:
+            i, j = tuple(pair) if len(pair) == 2 else (min(pair), min(pair))
+            L = _lcm(_lead(basis[i]), _lead(basis[j]))
+            info.append((sum(L), L, i, j, pair))
+        mindeg = min(x[0] for x in info)
+        batch = [x for x in info if x[0] == mindeg]
+        for x in batch:
+            pairs.discard(x[4])
+        rows = []
+        for _, L, i, j, _ in batch:
+            f, g = basis[i], basis[j]
+            lf, lg = _lead(f), _lead(g)
+            # Coprime leading monomials give an S-polynomial that reduces to
+            # zero by Buchberger's first criterion; the pair carries no
+            # information and is skipped.
+            if _mul(lf, lg) == L:
+                continue
+            rows.append(_scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p))
+            rows.append(_scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p))
+        if not rows:
+            continue
+        rows, monomials = _symbolic_preprocess(rows, basis, p)
+        ordered = sorted(monomials, key=monomial_key, reverse=True)
+        reduced = _reduce_matrix(rows, ordered, p, device)
+        leads = [_lead(g) for g in basis]
+        for row in reduced:
+            lm = _lead(row)
+            if any(_divides(l, lm) for l in leads):
+                continue
+            basis.append(row)
+            leads.append(lm)
+            new = len(basis) - 1
+            for k in range(new):
+                pairs.add(frozenset((k, new)))
+    return _interreduce(basis, p)
+def _interreduce(basis, p):
+    """Drop redundant elements and fully reduce the survivors."""
+    leads = [_lead(g) for g in basis]
+    keep = []
+    for i, g in enumerate(basis):
+        if any(j != i and _divides(leads[j], leads[i]) and
+               (leads[j] != leads[i] or j < i) for j in range(len(basis))):
+            continue
+        keep.append(g)
+    out = []
+    for i, g in enumerate(keep):
+        others = keep[:i] + keep[i + 1:] + out
+        r = normal_form(g, [h for h in others if h], p)
+        if r:
+            lm = _lead(r)
+            out.append(_scale_shift(r, tuple([0] * len(lm)), pow(r[lm], -1, p), p))
+    return sorted(out, key=lambda g: monomial_key(_lead(g)), reverse=True)
+def is_groebner_basis(basis, prime):
+    """True when every S-polynomial of the basis reduces to zero."""
+    p = int(prime)
+    for f, g in combinations(basis, 2):
+        if normal_form(spoly(f, g, p), basis, p):
+            return False
+    return True

build/torch212-cxx11-cu132-x86_64-linux/_groebner_cuda_0bb395a.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:15421261f06297d516f06075b2cb7e31cadeac5163514efc36bf2a084e446eef
+size 302224

build/torch212-cxx11-cu132-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _groebner_cuda_0bb395a
+ops = torch.ops._groebner_cuda_0bb395a
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_groebner_cuda_0bb395a::{op_name}"

build/torch212-cxx11-cu132-x86_64-linux/groebner/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch212-cxx11-cu132-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "groebner",
+  "id": "_groebner_cuda_0bb395a",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "CpsyiOVGquYAg8QliZu4XdtavY7LBxkm/VqYtFWi+1o=",
+      "_groebner_cuda_0bb395a.abi3.so": "FUISYfBil9UW8GB1sst+McrerFFjUU78Nr8qCE5Ebu8=",
+      "_ops.py": "HBf/A1FZVh5Vgeu7QDu0SfwcwNiTAPBSdQ0M9mx+p7M=",
+      "groebner/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "0bb395ae2658cdd9257c1433b06492b34c1a1378",
+      "dirty": false
+    }
+  }
+}

build/torch213-cxx11-cu126-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,267 @@

+"""groebner: Groebner bases over F_p with GPU Macaulay matrix reduction.
+Implements an F4-style algorithm in degree-reverse-lexicographic order. Critical
+pairs of minimal lcm degree are processed as a batch: their S-polynomial rows
+plus every reductor found by symbolic preprocessing form a Macaulay matrix whose
+columns are monomials, and that matrix is reduced to reduced row echelon form on
+the GPU. Rows whose leading monomial is not already divisible by a leading
+monomial of the basis become new basis elements.
+    groebner_basis(polys, nvars, prime)  -> reduced Groebner basis
+Polynomials are dicts mapping exponent tuples to coefficients in F_p.
+Reference baselines: msolve, Singular ``std``.
+"""
+from itertools import combinations
+import torch
+from ._ops import ops
+__all__ = ["groebner_basis", "monomial_key", "spoly", "normal_form", "is_groebner_basis"]
+# ---------------------------------------------------------------- monomials
+def monomial_key(exps):
+    """Sort key for degree-reverse-lexicographic order, ascending."""
+    return (sum(exps), tuple(-e for e in reversed(exps)))
+def _mul(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+def _div(a, b):
+    """a / b when b divides a, else None."""
+    out = []
+    for x, y in zip(a, b):
+        if x < y:
+            return None
+        out.append(x - y)
+    return tuple(out)
+def _lcm(a, b):
+    return tuple(max(x, y) for x, y in zip(a, b))
+def _divides(b, a):
+    return all(y <= x for x, y in zip(a, b))
+def _lead(poly):
+    """Leading monomial in degrevlex."""
+    return max(poly, key=monomial_key)
+# ---------------------------------------------------------------- polynomials
+def _normalize(poly, p):
+    out = {}
+    for m, c in poly.items():
+        c %= p
+        if c:
+            out[m] = c
+    return out
+def _scale_shift(poly, mono, coeff, p):
+    return {_mul(m, mono): (c * coeff) % p for m, c in poly.items()}
+def _sub(f, g, p):
+    out = dict(f)
+    for m, c in g.items():
+        v = (out.get(m, 0) - c) % p
+        if v:
+            out[m] = v
+        elif m in out:
+            del out[m]
+    return out
+def spoly(f, g, p):
+    """S-polynomial of two nonzero polynomials over F_p."""
+    lf, lg = _lead(f), _lead(g)
+    L = _lcm(lf, lg)
+    a = _scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p)
+    b = _scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p)
+    return _sub(a, b, p)
+def normal_form(f, basis, p):
+    """Fully reduce ``f`` modulo ``basis`` in degrevlex."""
+    f = _normalize(f, p)
+    out = {}
+    while f:
+        m = _lead(f)
+        c = f[m]
+        for g in basis:
+            lg = _lead(g)
+            q = _div(m, lg)
+            if q is not None:
+                factor = (c * pow(g[lg], -1, p)) % p
+                f = _sub(f, _scale_shift(g, q, factor, p), p)
+                break
+        else:
+            out[m] = c
+            del f[m]
+    return out
+# ---------------------------------------------------------------- reduction
+def _reduce_matrix(rows, monomials, prime, device):
+    """Reduce the Macaulay matrix on the GPU, returning its nonzero rows."""
+    index = {m: i for i, m in enumerate(monomials)}
+    m, n = len(rows), len(monomials)
+    dense = torch.zeros(m, n, dtype=torch.int32)
+    flat = dense.view(-1)
+    for r, poly in enumerate(rows):
+        base = r * n
+        for mono, coeff in poly.items():
+            flat[base + index[mono]] = coeff % prime
+    dense = dense.to(device).contiguous()
+    rank = torch.zeros(1, dtype=torch.int32, device=device)
+    piv = torch.full((m,), -1, dtype=torch.int32, device=device)
+    ops.groebner_reduce(dense, rank, piv, prime)
+    r = int(rank.item())
+    if r == 0:
+        return []
+    host = dense[:r].cpu().numpy()
+    out = []
+    for i in range(r):
+        row = host[i]
+        nz = row.nonzero()[0]
+        out.append({monomials[j]: int(row[j]) for j in nz})
+    return out
+def _symbolic_preprocess(rows, basis, p):
+    """Close the row set under reduction by the basis leading monomials."""
+    monomials = set()
+    for poly in rows:
+        monomials.update(poly)
+    done = set()
+    rows = list(rows)
+    while True:
+        pending = monomials - done
+        if not pending:
+            break
+        for mono in sorted(pending, key=monomial_key, reverse=True):
+            done.add(mono)
+            for g in basis:
+                lg = _lead(g)
+                q = _div(mono, lg)
+                if q is not None:
+                    row = _scale_shift(g, q, pow(g[lg], -1, p), p)
+                    rows.append(row)
+                    monomials.update(row)
+                    break
+    return rows, monomials
+# ---------------------------------------------------------------- driver
+def groebner_basis(polys, nvars, prime, device=None):
+    """Reduced Groebner basis of the ideal generated by ``polys`` over F_p.
+    Args:
+        polys: iterable of dicts mapping length-``nvars`` exponent tuples to
+            integer coefficients.
+        nvars: number of variables.
+        prime: field characteristic, an odd prime below 2^31.
+        device: torch device; defaults to ``cuda``.
+    Returns:
+        the reduced Groebner basis in degree-reverse-lexicographic order, each
+        element monic, sorted by descending leading monomial.
+    """
+    device = torch.device("cuda") if device is None else device
+    p = int(prime)
+    basis = [_normalize(f, p) for f in polys]
+    basis = [f for f in basis if f]
+    if not basis:
+        return []
+    for f in basis:
+        if len(_lead(f)) != nvars:
+            raise ValueError("every exponent tuple must have length nvars")
+    pairs = {frozenset((i, j)) for i, j in combinations(range(len(basis)), 2)}
+    while pairs:
+        # Normal selection: take every pair whose lcm has minimal degree.
+        info = []
+        for pair in pairs:
+            i, j = tuple(pair) if len(pair) == 2 else (min(pair), min(pair))
+            L = _lcm(_lead(basis[i]), _lead(basis[j]))
+            info.append((sum(L), L, i, j, pair))
+        mindeg = min(x[0] for x in info)
+        batch = [x for x in info if x[0] == mindeg]
+        for x in batch:
+            pairs.discard(x[4])
+        rows = []
+        for _, L, i, j, _ in batch:
+            f, g = basis[i], basis[j]
+            lf, lg = _lead(f), _lead(g)
+            # Coprime leading monomials give an S-polynomial that reduces to
+            # zero by Buchberger's first criterion; the pair carries no
+            # information and is skipped.
+            if _mul(lf, lg) == L:
+                continue
+            rows.append(_scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p))
+            rows.append(_scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p))
+        if not rows:
+            continue
+        rows, monomials = _symbolic_preprocess(rows, basis, p)
+        ordered = sorted(monomials, key=monomial_key, reverse=True)
+        reduced = _reduce_matrix(rows, ordered, p, device)
+        leads = [_lead(g) for g in basis]
+        for row in reduced:
+            lm = _lead(row)
+            if any(_divides(l, lm) for l in leads):
+                continue
+            basis.append(row)
+            leads.append(lm)
+            new = len(basis) - 1
+            for k in range(new):
+                pairs.add(frozenset((k, new)))
+    return _interreduce(basis, p)
+def _interreduce(basis, p):
+    """Drop redundant elements and fully reduce the survivors."""
+    leads = [_lead(g) for g in basis]
+    keep = []
+    for i, g in enumerate(basis):
+        if any(j != i and _divides(leads[j], leads[i]) and
+               (leads[j] != leads[i] or j < i) for j in range(len(basis))):
+            continue
+        keep.append(g)
+    out = []
+    for i, g in enumerate(keep):
+        others = keep[:i] + keep[i + 1:] + out
+        r = normal_form(g, [h for h in others if h], p)
+        if r:
+            lm = _lead(r)
+            out.append(_scale_shift(r, tuple([0] * len(lm)), pow(r[lm], -1, p), p))
+    return sorted(out, key=lambda g: monomial_key(_lead(g)), reverse=True)
+def is_groebner_basis(basis, prime):
+    """True when every S-polynomial of the basis reduces to zero."""
+    p = int(prime)
+    for f, g in combinations(basis, 2):
+        if normal_form(spoly(f, g, p), basis, p):
+            return False
+    return True

build/torch213-cxx11-cu126-x86_64-linux/_groebner_cuda_0bb395a.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:7426cb9830ff96c24c8c5dda578e7afbf10279ca61245da9b90be651ba4a1f1b
+size 177112

build/torch213-cxx11-cu126-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _groebner_cuda_0bb395a
+ops = torch.ops._groebner_cuda_0bb395a
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_groebner_cuda_0bb395a::{op_name}"

build/torch213-cxx11-cu126-x86_64-linux/groebner/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch213-cxx11-cu126-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,36 @@

+{
+  "name": "groebner",
+  "id": "_groebner_cuda_0bb395a",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "CpsyiOVGquYAg8QliZu4XdtavY7LBxkm/VqYtFWi+1o=",
+      "_groebner_cuda_0bb395a.abi3.so": "dCbLmDD/lsJMjF3aV456+/ECecphJF2puQvmUbpKHxs=",
+      "_ops.py": "HBf/A1FZVh5Vgeu7QDu0SfwcwNiTAPBSdQ0M9mx+p7M=",
+      "groebner/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "0bb395ae2658cdd9257c1433b06492b34c1a1378",
+      "dirty": false
+    }
+  }
+}

build/torch213-cxx11-cu130-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,267 @@

+"""groebner: Groebner bases over F_p with GPU Macaulay matrix reduction.
+Implements an F4-style algorithm in degree-reverse-lexicographic order. Critical
+pairs of minimal lcm degree are processed as a batch: their S-polynomial rows
+plus every reductor found by symbolic preprocessing form a Macaulay matrix whose
+columns are monomials, and that matrix is reduced to reduced row echelon form on
+the GPU. Rows whose leading monomial is not already divisible by a leading
+monomial of the basis become new basis elements.
+    groebner_basis(polys, nvars, prime)  -> reduced Groebner basis
+Polynomials are dicts mapping exponent tuples to coefficients in F_p.
+Reference baselines: msolve, Singular ``std``.
+"""
+from itertools import combinations
+import torch
+from ._ops import ops
+__all__ = ["groebner_basis", "monomial_key", "spoly", "normal_form", "is_groebner_basis"]
+# ---------------------------------------------------------------- monomials
+def monomial_key(exps):
+    """Sort key for degree-reverse-lexicographic order, ascending."""
+    return (sum(exps), tuple(-e for e in reversed(exps)))
+def _mul(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+def _div(a, b):
+    """a / b when b divides a, else None."""
+    out = []
+    for x, y in zip(a, b):
+        if x < y:
+            return None
+        out.append(x - y)
+    return tuple(out)
+def _lcm(a, b):
+    return tuple(max(x, y) for x, y in zip(a, b))
+def _divides(b, a):
+    return all(y <= x for x, y in zip(a, b))
+def _lead(poly):
+    """Leading monomial in degrevlex."""
+    return max(poly, key=monomial_key)
+# ---------------------------------------------------------------- polynomials
+def _normalize(poly, p):
+    out = {}
+    for m, c in poly.items():
+        c %= p
+        if c:
+            out[m] = c
+    return out
+def _scale_shift(poly, mono, coeff, p):
+    return {_mul(m, mono): (c * coeff) % p for m, c in poly.items()}
+def _sub(f, g, p):
+    out = dict(f)
+    for m, c in g.items():
+        v = (out.get(m, 0) - c) % p
+        if v:
+            out[m] = v
+        elif m in out:
+            del out[m]
+    return out
+def spoly(f, g, p):
+    """S-polynomial of two nonzero polynomials over F_p."""
+    lf, lg = _lead(f), _lead(g)
+    L = _lcm(lf, lg)
+    a = _scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p)
+    b = _scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p)
+    return _sub(a, b, p)
+def normal_form(f, basis, p):
+    """Fully reduce ``f`` modulo ``basis`` in degrevlex."""
+    f = _normalize(f, p)
+    out = {}
+    while f:
+        m = _lead(f)
+        c = f[m]
+        for g in basis:
+            lg = _lead(g)
+            q = _div(m, lg)
+            if q is not None:
+                factor = (c * pow(g[lg], -1, p)) % p
+                f = _sub(f, _scale_shift(g, q, factor, p), p)
+                break
+        else:
+            out[m] = c
+            del f[m]
+    return out
+# ---------------------------------------------------------------- reduction
+def _reduce_matrix(rows, monomials, prime, device):
+    """Reduce the Macaulay matrix on the GPU, returning its nonzero rows."""
+    index = {m: i for i, m in enumerate(monomials)}
+    m, n = len(rows), len(monomials)
+    dense = torch.zeros(m, n, dtype=torch.int32)
+    flat = dense.view(-1)
+    for r, poly in enumerate(rows):
+        base = r * n
+        for mono, coeff in poly.items():
+            flat[base + index[mono]] = coeff % prime
+    dense = dense.to(device).contiguous()
+    rank = torch.zeros(1, dtype=torch.int32, device=device)
+    piv = torch.full((m,), -1, dtype=torch.int32, device=device)
+    ops.groebner_reduce(dense, rank, piv, prime)
+    r = int(rank.item())
+    if r == 0:
+        return []
+    host = dense[:r].cpu().numpy()
+    out = []
+    for i in range(r):
+        row = host[i]
+        nz = row.nonzero()[0]
+        out.append({monomials[j]: int(row[j]) for j in nz})
+    return out
+def _symbolic_preprocess(rows, basis, p):
+    """Close the row set under reduction by the basis leading monomials."""
+    monomials = set()
+    for poly in rows:
+        monomials.update(poly)
+    done = set()
+    rows = list(rows)
+    while True:
+        pending = monomials - done
+        if not pending:
+            break
+        for mono in sorted(pending, key=monomial_key, reverse=True):
+            done.add(mono)
+            for g in basis:
+                lg = _lead(g)
+                q = _div(mono, lg)
+                if q is not None:
+                    row = _scale_shift(g, q, pow(g[lg], -1, p), p)
+                    rows.append(row)
+                    monomials.update(row)
+                    break
+    return rows, monomials
+# ---------------------------------------------------------------- driver
+def groebner_basis(polys, nvars, prime, device=None):
+    """Reduced Groebner basis of the ideal generated by ``polys`` over F_p.
+    Args:
+        polys: iterable of dicts mapping length-``nvars`` exponent tuples to
+            integer coefficients.
+        nvars: number of variables.
+        prime: field characteristic, an odd prime below 2^31.
+        device: torch device; defaults to ``cuda``.
+    Returns:
+        the reduced Groebner basis in degree-reverse-lexicographic order, each
+        element monic, sorted by descending leading monomial.
+    """
+    device = torch.device("cuda") if device is None else device
+    p = int(prime)
+    basis = [_normalize(f, p) for f in polys]
+    basis = [f for f in basis if f]
+    if not basis:
+        return []
+    for f in basis:
+        if len(_lead(f)) != nvars:
+            raise ValueError("every exponent tuple must have length nvars")
+    pairs = {frozenset((i, j)) for i, j in combinations(range(len(basis)), 2)}
+    while pairs:
+        # Normal selection: take every pair whose lcm has minimal degree.
+        info = []
+        for pair in pairs:
+            i, j = tuple(pair) if len(pair) == 2 else (min(pair), min(pair))
+            L = _lcm(_lead(basis[i]), _lead(basis[j]))
+            info.append((sum(L), L, i, j, pair))
+        mindeg = min(x[0] for x in info)
+        batch = [x for x in info if x[0] == mindeg]
+        for x in batch:
+            pairs.discard(x[4])
+        rows = []
+        for _, L, i, j, _ in batch:
+            f, g = basis[i], basis[j]
+            lf, lg = _lead(f), _lead(g)
+            # Coprime leading monomials give an S-polynomial that reduces to
+            # zero by Buchberger's first criterion; the pair carries no
+            # information and is skipped.
+            if _mul(lf, lg) == L:
+                continue
+            rows.append(_scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p))
+            rows.append(_scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p))
+        if not rows:
+            continue
+        rows, monomials = _symbolic_preprocess(rows, basis, p)
+        ordered = sorted(monomials, key=monomial_key, reverse=True)
+        reduced = _reduce_matrix(rows, ordered, p, device)
+        leads = [_lead(g) for g in basis]
+        for row in reduced:
+            lm = _lead(row)
+            if any(_divides(l, lm) for l in leads):
+                continue
+            basis.append(row)
+            leads.append(lm)
+            new = len(basis) - 1
+            for k in range(new):
+                pairs.add(frozenset((k, new)))
+    return _interreduce(basis, p)
+def _interreduce(basis, p):
+    """Drop redundant elements and fully reduce the survivors."""
+    leads = [_lead(g) for g in basis]
+    keep = []
+    for i, g in enumerate(basis):
+        if any(j != i and _divides(leads[j], leads[i]) and
+               (leads[j] != leads[i] or j < i) for j in range(len(basis))):
+            continue
+        keep.append(g)
+    out = []
+    for i, g in enumerate(keep):
+        others = keep[:i] + keep[i + 1:] + out
+        r = normal_form(g, [h for h in others if h], p)
+        if r:
+            lm = _lead(r)
+            out.append(_scale_shift(r, tuple([0] * len(lm)), pow(r[lm], -1, p), p))
+    return sorted(out, key=lambda g: monomial_key(_lead(g)), reverse=True)
+def is_groebner_basis(basis, prime):
+    """True when every S-polynomial of the basis reduces to zero."""
+    p = int(prime)
+    for f, g in combinations(basis, 2):
+        if normal_form(spoly(f, g, p), basis, p):
+            return False
+    return True

build/torch213-cxx11-cu130-x86_64-linux/_groebner_cuda_0bb395a.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:46f55345299d5c3337c035473b5293853dece7b25bd6c2deca2b493f087b2b56
+size 263312

build/torch213-cxx11-cu130-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _groebner_cuda_0bb395a
+ops = torch.ops._groebner_cuda_0bb395a
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_groebner_cuda_0bb395a::{op_name}"

build/torch213-cxx11-cu130-x86_64-linux/groebner/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch213-cxx11-cu130-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "groebner",
+  "id": "_groebner_cuda_0bb395a",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "CpsyiOVGquYAg8QliZu4XdtavY7LBxkm/VqYtFWi+1o=",
+      "_groebner_cuda_0bb395a.abi3.so": "RvVTRSmdXDM3wDVHO1KThT3s57Jb1sLeyitJPwh7K1Y=",
+      "_ops.py": "HBf/A1FZVh5Vgeu7QDu0SfwcwNiTAPBSdQ0M9mx+p7M=",
+      "groebner/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "0bb395ae2658cdd9257c1433b06492b34c1a1378",
+      "dirty": false
+    }
+  }
+}

build/torch213-cxx11-cu132-x86_64-linux/__init__.py ADDED Viewed

	@@ -0,0 +1,267 @@

+"""groebner: Groebner bases over F_p with GPU Macaulay matrix reduction.
+Implements an F4-style algorithm in degree-reverse-lexicographic order. Critical
+pairs of minimal lcm degree are processed as a batch: their S-polynomial rows
+plus every reductor found by symbolic preprocessing form a Macaulay matrix whose
+columns are monomials, and that matrix is reduced to reduced row echelon form on
+the GPU. Rows whose leading monomial is not already divisible by a leading
+monomial of the basis become new basis elements.
+    groebner_basis(polys, nvars, prime)  -> reduced Groebner basis
+Polynomials are dicts mapping exponent tuples to coefficients in F_p.
+Reference baselines: msolve, Singular ``std``.
+"""
+from itertools import combinations
+import torch
+from ._ops import ops
+__all__ = ["groebner_basis", "monomial_key", "spoly", "normal_form", "is_groebner_basis"]
+# ---------------------------------------------------------------- monomials
+def monomial_key(exps):
+    """Sort key for degree-reverse-lexicographic order, ascending."""
+    return (sum(exps), tuple(-e for e in reversed(exps)))
+def _mul(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+def _div(a, b):
+    """a / b when b divides a, else None."""
+    out = []
+    for x, y in zip(a, b):
+        if x < y:
+            return None
+        out.append(x - y)
+    return tuple(out)
+def _lcm(a, b):
+    return tuple(max(x, y) for x, y in zip(a, b))
+def _divides(b, a):
+    return all(y <= x for x, y in zip(a, b))
+def _lead(poly):
+    """Leading monomial in degrevlex."""
+    return max(poly, key=monomial_key)
+# ---------------------------------------------------------------- polynomials
+def _normalize(poly, p):
+    out = {}
+    for m, c in poly.items():
+        c %= p
+        if c:
+            out[m] = c
+    return out
+def _scale_shift(poly, mono, coeff, p):
+    return {_mul(m, mono): (c * coeff) % p for m, c in poly.items()}
+def _sub(f, g, p):
+    out = dict(f)
+    for m, c in g.items():
+        v = (out.get(m, 0) - c) % p
+        if v:
+            out[m] = v
+        elif m in out:
+            del out[m]
+    return out
+def spoly(f, g, p):
+    """S-polynomial of two nonzero polynomials over F_p."""
+    lf, lg = _lead(f), _lead(g)
+    L = _lcm(lf, lg)
+    a = _scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p)
+    b = _scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p)
+    return _sub(a, b, p)
+def normal_form(f, basis, p):
+    """Fully reduce ``f`` modulo ``basis`` in degrevlex."""
+    f = _normalize(f, p)
+    out = {}
+    while f:
+        m = _lead(f)
+        c = f[m]
+        for g in basis:
+            lg = _lead(g)
+            q = _div(m, lg)
+            if q is not None:
+                factor = (c * pow(g[lg], -1, p)) % p
+                f = _sub(f, _scale_shift(g, q, factor, p), p)
+                break
+        else:
+            out[m] = c
+            del f[m]
+    return out
+# ---------------------------------------------------------------- reduction
+def _reduce_matrix(rows, monomials, prime, device):
+    """Reduce the Macaulay matrix on the GPU, returning its nonzero rows."""
+    index = {m: i for i, m in enumerate(monomials)}
+    m, n = len(rows), len(monomials)
+    dense = torch.zeros(m, n, dtype=torch.int32)
+    flat = dense.view(-1)
+    for r, poly in enumerate(rows):
+        base = r * n
+        for mono, coeff in poly.items():
+            flat[base + index[mono]] = coeff % prime
+    dense = dense.to(device).contiguous()
+    rank = torch.zeros(1, dtype=torch.int32, device=device)
+    piv = torch.full((m,), -1, dtype=torch.int32, device=device)
+    ops.groebner_reduce(dense, rank, piv, prime)
+    r = int(rank.item())
+    if r == 0:
+        return []
+    host = dense[:r].cpu().numpy()
+    out = []
+    for i in range(r):
+        row = host[i]
+        nz = row.nonzero()[0]
+        out.append({monomials[j]: int(row[j]) for j in nz})
+    return out
+def _symbolic_preprocess(rows, basis, p):
+    """Close the row set under reduction by the basis leading monomials."""
+    monomials = set()
+    for poly in rows:
+        monomials.update(poly)
+    done = set()
+    rows = list(rows)
+    while True:
+        pending = monomials - done
+        if not pending:
+            break
+        for mono in sorted(pending, key=monomial_key, reverse=True):
+            done.add(mono)
+            for g in basis:
+                lg = _lead(g)
+                q = _div(mono, lg)
+                if q is not None:
+                    row = _scale_shift(g, q, pow(g[lg], -1, p), p)
+                    rows.append(row)
+                    monomials.update(row)
+                    break
+    return rows, monomials
+# ---------------------------------------------------------------- driver
+def groebner_basis(polys, nvars, prime, device=None):
+    """Reduced Groebner basis of the ideal generated by ``polys`` over F_p.
+    Args:
+        polys: iterable of dicts mapping length-``nvars`` exponent tuples to
+            integer coefficients.
+        nvars: number of variables.
+        prime: field characteristic, an odd prime below 2^31.
+        device: torch device; defaults to ``cuda``.
+    Returns:
+        the reduced Groebner basis in degree-reverse-lexicographic order, each
+        element monic, sorted by descending leading monomial.
+    """
+    device = torch.device("cuda") if device is None else device
+    p = int(prime)
+    basis = [_normalize(f, p) for f in polys]
+    basis = [f for f in basis if f]
+    if not basis:
+        return []
+    for f in basis:
+        if len(_lead(f)) != nvars:
+            raise ValueError("every exponent tuple must have length nvars")
+    pairs = {frozenset((i, j)) for i, j in combinations(range(len(basis)), 2)}
+    while pairs:
+        # Normal selection: take every pair whose lcm has minimal degree.
+        info = []
+        for pair in pairs:
+            i, j = tuple(pair) if len(pair) == 2 else (min(pair), min(pair))
+            L = _lcm(_lead(basis[i]), _lead(basis[j]))
+            info.append((sum(L), L, i, j, pair))
+        mindeg = min(x[0] for x in info)
+        batch = [x for x in info if x[0] == mindeg]
+        for x in batch:
+            pairs.discard(x[4])
+        rows = []
+        for _, L, i, j, _ in batch:
+            f, g = basis[i], basis[j]
+            lf, lg = _lead(f), _lead(g)
+            # Coprime leading monomials give an S-polynomial that reduces to
+            # zero by Buchberger's first criterion; the pair carries no
+            # information and is skipped.
+            if _mul(lf, lg) == L:
+                continue
+            rows.append(_scale_shift(f, _div(L, lf), pow(f[lf], -1, p), p))
+            rows.append(_scale_shift(g, _div(L, lg), pow(g[lg], -1, p), p))
+        if not rows:
+            continue
+        rows, monomials = _symbolic_preprocess(rows, basis, p)
+        ordered = sorted(monomials, key=monomial_key, reverse=True)
+        reduced = _reduce_matrix(rows, ordered, p, device)
+        leads = [_lead(g) for g in basis]
+        for row in reduced:
+            lm = _lead(row)
+            if any(_divides(l, lm) for l in leads):
+                continue
+            basis.append(row)
+            leads.append(lm)
+            new = len(basis) - 1
+            for k in range(new):
+                pairs.add(frozenset((k, new)))
+    return _interreduce(basis, p)
+def _interreduce(basis, p):
+    """Drop redundant elements and fully reduce the survivors."""
+    leads = [_lead(g) for g in basis]
+    keep = []
+    for i, g in enumerate(basis):
+        if any(j != i and _divides(leads[j], leads[i]) and
+               (leads[j] != leads[i] or j < i) for j in range(len(basis))):
+            continue
+        keep.append(g)
+    out = []
+    for i, g in enumerate(keep):
+        others = keep[:i] + keep[i + 1:] + out
+        r = normal_form(g, [h for h in others if h], p)
+        if r:
+            lm = _lead(r)
+            out.append(_scale_shift(r, tuple([0] * len(lm)), pow(r[lm], -1, p), p))
+    return sorted(out, key=lambda g: monomial_key(_lead(g)), reverse=True)
+def is_groebner_basis(basis, prime):
+    """True when every S-polynomial of the basis reduces to zero."""
+    p = int(prime)
+    for f, g in combinations(basis, 2):
+        if normal_form(spoly(f, g, p), basis, p):
+            return False
+    return True

build/torch213-cxx11-cu132-x86_64-linux/_groebner_cuda_0bb395a.abi3.so ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:9ae8748c0564ec772519295004771a64bd9c39407ed5235da7d93cd1b3ad8863
+size 302224

build/torch213-cxx11-cu132-x86_64-linux/_ops.py ADDED Viewed

	@@ -0,0 +1,9 @@

+import torch
+from . import _groebner_cuda_0bb395a
+ops = torch.ops._groebner_cuda_0bb395a
+def add_op_namespace_prefix(op_name: str):
+    """
+    Prefix op by namespace.
+    """
+    return f"_groebner_cuda_0bb395a::{op_name}"

build/torch213-cxx11-cu132-x86_64-linux/groebner/__init__.py ADDED Viewed

	@@ -0,0 +1,26 @@

+import ctypes
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+def _import_from_path(file_path: Path) -> ModuleType:
+    # We cannot use the module name as-is, after adding it to `sys.modules`,
+    # it would also be used for other imports. So, we make a module name that
+    # depends on the path for it to be unique using the hex-encoded hash of
+    # the path.
+    path_hash = "{:x}".format(ctypes.c_size_t(hash(file_path.absolute())).value)
+    module_name = path_hash
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Cannot load spec for {module_name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    if module is None:
+        raise ImportError(f"Cannot load module {module_name} from spec")
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)  # type: ignore
+    return module
+globals().update(vars(_import_from_path(Path(__file__).parent.parent / "__init__.py")))

build/torch213-cxx11-cu132-x86_64-linux/metadata.json ADDED Viewed

	@@ -0,0 +1,38 @@

+{
+  "name": "groebner",
+  "id": "_groebner_cuda_0bb395a",
+  "version": 1,
+  "license": "Apache-2.0",
+  "python-depends": [],
+  "backend": {
+    "type": "cuda",
+    "archs": [
+      "10.0",
+      "12.0",
+      "8.0",
+      "8.6",
+      "8.9",
+      "9.0"
+    ]
+  },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "__init__.py": "CpsyiOVGquYAg8QliZu4XdtavY7LBxkm/VqYtFWi+1o=",
+      "_groebner_cuda_0bb395a.abi3.so": "muh0jAVk7HclGSlQBHcaZL2cOUB+1SNdp9k80bOtiGM=",
+      "_ops.py": "HBf/A1FZVh5Vgeu7QDu0SfwcwNiTAPBSdQ0M9mx+p7M=",
+      "groebner/__init__.py": "DFYPlrhXwYjEqCl/8n0SmWGZV8NFml5DPhMjKfv98GY="
+    }
+  },
+  "provenance": {
+    "kernel-builder": {
+      "version": "0.17.0-dev0",
+      "sha": "19aaa6421e674e9fecc352bbae6eab81d19a6bf4",
+      "dirty": false
+    },
+    "kernel": {
+      "sha": "0bb395ae2658cdd9257c1433b06492b34c1a1378",
+      "dirty": false
+    }
+  }
+}