passagemath-msolve 10.6.47__tar.gz

passagemath_msolve-10.6.47/MANIFEST.in

@@ -0,0 +1,25 @@
+graft passagemath_msolve
+
+prune sage
+
+include VERSION.txt
+
+include sage/libs/msolve.p*
+include sage/rings/polynomial/msolve.p*
+
+global-exclude *.c
+global-exclude *.cpp
+
+global-exclude all__sagemath_*.py
+global-include all__sagemath_msolve.py
+
+include repair_wheel.py
+
+global-exclude __pycache__
+global-exclude *.py[co]
+global-exclude *.bak
+global-exclude *.so
+global-exclude *~
+prune .tox
+prune build
+prune dist

passagemath_msolve-10.6.47/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: passagemath-msolve
+Version: 10.6.47
+Summary: passagemath: Polynomial system solving through algebraic methods with msolve
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/x-rst
+Requires-Dist: cysignals!=1.12.4; sys_platform == "win32"
+Requires-Dist: cysignals!=1.12.0,>=1.11.2
+Requires-Dist: passagemath-categories~=10.6.47.0
+Requires-Dist: passagemath-flint~=10.6.47.0
+Requires-Dist: passagemath-modules~=10.6.47.0
+Requires-Dist: passagemath-repl~=10.6.47.0
+Provides-Extra: test
+
+============================================================================
+passagemath: Polynomial system solving through algebraic methods with msolve
+============================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.14.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-msolve`` provides an interface to `msolve <https://msolve.lip6.fr/>`_, which implements computer algebra algorithms for solving polynomial systems (with rational coefficients or coefficients in a prime field).
+
+
+Examples
+--------
+
+A quick way to try it out interactively::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-msolve[test]" ipython
+
+    In [1]: from passagemath_msolve import *
+
+    In [2]: R = PolynomialRing(QQ, 2, names=['x', 'y'], order='lex')
+
+    In [3]: x, y = R.gens()
+
+    In [4]: I = Ideal([ x*y - 1, (x-2)**2 + (y-1)**2 - 1])
+
+    In [5]: I.variety(RBF, algorithm='msolve', proof=False)
+    Out[5]:
+    [{x: [2.76929235423863 +/- 2.08e-15], y: [0.361103080528647 +/- 4.53e-16]},
+     {x: 1.000000000000000, y: 1.000000000000000}]

passagemath_msolve-10.6.47/README.rst

@@ -0,0 +1,74 @@
+============================================================================
+passagemath: Polynomial system solving through algebraic methods with msolve
+============================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.14.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-msolve`` provides an interface to `msolve <https://msolve.lip6.fr/>`_, which implements computer algebra algorithms for solving polynomial systems (with rational coefficients or coefficients in a prime field).
+
+
+Examples
+--------
+
+A quick way to try it out interactively::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-msolve[test]" ipython
+
+    In [1]: from passagemath_msolve import *
+
+    In [2]: R = PolynomialRing(QQ, 2, names=['x', 'y'], order='lex')
+
+    In [3]: x, y = R.gens()
+
+    In [4]: I = Ideal([ x*y - 1, (x-2)**2 + (y-1)**2 - 1])
+
+    In [5]: I.variety(RBF, algorithm='msolve', proof=False)
+    Out[5]:
+    [{x: [2.76929235423863 +/- 2.08e-15], y: [0.361103080528647 +/- 4.53e-16]},
+     {x: 1.000000000000000, y: 1.000000000000000}]

passagemath_msolve-10.6.47/VERSION.txt

@@ -0,0 +1 @@
+10.6.47

passagemath_msolve-10.6.47/passagemath_msolve/__init__.py

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-msolve
+
+from sage.all__sagemath_msolve import *

