passagemath-brial 10.6.38__cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

sage/rings/polynomial/pbori/easy_polynomials.py

@@ -0,0 +1,56 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from .interpolate import variety_lex_leading_terms, nf_lex_points
+from .pbori import easy_linear_factors
+
+
+def easy_linear_polynomials(p):
+    r"""
+    Get linear polynomials implied by given polynomial.
+
+    EXAMPLES::
+
+        sage: from sage.rings.polynomial.pbori.frontend import x
+        sage: from sage.rings.polynomial.pbori.easy_polynomials import easy_linear_polynomials
+        sage: easy_linear_polynomials(x(1)*x(2) + 1)
+        [x(1) + 1, x(2) + 1]
+        sage: easy_linear_polynomials(x(1)*x(2) + 0)
+        []
+        sage: easy_linear_polynomials(x(0)*x(1) + x(0)*x(2) + 1)
+        [x(0) + 1, x(1) + x(2) + 1]
+    """
+    res = []
+    if p.deg() >= 2:
+        if p.vars_as_monomial().deg() > 8:
+            res.extend(q + 1 for q in easy_linear_factors(p + 1))
+        else:
+            res = easy_linear_polynomials_via_interpolation(p)
+    return res
+
+
+def easy_linear_polynomials_via_interpolation(p):
+    r"""
+    Get linear polynomials implied by given polynomial using interpolation of the variety.
+
+    TESTS::
+
+        sage: from sage.rings.polynomial.pbori.frontend import x
+        sage: from sage.rings.polynomial.pbori.easy_polynomials import easy_linear_polynomials_via_interpolation
+        sage: easy_linear_polynomials_via_interpolation(x(1)*x(2) + 1)
+        [x(1) + 1, x(2) + 1]
+        sage: easy_linear_polynomials_via_interpolation(x(1)*x(2) + 0)
+        []
+        sage: easy_linear_polynomials_via_interpolation(x(0)*x(1) + x(0)*x(2) + 1)
+        [x(0) + 1, x(1) + x(2) + 1]
+    """
+    res = []
+    p_vars = p.vars_as_monomial()
+    space = p_vars.divisors()
+    zeros = p.zeros_in(space)
+    lex_leads = variety_lex_leading_terms(zeros, p_vars)
+    for m in lex_leads:
+        if m.deg() == 1:
+            red = m + nf_lex_points(m, zeros)
+            if red.lead_deg() == 1:  # normal ordering
+                res.append(red)
+    return res

sage/rings/polynomial/pbori/fglm.py

