Merge pull request #42 from ACSVMath/module-cleanup

behackl · web-flow · commit 9d3b252c7aa2 · 2025-04-13T20:19:48.000+02:00
Overall module cleanup and refactoring backends
diff --git a/docs/source/reference.rst b/docs/source/reference.rst
@@ -5,10 +5,10 @@ Reference Manual
    :maxdepth: 2
 
    reference/asymptotics
+   reference/backends
    reference/debug
+   reference/groebner
    reference/helpers
    reference/kronecker
-   reference/macaulay2
-   reference/msolve
    reference/settings
    reference/whitney
diff --git a/docs/source/reference/backends.rst b/docs/source/reference/backends.rst
@@ -0,0 +1,14 @@
+Backend Interfaces
+==================
+
+See :class:`.ACSVSettings` for information on how to
+configure the default computational backends. The module
+:mod:`.sage_acsv.groebner` is the entrypoint for Groebner basis
+computations.
+
+.. toctree::
+   :maxdepth: 2
+
+   backends/default
+   backends/macaulay2
+   backends/msolve
diff --git a/docs/source/reference/backends/default.rst b/docs/source/reference/backends/default.rst
@@ -0,0 +1,6 @@
+``default``
+===========
+
+.. automodule:: sage_acsv.backends.default
+   :members:
+   :undoc-members:
diff --git a/docs/source/reference/backends/macaulay2.rst b/docs/source/reference/backends/macaulay2.rst
@@ -1,6 +1,6 @@
 ``macaulay2``
 =============
 
-.. automodule:: sage_acsv.macaulay2
+.. automodule:: sage_acsv.backends.macaulay2
    :members:
    :undoc-members:
diff --git a/docs/source/reference/backends/msolve.rst b/docs/source/reference/backends/msolve.rst
@@ -1,6 +1,6 @@
 ``msolve``
 ==========
 
-.. automodule:: sage_acsv.msolve
+.. automodule:: sage_acsv.backends.msolve
    :members:
    :undoc-members:
diff --git a/docs/source/reference/groebner.rst b/docs/source/reference/groebner.rst
@@ -0,0 +1,6 @@
+``groebner``
+============
+
+.. automodule:: sage_acsv.groebner
+   :members:
+   :undoc-members:
diff --git a/sage_acsv/__init__.py b/sage_acsv/__init__.py
@@ -4,6 +4,6 @@
 __version__ = importlib.metadata.version(__name__)
 
 from sage_acsv.asymptotics import *
-from sage_acsv.kronecker import *
+from sage_acsv.kronecker import kronecker_representation
 from sage_acsv.helpers import get_expansion_terms
 from sage_acsv.settings import ACSVSettings
diff --git a/sage_acsv/asymptotics.py b/sage_acsv/asymptotics.py
@@ -116,20 +116,23 @@
 
 from copy import copy
 