passagemath_msolve-10.6.47/passagemath_msolve.egg-info/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: passagemath-msolve
+Version: 10.6.47
+Summary: passagemath: Polynomial system solving through algebraic methods with msolve
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/x-rst
+Requires-Dist: cysignals!=1.12.4; sys_platform == "win32"
+Requires-Dist: cysignals!=1.12.0,>=1.11.2
+Requires-Dist: passagemath-categories~=10.6.47.0
+Requires-Dist: passagemath-flint~=10.6.47.0
+Requires-Dist: passagemath-modules~=10.6.47.0
+Requires-Dist: passagemath-repl~=10.6.47.0
+Provides-Extra: test
+
+============================================================================
+passagemath: Polynomial system solving through algebraic methods with msolve
+============================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.14.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-msolve`` provides an interface to `msolve <https://msolve.lip6.fr/>`_, which implements computer algebra algorithms for solving polynomial systems (with rational coefficients or coefficients in a prime field).
+
+
+Examples
+--------
+
+A quick way to try it out interactively::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-msolve[test]" ipython
+
+    In [1]: from passagemath_msolve import *
+
+    In [2]: R = PolynomialRing(QQ, 2, names=['x', 'y'], order='lex')
+
+    In [3]: x, y = R.gens()
+
+    In [4]: I = Ideal([ x*y - 1, (x-2)**2 + (y-1)**2 - 1])
+
+    In [5]: I.variety(RBF, algorithm='msolve', proof=False)
+    Out[5]:
+    [{x: [2.76929235423863 +/- 2.08e-15], y: [0.361103080528647 +/- 4.53e-16]},
+     {x: 1.000000000000000, y: 1.000000000000000}]

passagemath_msolve-10.6.47/passagemath_msolve.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+MANIFEST.in
+README.rst
+VERSION.txt
+pyproject.toml
+repair_wheel.py
+setup.py
+passagemath_msolve/__init__.py
+passagemath_msolve.egg-info/PKG-INFO
+passagemath_msolve.egg-info/SOURCES.txt
+passagemath_msolve.egg-info/dependency_links.txt
+passagemath_msolve.egg-info/requires.txt
+passagemath_msolve.egg-info/top_level.txt
+sage/all__sagemath_msolve.py
+sage/libs/all__sagemath_msolve.py
+sage/libs/msolve.pyx
+sage/rings/all__sagemath_msolve.py
+sage/rings/polynomial/all__sagemath_msolve.py
+sage/rings/polynomial/msolve.py

passagemath_msolve-10.6.47/passagemath_msolve.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

passagemath_msolve-10.6.47/passagemath_msolve.egg-info/requires.txt

@@ -0,0 +1,10 @@
+cysignals!=1.12.0,>=1.11.2
+passagemath-categories~=10.6.47.0
+passagemath-flint~=10.6.47.0
+passagemath-modules~=10.6.47.0
+passagemath-repl~=10.6.47.0
+
+[:sys_platform == "win32"]
+cysignals!=1.12.4
+
+[test]

passagemath_msolve-10.6.47/passagemath_msolve.egg-info/top_level.txt

@@ -0,0 +1 @@
+

passagemath_msolve-10.6.47/pyproject.toml

