passagemath-brial 10.6.31rc3__cp314-cp314-macosx_13_0_x86_64.whl

sage/libs/polybori/pb_wrap.h

@@ -0,0 +1,133 @@
+/* sage_setup: distribution = sagemath-brial
+ */
+#include <polybori/BoolePolynomial.h>
+#include <polybori/BoolePolyRing.h>
+#include <polybori/factories/VariableBlock.h>
+#include <polybori/factories/VariableFactory.h>
+#include <polybori/groebner/add_up.h>
+#include <polybori/groebner/contained_variables.h>
+#include <polybori/groebner/FGLMStrategy.h>
+#include <polybori/groebner/groebner_alg.h>
+#include <polybori/groebner/interpolate.h>
+#include <polybori/groebner/linear_algebra_step.h>
+#include <polybori/groebner/LiteralFactorization.h>
+#include <polybori/groebner/ll_red_nf.h>
+#include <polybori/groebner/nf.h>
+#include <polybori/groebner/red_tail.h>
+#include <polybori/groebner/minimal_elements.h>
+#include <polybori/groebner/randomset.h>
+#include <polybori.h>
+#include <polybori/iterators/COrderedIter.h>
+#include <polybori/orderings/pbori_order.h>
+#include <polybori/pbori_defs.h>
+
+#include <sstream>
+#include <vector>
+
+USING_NAMESPACE_PBORI
+USING_NAMESPACE_PBORIGB
+
+
+static int pairs_top_sugar(const GroebnerStrategy& strat){
+    if (strat.pairs.pairSetEmpty())
+        return -1;
+    else
+        return (strat.pairs.queue.top().sugar);
+}
+
+static std::vector<BoolePolynomial> someNextDegreeSpolys(GroebnerStrategy& strat, size_t n){
+    std::vector<BoolePolynomial> res;
+    assert(!(strat.pairs.pairSetEmpty()));
+    strat.pairs.cleanTopByChainCriterion();
+    deg_type deg=strat.pairs.queue.top().sugar;
+
+    while((!(strat.pairs.pairSetEmpty())) && \
+                (strat.pairs.queue.top().sugar<=deg) && (res.size()<n)){
+        assert(strat.pairs.queue.top().sugar==deg);
+        res.push_back(strat.nextSpoly());
+        strat.pairs.cleanTopByChainCriterion();
+    }
+    return res;
+}
+
+static std::vector<Polynomial> nextDegreeSpolys(GroebnerStrategy& strat){
+    std::vector<Polynomial> res;
+    assert(!(strat.pairs.pairSetEmpty()));
+    strat.pairs.cleanTopByChainCriterion();
+    deg_type deg=strat.pairs.queue.top().sugar;
+
+    while((!(strat.pairs.pairSetEmpty())) &&
+            (strat.pairs.queue.top().sugar<=deg)){
+
+        assert(strat.pairs.queue.top().sugar==deg);
+        res.push_back(strat.nextSpoly());
+        strat.pairs.cleanTopByChainCriterion();
+    }
+    return res;
+}
+
+static std::vector<Polynomial> small_next_degree_spolys(GroebnerStrategy& strat,
+        double f, size_t n){
+    std::vector<Polynomial> res;
+    assert(!(strat.pairs.pairSetEmpty()));
+    strat.pairs.cleanTopByChainCriterion();
+    deg_type deg=strat.pairs.queue.top().sugar;
+    wlen_type wlen=strat.pairs.queue.top().wlen;
+    while((!(strat.pairs.pairSetEmpty())) &&
+            (strat.pairs.queue.top().sugar<=deg) &&
+            (strat.pairs.queue.top().wlen<=wlen*f+2)&& (res.size()<n)){
+
+        assert(strat.pairs.queue.top().sugar==deg);
+        res.push_back(strat.nextSpoly());
+        strat.pairs.cleanTopByChainCriterion();
+    }
+    return res;
+}
+
+
+class ring_singleton{
+ public:
+  static BoolePolyRing instance() {
+    static BoolePolyRing ring(1);
+    return ring;
+  }
+};
+
+
+
+template <class ValueType>
+class DefaultRinged:
+  public ValueType {
+  typedef DefaultRinged self;
+
+ public:
+  typedef ValueType value_type;
+  typedef value_type base;
+
+  // Default constructor allocated memory
+  DefaultRinged();
+
+  DefaultRinged(const value_type& rhs): base(rhs) {}
+
+  DefaultRinged(const self& rhs): base(rhs) {}
+
+  ~DefaultRinged() { }
+
+  self& operator=(const self& rhs) {
+    return operator=(static_cast<const value_type&>(rhs));
+  }
+
+  self& operator=(const value_type& rhs) {
+    base::operator=(rhs);
+    return *this;
+  }
+};
+
+template <class ValueType>
+DefaultRinged<ValueType>::DefaultRinged():
+  base(ring_singleton::instance()) { }
+
+template <>
+DefaultRinged<FGLMStrategy>::DefaultRinged():
+base(ring_singleton::instance(), ring_singleton::instance(),
+     PolynomialVector()) { }

sage/rings/all__sagemath_brial.py

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

sage/rings/polynomial/all__sagemath_brial.py

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

sage/rings/polynomial/pbori/PyPolyBoRi.py