@@ -0,0 +1,93 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from .pbori import BooleSet, FGLMStrategy
+from .PyPolyBoRi import BoolePolynomialVector, Polynomial
+
+
+def _fglm(I, from_ring, to_ring):
+    r"""
+    Unchecked variant of fglm
+    """
+    vec = BoolePolynomialVector(I)
+    return FGLMStrategy(from_ring, to_ring, vec).main()
+
+
+def fglm(I, from_ring, to_ring):
+    r"""
+    Convert *reduced* Groebner Basis in ``from_ring`` to a GroebnerBasis
+    in ``to_ring``.
+
+    It acts independent of the global ring, which is restored at the end of the
+    computation.
+
+    TESTS::
+
+        sage: from sage.rings.polynomial.pbori import *
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import OrderCode
+        sage: dp_asc = OrderCode.dp_asc
+        sage: r=declare_ring(['x','y','z'],dict())
+        sage: old_ring = r
+        sage: new_ring = old_ring.clone(ordering=dp_asc)
+        sage: (x,y,z) = [old_ring.variable(i) for i in range(3)]
+        sage: ideal=[x+z, y+z]# lp Groebner basis
+        sage: from sage.rings.polynomial.pbori.fglm import fglm
+        sage: list(fglm(ideal, old_ring, new_ring))
+        [y + x, z + x]
+    """
+    for poly in I:
+        if poly.ring().id() != from_ring.id():
+            raise ValueError("Ideal I must be from the first ring argument")
+    return _fglm(I, from_ring, to_ring)
+
+
+def vars_real_divisors(monomial, monomial_set):
+    r"""
+    Return all elements of ``monomial_set``, which result multiplied by a variable in monomial.
+
+    EXAMPLES::
+
+        sage: from sage.rings.polynomial.pbori.pbori import *
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import OrderCode
+        sage: dp_asc = OrderCode.dp_asc
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import Ring
+        sage: r = Ring(1000)
+        sage: x = r.variable
+        sage: b = BooleSet([x(1)*x(2),x(2)])
+        sage: from sage.rings.polynomial.pbori.fglm import vars_real_divisors
+        sage: vars_real_divisors(x(1)*x(2)*x(3),b)
+        {{x(1),x(2)}}
+    """
+    return BooleSet(Polynomial(monomial_set.divisors_of(monomial)).
+                    graded_part(monomial.deg() - 1))
+
+
+def m_k_plus_one(completed_elements, variables):
+    r"""
+    Calculate `m_{k+1}` from the FGLM algorithm.
+
+    Calculate `m_{k+1}` from the FGLM algorithm as described in Wichmann [Wich1997]_.
+
+    .. NOTE::
+
+        It would be nice to be able to efficiently extract the smallest term of a polynomial.
+
+    EXAMPLES::
+
+        sage: from sage.rings.polynomial.pbori.pbori import *
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import OrderCode
+        sage: from sage.rings.polynomial.pbori.fglm import m_k_plus_one
+        sage: dp_asc = OrderCode.dp_asc
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import Ring
+        sage: r = Ring(1000)
+        sage: x = r.variable
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import Monomial
+        sage: s = BooleSet([x(1)*x(2),x(1),x(2),Monomial(r),x(3)])
+        sage: variables = BooleSet([x(1),x(2),x(3)])
+        sage: m_k_plus_one(s,variables)
+        x(2)*x(3)
+        sage: r2 = r.clone(ordering=dp_asc)
+        sage: m_k_plus_one(r2(s).set(),r2(variables).set())
+        x(1)*x(3)
+    """
+    return sorted(completed_elements.cartesian_product(variables).diff(
+        completed_elements))[0]

sage/rings/polynomial/pbori/frontend.py

@@ -0,0 +1,70 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+# Import basic functionality
+r"""
+This module defines an initial ring, and patches the declare_ring to use
+a given context.
+
+EXAMPLES::
+
+    sage: from sage.rings.polynomial.pbori.frontend import x
+    sage: x(0)
+    x(0)
+    sage: x(0)*x(0)
+    x(0)
+    sage: x(0) + x(0)
+    0
+    sage: x(9999)
+    x(9999)
+    sage: x(9999)*x(9999)
+    x(9999)
+    sage: x(9999) + x(9999)
+    0
+
+    sage: from sage.rings.polynomial.pbori.frontend import x, polybori_start
+    sage: context = dict(globals())
+    sage: polybori_start(context)
+    ipbori...
+    sage: r = context['declare_ring']('abc')
+    sage: context['a']
+    a
+    sage: r.variable(0)
+    a
+"""
+
+
+from .PyPolyBoRi import Ring
+from .pbori import VariableFactory
+from .blocks import declare_ring as orig_declare_ring
+
+
+def block_scheme_names(blocks):
+    r"""
+    Helper for Singular interface.
+    """
+    context = {}
+    from .blocks import declare_block_scheme
+    declare_block_scheme(blocks, context)
+
+    return list(context.keys())
+
+
+ipbname = 'ipbori'
+
+
+def polybori_start(global_context):
+    def declare_ring(blocks, context=None):
+        if context is None:
+            context = global_context
+
+        return orig_declare_ring(blocks, context)
+    declare_ring.__doc__ = orig_declare_ring.__doc__
+    global_context["declare_ring"] = declare_ring
+
+    print(ipbname + """ -- The interactive command line tool of PolyBoRi/BRiAL %s
+""" % global_context.get("polybori_version", ''))
+
+
+# Here come the defaults
+r = Ring(10000)
+x = VariableFactory(r)