qqideal 0.1.0__tar.gz

qqideal-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DC Posch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qqideal-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: qqideal
+Version: 0.1.0
+Summary: Exact ideals over QQ: python-flint for arithmetic, msolve for Groebner bases.
+Author: DC Posch
+License: MIT
+Project-URL: Homepage, https://github.com/dcposch/qqideal
+Project-URL: Source, https://github.com/dcposch/qqideal
+Keywords: msolve,groebner,ideal,polynomial,computer-algebra
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msolveio>=0.1.0
+Requires-Dist: python-flint<1,>=0.8
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# qqideal
+
+Exact ideals over QQ: python-flint for arithmetic, msolve for Gröbner bases, verdicts that
+refuse to guess. Emptiness, dimension, and 0-dimensional degree from grevlex leading ideals.
+No solver-mode I/O.
+
+## Install
+
+```
+pip install qqideal
+```
+
+That pulls [msolveio](https://pypi.org/project/msolveio/) and python-flint from PyPI. You also
+need a system `msolve` 0.10.x binary on `PATH`.
+
+## Usage
+
+```python
+from qqideal import Ideal, Kind, Ring, ideal_verdict
+
+R = Ring("x", "y")
+I = Ideal(["x^2-1", "y-x"], ring=R)
+
+verdict = ideal_verdict(I)
+print(verdict.kind)       # Kind.NONEMPTY
+print(verdict.dim)        # 0
+print(verdict.degree)     # 2
+print(verdict.certainty)  # Certainty.PROVEN
+
+if verdict.kind is Kind.NONEMPTY:   # never `if verdict:` -- that raises
+    print(I.groebner())             # (Poly('x - y', ...), Poly('y^2 - 1', ...))
+```
+
+`Verdict.__bool__` raises `TypeError`. `TIMEOUT` and `ERROR` are not answers, and a
+truthiness test would silently fold them into one of the two that are.
+
+`opens=` saturates before the test, so you can ask about the complement of a hypersurface:
+
+```python
+ideal_verdict(["x*y", "x"], ring=R, opens=["x"]).kind   # Kind.EMPTY
+Ideal(["x^2"], ring=R).radical_member("x").kind         # Kind.EMPTY: x is in the radical
+```
+
+## Certainty
+
+A unit ideal over Q from msolve `-g` is `Certainty.MODULAR`, not `PROVEN`: msolve 0.10.1
+returns after its first modular prime and still prints characteristic 0. A nonempty result
+over Q uses a lifted `-g 2` basis and is `Certainty.PROVEN`, as is any result over a prime
+field.
+
+## Saturation
+
+`I.saturate(f)` is Rabinowitsch: it returns `I + (u*f - 1)` in the ring extended by one slack
+variable. Its variety is `V(I) \ V(f)`, so emptiness, dimension, and degree are those of
+`I : f^∞` -- but its generators are not that ideal written back in `R`, which would need an
+elimination order msolve's Gröbner mode does not offer. `colon` is an alias, and in v0.1 the
+colon is the saturation.
+
+## Not in v0.1
+
+Primary decomposition, positive-dimensional radicals, radical computation of any kind
+(membership only), solver mode / `-P`, Macaulay2. These raise `NotImplementedError` rather
+than returning an approximation.
+
+## License
+
+MIT © 2026 DC Posch — <https://github.com/dcposch/qqideal>

qqideal-0.1.0/README.md

@@ -0,0 +1,67 @@
+# qqideal
+
+Exact ideals over QQ: python-flint for arithmetic, msolve for Gröbner bases, verdicts that
+refuse to guess. Emptiness, dimension, and 0-dimensional degree from grevlex leading ideals.
+No solver-mode I/O.
+
+## Install
+
+```
+pip install qqideal
+```
+
+That pulls [msolveio](https://pypi.org/project/msolveio/) and python-flint from PyPI. You also
+need a system `msolve` 0.10.x binary on `PATH`.
+
+## Usage
+
+```python
+from qqideal import Ideal, Kind, Ring, ideal_verdict
+
+R = Ring("x", "y")
+I = Ideal(["x^2-1", "y-x"], ring=R)
+
+verdict = ideal_verdict(I)
+print(verdict.kind)       # Kind.NONEMPTY
+print(verdict.dim)        # 0
+print(verdict.degree)     # 2
+print(verdict.certainty)  # Certainty.PROVEN
+
+if verdict.kind is Kind.NONEMPTY:   # never `if verdict:` -- that raises
+    print(I.groebner())             # (Poly('x - y', ...), Poly('y^2 - 1', ...))
+```
+
+`Verdict.__bool__` raises `TypeError`. `TIMEOUT` and `ERROR` are not answers, and a
+truthiness test would silently fold them into one of the two that are.
+
+`opens=` saturates before the test, so you can ask about the complement of a hypersurface:
+
+```python
+ideal_verdict(["x*y", "x"], ring=R, opens=["x"]).kind   # Kind.EMPTY
+Ideal(["x^2"], ring=R).radical_member("x").kind         # Kind.EMPTY: x is in the radical
+```
+
+## Certainty
+
+A unit ideal over Q from msolve `-g` is `Certainty.MODULAR`, not `PROVEN`: msolve 0.10.1
+returns after its first modular prime and still prints characteristic 0. A nonempty result
+over Q uses a lifted `-g 2` basis and is `Certainty.PROVEN`, as is any result over a prime
+field.
+
+## Saturation
+
+`I.saturate(f)` is Rabinowitsch: it returns `I + (u*f - 1)` in the ring extended by one slack
+variable. Its variety is `V(I) \ V(f)`, so emptiness, dimension, and degree are those of
+`I : f^∞` -- but its generators are not that ideal written back in `R`, which would need an
+elimination order msolve's Gröbner mode does not offer. `colon` is an alias, and in v0.1 the
+colon is the saturation.
+
+## Not in v0.1
+
+Primary decomposition, positive-dimensional radicals, radical computation of any kind
+(membership only), solver mode / `-P`, Macaulay2. These raise `NotImplementedError` rather
+than returning an approximation.
+
+## License
+
+MIT © 2026 DC Posch — <https://github.com/dcposch/qqideal>

qqideal-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qqideal"
+version = "0.1.0"
+description = "Exact ideals over QQ: python-flint for arithmetic, msolve for Groebner bases."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "DC Posch" }]
+keywords = ["msolve", "groebner", "ideal", "polynomial", "computer-algebra"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Typing :: Typed",
+]
+dependencies = [
+    "msolveio>=0.1.0",
+    "python-flint>=0.8,<1",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://github.com/dcposch/qqideal"
+Source = "https://github.com/dcposch/qqideal"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+qqideal = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

qqideal-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

qqideal-0.1.0/src/qqideal/__init__.py

@@ -0,0 +1,37 @@
+"""Exact ideals over Q, with python-flint for arithmetic and msolve for
+Groebner bases.
+
+qqideal answers three questions about an ideal -- is its variety empty, what is
+its dimension, and (when the dimension is zero) what is its degree -- and
+refuses the rest. It is not a computer algebra system: anything outside that
+slate raises :class:`NotImplementedError` rather than returning something
+approximate.
+
+msolve is called in Groebner mode only. Solver mode and ``-P`` parametrizations
+are never invoked, so no output whose meaning depends on the mode is ever
+interpreted.
+"""
+
+from __future__ import annotations
+
+from .doublepoint import double_point_ideal
+from .errors import MsolveInputError, QQIdealError, RingMismatch
+from .ideal import Ideal
+from .ring import Poly, Ring
+from .verdict import Certainty, Kind, Verdict, ideal_verdict
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Ring",
+    "Poly",
+    "Ideal",
+    "Kind",
+    "Certainty",
+    "Verdict",
+    "ideal_verdict",
+    "double_point_ideal",
+    "QQIdealError",
+    "RingMismatch",
+    "MsolveInputError",
+]