@@ -0,0 +1,123 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+r"""
+PolyBoRi's interface to libpolybori/BRiAL
+
+This file makes interfaces to PolyBoRi's runtime libraries available in Python via sage.
+
+
+AUTHOR:
+
+- The PolyBoRi Team, 2007-2012
+
+    EXAMPLES::
+
+        sage: from sage.rings.polynomial.pbori.pbori import *
+        sage: from sage.rings.polynomial.pbori.blocks import declare_ring
+        sage: r=declare_ring(["x0","x1","x2","y0","y1","y2"], globals())
+        sage: x0>x1
+        True
+        sage: x0>x1*x2
+        True
+        sage: y0>y1
+        True
+        sage: y0>y1*y2
+        True
+
+        sage: r = r.clone(ordering=dlex)
+        sage: r(x0) > r(x1)
+        True
+        sage: r(x0) > r(x1*x2)
+        False
+
+        sage: r = r.clone(ordering=dp_asc)
+        sage: r(x0) > r(x1)
+        False
+        sage: r(x0) > r(x1*x2)
+        False
+
+        sage: r = r.clone(ordering=block_dlex, blocks=[3])
+        sage: r(x0) > r(x1)
+        True
+        sage: r(x0) > r(x1*x2)
+        False
+        sage: r(x0) > r(y0*y1*y2)
+        True
+
+        sage: r = r.clone(ordering=block_dp_asc)
+        sage: r(x0) > r(x1)
+        False
+        sage: r(x0) > r(y0)
+        False
+        sage: r(x0) > r(x1*x2)
+        False
+
+        sage: r = r.clone(ordering=block_dp_asc, blocks=[3])
+        sage: r(x0) > r(y0)
+        True
+
+        sage: r(x0) > r(y0*y1)
+        True
+
+        sage: r = r.clone(names=["z17", "z7"])
+        sage: [r.variable(idx) for idx in range(3)]
+        [z17, z7, x2]
+        sage: r = r.clone(names='abcde')
+        sage: [r.variable(idx) for idx in range(6)]
+        [a, b, c, d, e, y2]
+"""
+
+from .pbori import (order_dict, TermOrder_from_pb_order, BooleanPolynomialRing,
+                    BooleanPolynomialVector, MonomialFactory,
+                    PolynomialFactory, VariableFactory, add_up_polynomials)
+from .pbori import gauss_on_polys as _gauss_on_polys
+
+import weakref
+
+
+OrderCode = type('OrderCode', (object,), order_dict)
+
+
+def Ring(n, order='lp', names=None, blocks=None):
+    if blocks is None:
+        blocks = []
+    pbnames = names
+    if pbnames is None:
+        pbnames = ['x(' + str(idx) + ')' for idx in range(n)]
+    order = TermOrder_from_pb_order(n, order, blocks)
+    return BooleanPolynomialRing(n, names=pbnames, order=order)
+
+
+BoolePolynomialVector = BooleanPolynomialVector
+
+
+# todo: PolyBoRi's original interface uses its WeakRingPtr here
+def WeakRingRef(ring):
+    return weakref.weakref(ring)
+
+
+Monomial = MonomialFactory()
+Polynomial = PolynomialFactory()
+Variable = VariableFactory()
+
+
+_add_up_polynomials = add_up_polynomials
+
+
+def add_up_polynomials(polys, init):
+    r"""
+    Add up the polynomials in polys (which should be a
+    ``BoolePolynomialVector`` or a sequence of ???
+    """
+    if not isinstance(polys, BoolePolynomialVector):
+        vec = BoolePolynomialVector
+        for p in polys:
+            vec.append(p)
+        polys = vec
+
+    return _add_up_polynomials(polys, init)
+
+
+def gauss_on_polys(l):
+    vec = BoolePolynomialVector(l)
+    return list(_gauss_on_polys(vec))

sage/rings/polynomial/pbori/__init__.py

@@ -0,0 +1,44 @@
+# sage_setup: distribution = sagemath-brial
+"""The PolyBoRi package implements a framework for computations with Polynomials in Boolean Ring.
+
+The core of PolyBoRi is a C++ library, which provides high-level data types for Boolean polynomials and monomials,
+exponent vectors, as well as for the underlying polynomial rings and subsets of the powerset of the Boolean variables.
+The description of the latter can be found in the description of the 'dynamic' submodule, as well as in the doxygen-based documentation.
+
+As a unique approach, binary decision diagrams are used as internal storage type for polynomial structures.
+On top of this C++-library we provide a Python interface. This allows parsing of complex polynomial systems,
+as well as sophisticated and extendable strategies for Groebner base computation.
+PolyBoRi features a powerful reference implementation for Groebner basis computation.
+
+AUTHOR:
+
+The PolyBoRi Team, 2007-2011
+
+REFERENCES:
+
+M. Brickenstein, A. Dreyer, G. Greuel, M. Wedler, O. Wienand,
+*New developments in the theory of Groebner bases and applications
+to formal Verification*,  Preprint at :arxiv:`0801.1177`
+
+M. Brickenstein, A. Dreyer, PolyBoRi:
+*A Groebner Basis Framework for Boolean Polynomials*,
+Reports of Fraunhofer ITWM, No. 122, Kaiserslautern, Germany, 2007.
+http://www.itwm.fraunhofer.de/zentral/download/berichte/bericht122.pdf
+
+M. Brickenstein, A. Dreyer, PolyBoRi:
+*A framework for Groebner basis computations with Boolean polynomials*,
+Electronic Proceedings of the MEGA 2007 - Effective Methods in Algebraic Geometry, Strobl, Austria, June 2007.
+http://www.ricam.oeaw.ac.at/mega2007/electronic/electronic.html
+"""
+from sage.misc.lazy_import import lazy_import
+from .PyPolyBoRi import Ring, Polynomial, Monomial, Variable
+
+# Get all-inclusive groebner routine
+from .gbcore import groebner_basis
+from .nf import normal_form
+
+# Import some high-level modelling functionality
+from .blocks import declare_ring
+from .blocks import HigherOrderBlock, AlternatingBlock, Block
+from .gbrefs import load_file
+from .specialsets import all_monomials_of_degree_d, power_set