-from sage.all import AA, PolynomialRing, QQ, QQbar, SR, DifferentialWeylAlgebra, Ideal
-from sage.all import (
-    gcd,
-    prod,
-    pi,
-    matrix,
-    exp,
-    log,
-    I,
-    factorial,
-    srange,
-    shuffle,
-    vector,
-)
+from sage.algebras.weyl_algebra import DifferentialWeylAlgebra
+from sage.arith.misc import gcd
+from sage.arith.srange import srange
+from sage.functions.log import log, exp
+from sage.functions.other import factorial
+from sage.matrix.constructor import matrix
+from sage.misc.misc_c import prod
+from sage.misc.prandom import shuffle
+from sage.modules.free_module_element import vector
+from sage.rings.asymptotic.asymptotic_ring import AsymptoticRing
+from sage.rings.ideal import Ideal
+from sage.rings.imaginary_unit import I
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+from sage.rings.qqbar import AA, QQbar
+from sage.rings.rational_field import QQ
+from sage.symbolic.constants import pi
+from sage.symbolic.ring import SR
 
 from sage_acsv.kronecker import _kronecker_representation
 from sage_acsv.helpers import (
@@ -144,7 +147,7 @@
 from sage_acsv.debug import Timer, acsv_logger
 from sage_acsv.settings import ACSVSettings
 from sage_acsv.whitney import whitney_stratification
-from sage_acsv.macaulay2 import compute_primary_decomposition, compute_saturation
+from sage_acsv.groebner import compute_primary_decomposition, compute_saturation
 
 
 # we need to monkeypatch a function from the asymptotics module such that creating
@@ -337,8 +340,6 @@ def _diagonal_asymptotics_combinatorial_smooth(
             result = sum([a**n * b * c * d for (a, b, c, d) in result])
 
     elif output_format == ACSVSettings.Output.ASYMPTOTIC:
-        from sage.all import AsymptoticRing
-
         AR = AsymptoticRing("QQbar^n * n^QQ", QQbar)
         n = AR.gen()
         result = sum(
@@ -653,7 +654,8 @@ def diagonal_asymptotics_combinatorial(
     vs_copy, r_copy = copy(vs), copy(r)
     for cp in min_crit_pts:
         vs, r = copy(vs_copy), copy(r_copy)
-        # Step 1: Determine if pt is a transverse multiple point of H, and compute the factorization
+        # Step 1: Determine if pt is a transverse multiple point of H,
+        # and compute the factorization
         # for now, we'll just try to factor it in the polynomial ring
         R = PolynomialRing(QQbar, len(vs), vs)
         G = R(SR(G))
@@ -683,8 +685,10 @@ def diagonal_asymptotics_combinatorial(
             )
 
         # Step 2: Find the locally parametrizing coordinates of the point pt
-        # Since we have d variables and s factors, there should be d-s of these parametrizing coordinates
-        # We will try to parametrize with the first d-s coordinates, shuffling the vs and r if it doesn't work
+        # Since we have d variables and s factors, there should be d-s of these
+        # parametrizing coordinates
+        # We will try to parametrize with the first d-s coordinates, shuffling
+        # the vs and r if it doesn't work
         for _ in range(s**2):
             Jac = matrix(
                 [
@@ -717,7 +721,8 @@ def diagonal_asymptotics_combinatorial(
             x ** (multiplicities[i] - 1)
             for i, x in enumerate(list(vector(r) * Gamma.inverse())[:s])
         )
-        # If cp lies on a single smooth component, we can compute asymptotics like in the smooth case
+        # If cp lies on a single smooth component, we can compute asymptotics
+        # like in the smooth case
         if s == 1 and sum(multiplicities) == 1:
             n = SR.var("n")
             expansion = sum(
@@ -785,8 +790,6 @@ def diagonal_asymptotics_combinatorial(
             result = sum([a**n * b * c * d for (a, b, c, d) in result])
 
     elif output_format == ACSVSettings.Output.ASYMPTOTIC:
-        from sage.all import AsymptoticRing
-
         AR = AsymptoticRing("QQbar^n * n^QQ", QQbar)
         n = AR.gen()
         result = sum(
diff --git a/sage_acsv/backends/__init__.py b/sage_acsv/backends/__init__.py
diff --git a/sage_acsv/backends/default.py b/sage_acsv/backends/default.py
@@ -0,0 +1,29 @@
+"""Default implementations of Groebner basis computations
+using SageMath."""
+
+def compute_primary_decomposition(ideal):
+    """Return the primary decomposition of an ideal.
+
+    INPUT:
+
+    * ``ideal`` - A polynomial ideal
+    """
+    return ideal.primary_decomposition()
+
+def compute_groebner_basis(ideal):
+    """Return a Groebner basis of an ideal.
+
+    INPUT:
+
+    * ``ideal`` - A polynomial ideal
+    """
+    return ideal.groebner_basis()
+
+def compute_radical(ideal):
+    """Return the radical of an ideal.
+
+    INPUT:
+
+    * ``ideal`` - A polynomial ideal
+    """
+    return ideal.radical()
diff --git a/sage_acsv/backends/macaulay2.py b/sage_acsv/backends/macaulay2.py
@@ -0,0 +1,59 @@
+"""Interface to macaulay2."""
+
+from sage.categories.homset import Hom
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+from sage.rings.rational_field import QQ
+
+from sage_acsv.settings import ACSVSettings
+
+
+def _construct_m2_morphims(ideal):
+    R = ideal.gens()[0].parent()
+    n = len(R.gens())
+    RM2 = PolynomialRing(QQ, n, [f"x{i}" for i in range(n)])
+    vs = list(RM2.gens())
+    mor = Hom(R, RM2)(vs)
+    inv = mor.inverse()
+    return mor, inv
+
+
+def compute_primary_decomposition(ideal):
+    """Return the primary decomposition of an ideal, computed via
+    Macaulay2.
+
+    INPUT:
+
+    * ``ideal`` - A polynomial ideal
+    """
+    mor, inv = _construct_m2_morphims(ideal)
+    ideal = ideal.apply_morphism(mor)
+    m2 = ACSVSettings.get_macaulay2()
+    return iter(J.sage().apply_morphism(inv) for J in m2.decompose(ideal))
+
+
+def compute_groebner_basis(ideal):
+    """Return a Groebner basis of an ideal, computed via Macaulay2.
+
+    INPUT:
+
+    * ``ideal`` - A polynomial ideal
+    """
+    mor, inv = _construct_m2_morphims(ideal)
+    ideal = ideal.apply_morphism(mor)
+    m2 = ACSVSettings.get_macaulay2()
+    # This is really roundabout but for some reason returning the generators
+    # from M2 to sage puts them in the wrong ring
+    return m2.ideal(m2.gb(ideal).generators()).sage().apply_morphism(inv).gens()
+
+
+def compute_radical(ideal):
+    """Return the radical of an ideal, computed via Macaulay2.
+
+    INPUT:
+
+    * ``ideal`` - A polynomial ideal
+    """
+    mor, inv = _construct_m2_morphims(ideal)
+    ideal = ideal.apply_morphism(mor)
+    m2 = ACSVSettings.get_macaulay2()
+    return m2.radical(ideal).sage().apply_morphism(inv)
diff --git a/sage_acsv/backends/msolve.py b/sage_acsv/backends/msolve.py
@@ -1,3 +1,5 @@
+"""Interface to msolve."""
+
 import os
 import tempfile
 import subprocess
diff --git a/sage_acsv/debug.py b/sage_acsv/debug.py
@@ -1,3 +1,5 @@
+"""Utilities for logging and debugging."""
+
 import time
 import logging
 
diff --git a/sage_acsv/groebner.py b/sage_acsv/groebner.py
@@ -0,0 +1,79 @@
+"""Central interface for accessing and using different backends
+for Groebner basis computations.
+
+Depending on the chosen backend for Groebner basis computations
+(via :meth:`.ACSVSettings.set_default_groebner_backend`, allowed
+values are given in :class:`.ACSVSettings.Groebner`) the members
+of this module delegate their computations to the available
+computational backends:
+
+- :mod:`.backends.default`
+- :mod:`.backends.macaulay2`
+"""
+
+
+import sage_acsv.backends.default as default_backend
+import sage_acsv.backends.macaulay2 as macaulay2_backend
+from sage_acsv.settings import ACSVSettings
+
+
+def compute_primary_decomposition(ideal):
+    """Return the primary decomposition of an ideal.
+
+    Delegates the computation to the backend set in
+    :class:`.ACSVSettings`.
+
+    INPUT:
+
+    * ``ideal`` - A polynomial ideal
+    """
+    match ACSVSettings.get_default_groebner_backend():
+        case ACSVSettings.Groebner.MACAULAY2:
+            return macaulay2_backend.compute_primary_decomposition(ideal)
+        case _:
+            return default_backend.compute_primary_decomposition(ideal)
+
+
+def compute_saturation(ideal_I, ideal_J):
+    """Return the saturation of ideal I with respect to ideal J.
+
+    INPUT:
+
+    * ``ideal_I`` - A polynomial ideal
+    * ``ideal_J`` - A polynomial ideal
+    """
+    return ideal_I.saturation(ideal_J)[0]
+
+
+def compute_groebner_basis(ideal):
+    """Return a Groebner basis of an ideal.
+
+    Delegates the computation to the backend set in
+    :class:`.ACSVSettings`.
+
+    INPUT:
+
+    * ``ideal`` - A polynomial ideal
+    """
+    match ACSVSettings.get_default_groebner_backend():
+        case ACSVSettings.Groebner.MACAULAY2:
+            return macaulay2_backend.compute_groebner_basis(ideal)
+        case _:
+            return default_backend.compute_groebner_basis(ideal)
+
+
+def compute_radical(ideal):
+    """Return the radical of an ideal.
+
+    Delegates the computation to the backend set in
+    :class:`.ACSVSettings`.
+
+    INPUT:
+
+    * ``ideal`` - A polynomial ideal
+    """
+    match ACSVSettings.get_default_groebner_backend():
+        case ACSVSettings.Groebner.MACAULAY2:
+            return macaulay2_backend.compute_radical(ideal)
+        case _:
+            return default_backend.compute_radical(ideal)
diff --git a/sage_acsv/helpers.py b/sage_acsv/helpers.py
diff --git a/sage_acsv/kronecker.py b/sage_acsv/kronecker.py
diff --git a/sage_acsv/macaulay2.py b/sage_acsv/macaulay2.py
diff --git a/sage_acsv/settings.py b/sage_acsv/settings.py
diff --git a/sage_acsv/whitney.py b/sage_acsv/whitney.py