qqideal-0.1.0/src/qqideal/dimdeg.py

@@ -0,0 +1,127 @@
+"""Krull dimension and 0-dimensional degree, read off a leading ideal.
+
+Both quantities are combinatorial once you have the leading monomials of a
+Groebner basis: ``k[x]/I`` and ``k[x]/LT(I)`` have the same Hilbert function, so
+they have the same dimension, and in the 0-dimensional case the same vector
+space dimension over ``k``. Nothing here talks to msolve; the input is just
+exponent vectors, which makes it cheap to test.
+
+The convention for the unit ideal is ``dimension == -1``: ``LT(I)`` contains the
+constant monomial, ``k[x]/I`` is the zero ring, and the variety is empty.
+"""
+
+from __future__ import annotations
+
+from itertools import product
+from typing import Iterable, Sequence
+
+__all__ = ["dimension", "degree", "dim_and_degree"]
+
+
+def dimension(leading: Iterable[Sequence[int]], nvars: int) -> int:
+    """Krull dimension of ``k[x1..xn]/I`` from the leading monomials of ``I``.
+
+    The dimension is the largest number of variables ``S`` such that ``LT(I)``
+    contains no monomial supported entirely inside ``S``.
+
+    :param leading: exponent vectors of the leading monomials, each of length
+        ``nvars``. An empty collection means the zero ideal.
+    :param nvars: the number of variables.
+    :returns: the dimension, or ``-1`` for the unit ideal.
+    """
+    supports = _supports(leading, nvars)
+    best = -1
+
+    def search(start: int, chosen: int, size: int) -> None:
+        nonlocal best
+        # Independence is downward closed, so a dependent set prunes the whole
+        # subtree below it.
+        if any(support & ~chosen == 0 for support in supports):
+            return
+        if size > best:
+            best = size
+        for index in range(start, nvars):
+            if size + (nvars - index) <= best:
+                break
+            search(index + 1, chosen | (1 << index), size + 1)
+
+    search(0, 0, 0)
+    return best
+
+
+def degree(leading: Iterable[Sequence[int]], nvars: int) -> int:
+    """Number of standard monomials, i.e. ``dim_k k[x1..xn]/I``.
+
+    This is the affine degree of a 0-dimensional ideal, counted with
+    multiplicity.
+
+    :raises ValueError: unless the ideal is 0-dimensional. In positive dimension
+        there are infinitely many standard monomials and no such number.
+    """
+    monomials = _normalize(leading, nvars)
+    bounds: list[int] = []
+    for index in range(nvars):
+        pure = [
+            monomial[index]
+            for monomial in monomials
+            if all(e == 0 for position, e in enumerate(monomial) if position != index)
+        ]
+        if not pure:
+            raise ValueError(
+                f"the ideal is not 0-dimensional: the leading ideal contains no "
+                f"pure power of variable {index}"
+            )
+        bounds.append(min(pure))
+    if any(bound == 0 for bound in bounds):
+        # A pure power with exponent 0 is the constant monomial: the unit ideal.
+        return 0
+
+    count = 0
+    for candidate in product(*(range(bound) for bound in bounds)):
+        if not any(_divides(monomial, candidate) for monomial in monomials):
+            count += 1
+    return count
+
+
+def dim_and_degree(
+    leading: Iterable[Sequence[int]], nvars: int
+) -> tuple[int, int | None]:
+    """``(dimension, degree)``, with ``degree`` only when the dimension is 0."""
+    monomials = _normalize(leading, nvars)
+    dim = dimension(monomials, nvars)
+    if dim != 0:
+        return dim, None
+    return dim, degree(monomials, nvars)
+
+
+def _normalize(
+    leading: Iterable[Sequence[int]], nvars: int
+) -> tuple[tuple[int, ...], ...]:
+    monomials: list[tuple[int, ...]] = []
+    for monomial in leading:
+        exponents = tuple(int(e) for e in monomial)
+        if len(exponents) != nvars:
+            raise ValueError(
+                f"leading monomial {exponents} has {len(exponents)} exponents, "
+                f"expected {nvars}"
+            )
+        if any(e < 0 for e in exponents):
+            raise ValueError(f"leading monomial {exponents} has a negative exponent")
+        monomials.append(exponents)
+    return tuple(monomials)
+
+
+def _supports(leading: Iterable[Sequence[int]], nvars: int) -> tuple[int, ...]:
+    """One bitmask per leading monomial, marking which variables it uses."""
+    masks = set()
+    for monomial in _normalize(leading, nvars):
+        mask = 0
+        for index, exponent in enumerate(monomial):
+            if exponent:
+                mask |= 1 << index
+        masks.add(mask)
+    return tuple(masks)
+
+
+def _divides(monomial: Sequence[int], candidate: Sequence[int]) -> bool:
+    return all(a <= b for a, b in zip(monomial, candidate))