@@ -0,0 +1,101 @@
+[build-system]
+# Minimum requirements for the build system to execute.
+requires = [
+    'setuptools >= 77.0.0',
+    'pkgconfig',
+    'passagemath-conf ~= 10.6.47.0 ; sys_platform != "win32"',
+    'passagemath-setup ~= 10.6.47.0',
+    'passagemath-categories ~= 10.6.47.0',
+    'passagemath-environment ~= 10.6.47.0',
+    'passagemath-objects ~= 10.6.47.0',
+    'cython >=3.0.8, <3.3.0', 'cython >=3.0.8,<3.3.0',
+    'cysignals !=1.12.4; sys_platform == "win32"', 'cysignals >=1.11.2, != 1.12.0',
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "passagemath-msolve"
+description = "passagemath: Polynomial system solving through algebraic methods with msolve"
+dependencies = [
+    'cysignals !=1.12.4; sys_platform == "win32"', 'cysignals >=1.11.2, != 1.12.0',
+    'passagemath-categories ~= 10.6.47.0',
+    'passagemath-flint ~= 10.6.47.0',              'passagemath-modules ~= 10.6.47.0',            'passagemath-repl ~= 10.6.47.0',           ]
+dynamic = ["version"]
+license = "GPL-2.0-or-later"
+authors = [{name = "The Sage Developers", email = "sage-support@googlegroups.com"}]
+maintainers = [
+    {name = "Matthias Köppe"},
+    {name = "passagemath contributors"},
+]
+classifiers = [
+    "Development Status :: 6 - Mature",
+    "Intended Audience :: Education",
+    "Intended Audience :: Science/Research",
+    "Operating System :: POSIX",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS :: MacOS X",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+requires-python = ">=3.10, <3.15"
+
+[project.urls]
+"release notes" = "https://github.com/passagemath/passagemath/releases"
+"repo (upstream)" = "https://github.com/sagemath/sage"
+"repo" = "https://github.com/passagemath/passagemath"
+documentation = "https://passagemath.org/docs/latest"
+"homepage (upstream)" = "https://www.sagemath.org"
+"discourse" = "https://passagemath.discourse.group"
+"tracker (upstream)" = "https://github.com/sagemath/sage/issues"
+"tracker" = "https://github.com/passagemath/passagemath/issues"
+
+[project.readme]
+file = "README.rst"
+content-type = "text/x-rst"
+
+[project.optional-dependencies]
+test = [
+]
+
+[tool.cibuildwheel.linux]
+repair-wheel-command = [
+    'python3 -m pip install passagemath-conf auditwheel',
+    'python3 {package}/repair_wheel.py {wheel}',
+    'auditwheel repair -w {dest_dir} {wheel}',
+]
+[tool.cibuildwheel.macos]
+repair-wheel-command = [
+    'python3 -m pip install passagemath-conf auditwheel',
+    'python3 {package}/repair_wheel.py {wheel}',
+    'delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}',
+]
+
+[tool.setuptools]
+include-package-data = false
+
+[tool.setuptools.dynamic]
+version = {file = ["VERSION.txt"]}
+
+[external]
+# External dependencies in the format proposed by https://peps.python.org/pep-0725
+build-requires = [
+  "virtual:compiler/c",
+  "virtual:compiler/cpp",
+  "pkg:generic/pkg-config",
+]
+
+host-requires = [
+  "pkg:generic/msolve",
+  "pkg:generic/gmp",
+  "pkg:generic/mpc",
+  "pkg:generic/mpfr",
+]
+
+dependencies = [
+]

passagemath_msolve-10.6.47/repair_wheel.py

@@ -0,0 +1,24 @@
+# Add data to the wheel
+
+import os
+import shlex
+import sys
+
+from pathlib import Path
+
+from auditwheel.wheeltools import InWheel
+
+from sage_conf import SAGE_LOCAL
+
+if "TMPDIR" in os.environ:
+    os.environ["TMPDIR"] = str(Path(os.environ["TMPDIR"]).resolve())
+
+wheel = Path(sys.argv[1])
+
+# SAGE_LOCAL/bin/msolve --> sage_wheels/bin/msolve
+with InWheel(wheel, wheel):
+    command = f'set -o pipefail; (cd {shlex.quote(SAGE_LOCAL)} && tar cf - --dereference bin/msolve) | (mkdir -p sage_wheels && cd sage_wheels && tar xvf -)'
+    print(f'Running {command}')
+    sys.stdout.flush()
+    if os.system(f"bash -c {shlex.quote(command)}") != 0:
+        sys.exit(1)

passagemath_msolve-10.6.47/sage/all__sagemath_msolve.py

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-msolve
+# delvewheel: patch
+
+from sage.all__sagemath_flint import *
+from sage.all__sagemath_modules import *

passagemath_msolve-10.6.47/sage/libs/all__sagemath_msolve.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-msolve

passagemath_msolve-10.6.47/sage/libs/msolve.pyx

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-msolve

passagemath_msolve-10.6.47/sage/rings/all__sagemath_msolve.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-msolve

passagemath_msolve-10.6.47/sage/rings/polynomial/all__sagemath_msolve.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-msolve

passagemath_msolve-10.6.47/sage/rings/polynomial/msolve.py

@@ -0,0 +1,322 @@
+# sage_setup: distribution = sagemath-msolve
+# sage.doctest: optional - msolve
+r"""
+Solution of polynomial systems using msolve
+
+`msolve <https://msolve.lip6.fr/>`_ is a multivariate polynomial system solver
+based on Gröbner bases.
+
+This module provide implementations of some operations on polynomial ideals
+based on msolve.
+
+Note that the :ref:`optional package msolve <spkg_msolve>` must be installed.
+
+.. SEEALSO::
+
+    - :mod:`sage.features.msolve`
+    - :mod:`sage.rings.polynomial.multi_polynomial_ideal`
+"""
+
+import os
+import tempfile
+import subprocess
+
+import sage.structure.proof.proof
+
+from sage.features.msolve import msolve
+from sage.misc.converting_dict import KeyConvertingDict
+from sage.misc.sage_eval import sage_eval
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+from sage.rings.finite_rings.finite_field_base import FiniteField
+from sage.rings.rational_field import QQ
+from sage.rings.real_arb import RealBallField
+from sage.rings.real_double import RealDoubleField_class
+from sage.rings.real_mpfr import RealField_class
+from sage.rings.real_mpfi import RealIntervalField_class, RealIntervalField
+from sage.structure.sequence import Sequence
+
+
+def _run_msolve(ideal, options):
+    r"""
+    Internal utility function
+    """
+
+    base = ideal.base_ring()
+    if not (base is QQ or isinstance(base, FiniteField) and
+            base.is_prime_field() and base.characteristic() < 2**31):
+        raise NotImplementedError(f"unsupported base field: {base}")
+
+    # Run msolve
+
+    drlpolring = ideal.ring().change_ring(order='degrevlex')
+    polys = ideal.change_ring(drlpolring).gens()
+    msolve_in = tempfile.NamedTemporaryFile(mode='w',
+                                            encoding='ascii', delete=False)
+    command = [msolve().absolute_filename(), "-f", msolve_in.name] + options
+    try:
+        print(",".join(drlpolring.variable_names()), file=msolve_in)
+        print(base.characteristic(), file=msolve_in)
+        print(*(pol._repr_().replace(" ", "") for pol in polys),
+                sep=',\n', file=msolve_in)
+        msolve_in.close()
+        msolve_out = subprocess.run(command, capture_output=True, text=True)
+    finally:
+        os.unlink(msolve_in.name)
+    msolve_out.check_returncode()
+
+    return msolve_out.stdout
+
+
+def groebner_basis_degrevlex(ideal, proof=True):
+    r"""
+    Compute a degrevlex Gröbner basis using msolve
+
+    EXAMPLES::
+
+        sage: from sage.rings.polynomial.msolve import groebner_basis_degrevlex
+
+        sage: # needs sage.libs.singular
+        sage: R.<a,b,c> = PolynomialRing(GF(101), 3, order='lex')
+        sage: I = sage.rings.ideal.Katsura(R,3)
+        sage: gb = groebner_basis_degrevlex(I); gb # optional - msolve
+        [a + 2*b + 2*c - 1, b*c - 19*c^2 + 10*b + 40*c,
+        b^2 - 41*c^2 + 20*b - 20*c, c^3 + 28*c^2 - 37*b + 13*c]
+        sage: gb.universe() is R # optional - msolve
+        False
+        sage: gb.universe().term_order() # optional - msolve
+        Degree reverse lexicographic term order
+        sage: ideal(gb).transformed_basis(other_ring=R) # optional - msolve
+        [c^4 + 38*c^3 - 6*c^2 - 6*c, 30*c^3 + 32*c^2 + b - 14*c,
+        a + 2*b + 2*c - 1]
+
+    Gröbner bases over the rationals require `proof=False`::
+
+        sage: R.<x, y> = PolynomialRing(QQ, 2)
+        sage: I = Ideal([ x*y - 1, (x-2)^2 + (y-1)^2 - 1])
+        sage: I.groebner_basis(algorithm='msolve') # optional - msolve
+        Traceback (most recent call last):
+        ...
+        ValueError: msolve relies on heuristics; please use proof=False
+        sage: I.groebner_basis(algorithm='msolve', proof=False) # optional - msolve
+        [x*y - 1, x^2 + y^2 - 4*x - 2*y + 4, y^3 - 2*y^2 + x + 4*y - 4]
+
+    TESTS::
+
+        sage: # needs sage.rings.finite_rings
+        sage: R.<foo, bar> = PolynomialRing(GF(536870909), 2)
+        sage: I = Ideal([ foo^2 - 1, bar^2 - 1 ])
+        sage: I.groebner_basis(algorithm='msolve') # optional - msolve
+        [bar^2 - 1, foo^2 - 1]
+    """
+
+    if ideal.base_ring() is QQ and sage.structure.proof.proof.get_flag(proof, "polynomial"):
+            raise ValueError("msolve relies on heuristics; please use proof=False")
+
+    drlpolring = ideal.ring().change_ring(order='degrevlex')
+    msolve_out = _run_msolve(ideal, ["-g", "2"])
+    gbasis = sage_eval(msolve_out[:-2], locals=drlpolring.gens_dict())
+    return Sequence(gbasis)
+
+
+def variety(ideal, ring, *, proof=True):
+    r"""
+    Compute the variety of a zero-dimensional ideal using msolve.
+
+    Part of the initial implementation was loosely based on the example
+    interfaces available as part of msolve, with the authors' permission.
+
+    EXAMPLES::
+
+        sage: # needs sage.rings.finite_rings
+        sage: from sage.rings.polynomial.msolve import variety
+        sage: p = 536870909
+        sage: R.<x, y> = PolynomialRing(GF(p), 2, order='lex')
+        sage: I = Ideal([ x*y - 1, (x-2)^2 + (y-1)^2 - 1])
+        sage: sorted(variety(I, GF(p^2), proof=False), key=str) # optional - msolve
+        [{x: 1, y: 1},
+         {x: 254228855*z2 + 114981228, y: 232449571*z2 + 402714189},
+         {x: 267525699, y: 473946006},
+         {x: 282642054*z2 + 154363985, y: 304421338*z2 + 197081624}]
+
+    TESTS::
+
+        sage: # needs sage.rings.finite_rings
+        sage: p = 536870909
+        sage: R.<x, y> = PolynomialRing(GF(p), 2, order='lex')
+        sage: I = Ideal([ x*y - 1, (x-2)^2 + (y-1)^2 - 1])
+        sage: sorted(I.variety(algorithm='msolve', proof=False), key=str) # optional - msolve
+        [{x: 1, y: 1}, {x: 267525699, y: 473946006}]
+        sage: K.<a> = GF(p^2)
+        sage: sorted(I.variety(K, algorithm='msolve', proof=False), key=str) # optional - msolve
+        [{x: 1, y: 1},
+         {x: 118750849*a + 194048031, y: 510295713*a + 18174854},
+         {x: 267525699, y: 473946006},
+         {x: 418120060*a + 75297182, y: 26575196*a + 44750050}]
+
+        sage: # needs sage.rings.finite_rings
+        sage: R.<x, y> = PolynomialRing(GF(2147483659), 2, order='lex')
+        sage: ideal([x, y]).variety(algorithm='msolve', proof=False)
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: unsupported base field: Finite Field of size 2147483659
+
+        sage: R.<x, y> = PolynomialRing(QQ, 2, order='lex')
+        sage: I = Ideal([ x*y - 1, (x-2)^2 + (y-1)^2 - 1])
+
+        sage: I.variety(algorithm='msolve', proof=False) # optional - msolve
+        [{x: 1, y: 1}]
+        sage: I.variety(RealField(100), algorithm='msolve', proof=False) # optional - msolve
+        [{x: 2.7692923542386314152404094643, y: 0.36110308052864737763464656216},
+         {x: 1.0000000000000000000000000000, y: 1.0000000000000000000000000000}]
+        sage: I.variety(RealIntervalField(100), algorithm='msolve', proof=False) # optional - msolve
+        [{x: 2.76929235423863141524040946434?, y: 0.361103080528647377634646562159?},
+         {x: 1, y: 1}]
+        sage: I.variety(RBF, algorithm='msolve', proof=False) # optional - msolve
+        [{x: [2.76929235423863 +/- 2.08e-15], y: [0.361103080528647 +/- 4.53e-16]},
+         {x: 1.000000000000000, y: 1.000000000000000}]
+        sage: I.variety(RDF, algorithm='msolve', proof=False) # optional - msolve
+        [{x: 2.7692923542386314, y: 0.36110308052864737}, {x: 1.0, y: 1.0}]
+        sage: I.variety(AA, algorithm='msolve', proof=False) # optional - msolve
+        [{x: 2.769292354238632?, y: 0.3611030805286474?},
+         {x: 1.000000000000000?, y: 1.000000000000000?}]
+        sage: I.variety(QQbar, algorithm='msolve', proof=False) # optional - msolve
+        [{x: 2.769292354238632?, y: 0.3611030805286474?},
+         {x: 1, y: 1},
+         {x: 0.11535382288068429? + 0.5897428050222055?*I, y: 0.3194484597356763? - 1.633170240915238?*I},
+         {x: 0.11535382288068429? - 0.5897428050222055?*I, y: 0.3194484597356763? + 1.633170240915238?*I}]
+        sage: I.variety(ComplexField(100))                                              # needs sage.libs.singular
+        [{y: 1.0000000000000000000000000000, x: 1.0000000000000000000000000000},
+         {y: 0.36110308052864737763464656216, x: 2.7692923542386314152404094643},
+         {y: 0.31944845973567631118267671892 - 1.6331702409152376561188467320*I, x: 0.11535382288068429237979526783 + 0.58974280502220550164728074602*I},
+         {y: 0.31944845973567631118267671892 + 1.6331702409152376561188467320*I, x: 0.11535382288068429237979526783 - 0.58974280502220550164728074602*I}]
+
+        sage: Ideal(x^2 + y^2 - 1, x - y).variety(RBF, algorithm='msolve', proof=False)
+        [{x: [-0.707106781186547 +/- 6.29e-16], y: [-0.707106781186547 +/- 6.29e-16]},
+         {x: [0.707106781186547 +/- 6.29e-16], y: [0.707106781186547 +/- 6.29e-16]}]
+        sage: sorted(Ideal(x^2 - 1, y^2 - 1).variety(QQ, algorithm='msolve', proof=False), key=str)
+        [{x: -1, y: -1}, {x: -1, y: 1}, {x: 1, y: -1}, {x: 1, y: 1}]
+        sage: sorted(Ideal(x^2 - 1, y^2 - 2).variety(CC, algorithm='msolve', proof=False),  # abs tol 1e-10
+        ....:        key=lambda d: (sign(d['x']), sign(d['y'])))
+        [{x: -1.00000000000000, y: -1.41421356237309},
+         {x: -1.00000000000000, y: 1.41421356237309},
+         {x: 1.00000000000000, y: -1.41421356237309},
+         {x: 1.00000000000000, y: 1.41421356237309}]
+        sage: Ideal([x, y, x + y]).variety(algorithm='msolve', proof=False)
+        [{x: 0, y: 0}]
+
+        sage: Ideal([x, y, x + y - 1]).variety(algorithm='msolve', proof=False) # optional - msolve
+        []
+        sage: Ideal([x, y, x + y - 1]).variety(RR, algorithm='msolve', proof=False) # optional - msolve
+        []
+
+        sage: Ideal([x*y - 1]).variety(QQbar, algorithm='msolve', proof=False) # optional - msolve
+        Traceback (most recent call last):
+        ...
+        ValueError: positive-dimensional ideal
+
+        sage: R.<x, y> = PolynomialRing(RR, 2, order='lex')
+        sage: Ideal(x, y).variety(algorithm='msolve', proof=False)
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: unsupported base field: Real Field with 53 bits of precision
+
+        sage: R.<x, y> = PolynomialRing(QQ, 2, order='lex')
+        sage: Ideal(x, y).variety(ZZ, algorithm='msolve', proof=False)
+        Traceback (most recent call last):
+        ...
+        ValueError: no coercion from base field Rational Field to output ring Integer Ring
+    """
+
+    proof = sage.structure.proof.proof.get_flag(proof, "polynomial")
+    if proof:
+        raise ValueError("msolve relies on heuristics; please use proof=False")
+
+    base = ideal.base_ring()
+    if ring is None:
+        ring = base
+    if not ring.has_coerce_map_from(base):
+        raise ValueError(
+            f"no coercion from base field {base} to output ring {ring}")
+
+    if isinstance(ring, (RealIntervalField_class, RealBallField,
+                         RealField_class, RealDoubleField_class)):
+        parameterization = False
+        options = ["-p", str(ring.precision())]
+    else:
+        parameterization = True
+        options = ["-P", "1"]
+
+    msolve_out = _run_msolve(ideal, options)
+
+    # Interpret output
+
+    try:
+        data = sage_eval(msolve_out[:-2])
+    except SyntaxError:
+        raise NotImplementedError(f"unsupported msolve output format: {data}")
+
+    dim = data[0]
+    if dim == -1:
+        return []
+    elif dim > 0:
+        raise ValueError("positive-dimensional ideal")
+    else:
+        assert dim.is_zero()
+
+    out_ring = ideal.ring().change_ring(ring)
+
+    if parameterization:
+
+        def to_poly(p, d=1, *, upol=PolynomialRing(base, 't')):
+            assert len(p[1]) == p[0] + 1 or p == [-1, [0]]
+            return upol(p[1])/d
+
+        try:
+            char, nvars, deg, vars, _, [one, [elim, den, param]] = data[1]
+        except (IndexError, ValueError):
+            raise NotImplementedError(
+                f"unsupported msolve output format: {data}")
+        assert char == ideal.base_ring().characteristic()
+        assert one.is_one()
+        assert len(vars) == nvars
+        ringvars = out_ring.variable_names()
+        assert sorted(vars[:len(ringvars)]) == sorted(ringvars)
+        vars = [out_ring(name) for name in vars[:len(ringvars)]]
+        elim = to_poly(elim)
+        # Criterion suggested by Mohab Safey El Din to avoid cases where there
+        # is no rational parameterization or where the one returned by msolve
+        # has a significant probability of being incorrect.
+        if deg >= char > 0 or 0 < char <= 2**17 and deg != elim.degree():
+            raise NotImplementedError(f"characteristic {char} too small")
+        den = to_poly(den)
+        # As of msolve 0.4.4, param is of the form [pol, denom] in char 0, but
+        # [pol] in char p > 0. My understanding is that both cases will
+        # eventually use the same format, so let's not be too picky.
+        param = [to_poly(*f) for f in param]
+        elim_roots = elim.roots(ring, multiplicities=False)
+        variety = []
+        for rt in elim_roots:
+            den_of_rt = den(rt)
+            point = [-p(rt) / den_of_rt for p in param]
+            if len(param) != len(vars):
+                point.append(rt)
+            assert len(point) == len(vars)
+            variety.append(point)
+
+    else:
+
+        if len(data[1]) < 2 or len(data[1]) != data[1][0] + 1:
+            raise NotImplementedError(
+                f"unsupported msolve output format: {data}")
+        if isinstance(ring, (RealIntervalField_class, RealBallField)):
+            to_out_ring = ring
+        else:
+            assert isinstance(ring, (RealField_class, RealDoubleField_class))
+            myRIF = RealIntervalField(ring.precision())
+            to_out_ring = lambda iv: ring.coerce(myRIF(iv).center())
+        vars = out_ring.gens()
+        variety = [[to_out_ring(iv) for iv in point]
+                   for l in data[1][1:]
+                   for point in l]
+
+    return [KeyConvertingDict(out_ring, zip(vars, point)) for point in variety]

passagemath_msolve-10.6.47/setup.cfg

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

passagemath_msolve-10.6.47/setup.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+
+# PEP 517 builds do not have . in sys.path
+import os
+import sys
+sys.path.insert(0, os.path.dirname(__file__))
+
+from sage_setup import sage_setup
+
+sage_setup(['sagemath-msolve'],
+           recurse_packages=('sage', 'passagemath_msolve'),
+           spkgs=['msolve'],
+           package_data={},
+           py_limited_api=True)