qqideal-0.1.0/src/qqideal/doublepoint.py

@@ -0,0 +1,96 @@
+"""The double-point ideal of a polynomial parametrization.
+
+For a plane curve parametrized by ``t -> (p(t), q(t))``, two distinct parameters
+land on the same point exactly when ``p(s) = p(t)`` and ``q(s) = q(t)`` with
+``s != t``. That is the ideal
+
+    I_DP = (p(s) - p(t), q(s) - q(t)) : (s - t)^oo
+
+in ``QQ[s, t]``: saturating at ``s - t`` throws away the diagonal, which solves
+the equations trivially and says nothing.
+
+This module builds that ideal and stops there. It is not a test for whether a
+parametrization is an embedding: an injective map can still fail to be one, and
+the cusp ``t -> (t^2, t^3)`` is the standard example -- it has no double point
+at all, and fails on the derivative instead. Deciding embedding needs the rest
+of the postcheck (length, immersivity, distinct tangents), which is not here.
+"""
+
+from __future__ import annotations
+
+from .errors import MsolveInputError, RingMismatch
+from .ideal import Ideal
+from .ring import Poly, Ring
+
+__all__ = ["double_point_ideal"]
+
+
+def double_point_ideal(
+    p: "Poly | str",
+    q: "Poly | str",
+    *,
+    ring: Ring | None = None,
+    names: tuple[str, str] = ("s", "t"),
+) -> Ideal:
+    """Build ``(p(s)-p(t), q(s)-q(t)) : (s-t)^oo`` for the parametrization
+    ``(p, q)``.
+
+    :param p: first coordinate, a univariate polynomial or a string.
+    :param q: second coordinate, likewise.
+    :param ring: the univariate source ring, required if ``p`` or ``q`` is a
+        string.
+    :param names: the two parameter names to use.
+    :returns: an :class:`~qqideal.Ideal`. As with
+        :meth:`~qqideal.Ideal.saturate`, the saturation is carried as a
+        Rabinowitsch ideal, so the ideal lives in ``QQ[s, t, u]`` with
+        ``u*(s-t) - 1`` among its generators, and its variety is the set of
+        ordered pairs ``s != t`` with the same image. Emptiness, dimension and
+        degree are the ones of the double-point locus.
+    :raises MsolveInputError: if the source ring is not univariate.
+    """
+    source = _source_ring(p, q, ring)
+    if source.nvars != 1:
+        raise MsolveInputError(
+            f"a parametrization is univariate; got {source} with "
+            f"{source.nvars} variables"
+        )
+    if len(names) != 2 or names[0] == names[1]:
+        raise MsolveInputError(f"names must be two distinct variables, got {names!r}")
+
+    poly_p = _coerce(source, p)
+    poly_q = _coerce(source, q)
+
+    plane = Ring(*names, characteristic=source.characteristic)
+    s, t = plane.gens()
+    equations = [
+        _substitute(poly_p, plane, 0) - _substitute(poly_p, plane, 1),
+        _substitute(poly_q, plane, 0) - _substitute(poly_q, plane, 1),
+    ]
+    return Ideal(equations, ring=plane).saturate(s - t)
+
+
+def _source_ring(p: "Poly | str", q: "Poly | str", ring: Ring | None) -> Ring:
+    rings = {value.ring for value in (p, q) if isinstance(value, Poly)}
+    if ring is not None:
+        rings.add(ring)
+    if not rings:
+        raise MsolveInputError("ring= is required when p and q are strings")
+    if len(rings) > 1:
+        raise RingMismatch(
+            f"p and q must live in one ring, got {sorted(str(r) for r in rings)}"
+        )
+    return rings.pop()
+
+
+def _coerce(ring: Ring, value: "Poly | str") -> Poly:
+    return ring(value) if isinstance(value, str) else ring._check(value)
+
+
+def _substitute(poly: Poly, plane: Ring, position: int) -> Poly:
+    """Send the source variable to variable ``position`` of the plane ring."""
+    terms = {}
+    for exponents, coeff in poly.terms():
+        key = [0, 0]
+        key[position] = exponents[0]
+        terms[tuple(key)] = coeff
+    return plane._wrap(plane._ctx.from_dict(terms))

qqideal-0.1.0/src/qqideal/errors.py

@@ -0,0 +1,52 @@
+"""Exceptions raised by qqideal.
+
+Two rules decide which exception a failure gets:
+
+* A caller mistake -- an unparseable polynomial, a ring mismatch, a request
+  outside the v0.1 slate -- raises. Callers should not have to inspect a
+  :class:`~qqideal.Verdict` to discover they wrote ``x/2``.
+* A solver failure -- msolve timing out, dying, or emitting bytes we refuse to
+  interpret -- becomes a :class:`~qqideal.Verdict` with
+  :attr:`~qqideal.Kind.TIMEOUT` or :attr:`~qqideal.Kind.ERROR`.
+
+Input errors are reported as msolveio's :class:`~msolveio.MsolveInputError`
+rather than a new type, so that a bad polynomial raises the same exception
+whether qqideal or msolveio caught it.
+"""
+
+from __future__ import annotations
+
+from msolveio import (
+    MsolveAmbiguous,
+    MsolveDied,
+    MsolveError,
+    MsolveInputError,
+    MsolveOutputError,
+    MsolveTimeout,
+    MsolveVersionUnsupported,
+)
+
+__all__ = [
+    "QQIdealError",
+    "RingMismatch",
+    "MsolveError",
+    "MsolveInputError",
+    "MsolveOutputError",
+    "MsolveAmbiguous",
+    "MsolveTimeout",
+    "MsolveDied",
+    "MsolveVersionUnsupported",
+]
+
+
+class QQIdealError(Exception):
+    """Base class for errors qqideal raises on its own behalf."""
+
+
+class RingMismatch(QQIdealError, TypeError):
+    """Two polynomials from different rings were combined.
+
+    qqideal never coerces across rings implicitly: ``QQ[x]`` and ``QQ[x,y]``
+    are different rings, and so are ``QQ[x,y]`` and ``F_p[x,y]``. Use
+    :meth:`qqideal.Ring.embed` to move a polynomial deliberately.
+    """