passagemath-brial 10.8.1a3__cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

passagemath_brial/__init__.py

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

passagemath_brial-10.8.1a3.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: passagemath-brial
+Version: 10.8.1a3
+Summary: passagemath: Boolean Ring Algebra with BRiAl
+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.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.11
+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.8.1.alpha3
+Provides-Extra: test
+Requires-Dist: passagemath-modules; extra == "test"
+Requires-Dist: passagemath-ntl; extra == "test"
+Requires-Dist: passagemath-flint; extra == "test"
+Requires-Dist: passagemath-pari; extra == "test"
+Requires-Dist: passagemath-repl; extra == "test"
+Requires-Dist: passagemath-singular; extra == "test"
+
+=========================================================================
+ passagemath: Boolean Ring Algebra with BRiAl
+=========================================================================
+
+`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 source distribution ``passagemath-brial`` provides
+a Boolean Ring Algebra implementation using binary decision diagrams,
+implemented by the BRiAl library, the successor to PolyBoRi.

passagemath_brial-10.8.1a3.dist-info/RECORD

@@ -0,0 +1,39 @@
+passagemath_brial/__init__.py,sha256=u3JOuHEFYqH_QD2APr5v33fbb-mXCTSzBtw6MCCcXNk,84
+passagemath_brial.libs/libbrial-a2b87c7c.so.3.0.7,sha256=dR90BHFyenROH3GdAl16vLmvDS9S-QlLqMPWHH_6Wq8,10503625
+passagemath_brial.libs/libbrial_groebner-607bf574.so.3.0.7,sha256=6zZRQHhvu7qpVhn0HkuB-1b-eg-jCn_6nj8j331EwsY,20569865
+passagemath_brial.libs/libgmp-93ebf16a.so.10.5.0,sha256=J_oguU4vvekVCVuY5w0xJjRsPinQWaZ9HqUVq6yFhas,668537
+passagemath_brial.libs/libm4ri-4311ab86.so.2.0.1,sha256=NVtbhZ90ROh4EgO7JNNZ4lvyWNYRqMFTb2C-xh96UCA,1250769
+passagemath_brial.libs/libpng16-5d944a30.so.16.54.0,sha256=T9ZCvVAtYrPiFypaCeFuqlMkODCSXnyKoWWf7OCnEag,1384689
+sage/all__sagemath_brial.py,sha256=3pdx_TyESRdnfj0a-BFotJd7IohjzFSV7y0adPc8jdc,181
+sage/libs/all__sagemath_brial.py,sha256=5q-Ygp3aEBaIBwJqkUylkJoxtuov5smlTEUM5Rv_U7w,44
+sage/libs/polybori/__init__.pxd,sha256=aFtUBJSK6uu2h1fqD5xOraYKZHzYQK--ellmPEkdDBA,96
+sage/libs/polybori/decl.pxd,sha256=MmjQbEcG-TKiG2lE6nbsnLJMqxvqVYyDYHQiz_0EqVc,13068
+sage/libs/polybori/pb_wrap.h,sha256=_ANpLeG1ZUzoL88LzrLXaZYY84jWeRA8LU19HGOJsZ8,3814
+sage/rings/all__sagemath_brial.py,sha256=5q-Ygp3aEBaIBwJqkUylkJoxtuov5smlTEUM5Rv_U7w,44
+sage/rings/polynomial/all__sagemath_brial.py,sha256=5q-Ygp3aEBaIBwJqkUylkJoxtuov5smlTEUM5Rv_U7w,44
+sage/rings/polynomial/pbori/PyPolyBoRi.py,sha256=PL_frkfT7NhJNmEldWIz2084Ce5Ql31L54UKG8yutW8,3357
+sage/rings/polynomial/pbori/__init__.py,sha256=oa0vKWiihNIbKPAYPlHbzSMeDOiouHsEhzhdvPzQpOM,2108
+sage/rings/polynomial/pbori/blocks.py,sha256=Vp3LkNUNQpw7fPfcO7F9OnGunmB_hrDYLZ_VADxKCLk,15569
+sage/rings/polynomial/pbori/cnf.py,sha256=nKjNGdenHwwDGzDh9aW1JizQflQ75LqU_P9wOPt3Dqw,9156
+sage/rings/polynomial/pbori/easy_polynomials.py,sha256=YA1D86INvZ5bueUANLO5XPNq1yHIZRwasGteoyTVEe4,2046
+sage/rings/polynomial/pbori/fglm.py,sha256=047RrCKXeiC8s3LbD6DRKgdatWKAX78Egqzb6vc6F_s,3414
+sage/rings/polynomial/pbori/frontend.py,sha256=bZQHO9Q73VHhAjNX_dz_Ms4J_-VkYWPC9-PcNPCHxvY,1690
+sage/rings/polynomial/pbori/gbcore.py,sha256=T7kuQWUUuEkzXcTeteMIvqEUBiI5WjJBUIwrcQwIS6k,21028
+sage/rings/polynomial/pbori/gbrefs.py,sha256=MOtP2YtcRBIO3kjuYyvtpPUvNi0A5A52JbetyvcB20w,3393
+sage/rings/polynomial/pbori/heuristics.py,sha256=4jf56TdHw-YIPfkUjIaWffWQ1SfVe04n3URIC7ycWak,871
+sage/rings/polynomial/pbori/interpolate.py,sha256=x4_h-lMs04kZbGW5W5xETKC08XN3uArfpqeLVGKipYo,3958
+sage/rings/polynomial/pbori/interred.py,sha256=zSqSo4S9qojVl3NrEwTR913s4_pwNInWOY8FxOwerrc,1005
+sage/rings/polynomial/pbori/ll.py,sha256=ophQ0epXYR2SPLdq2fDwyt12B2pzdMqg8T0mx4Wrxnk,10598
+sage/rings/polynomial/pbori/nf.py,sha256=4lj82HQiGC5eqdxYZY6hvJ6-n4wISFwhhB1tkat1hv4,22374
+sage/rings/polynomial/pbori/parallel.py,sha256=igbW4G2JpqQbbxosLdOYCBNjDbKZgu2JtAWZx7v8nyo,8850
+sage/rings/polynomial/pbori/pbori.cpython-314-aarch64-linux-gnu.so,sha256=OFCuSU2f0JRqaRxoMLm02gCetBVTRzrJEKmQ6_Pv6VE,14392641
+sage/rings/polynomial/pbori/pbori.pxd,sha256=zN8LPgF_gE30SN4Vrs-BRsj9U2MEAkVyWG3Dd0yhd0c,3845
+sage/rings/polynomial/pbori/pbori.pyx,sha256=Ly2AAJYYN1czQHSsILBgi_ftDvqnn3m4sgKV2Re-178,249433
+sage/rings/polynomial/pbori/randompoly.py,sha256=P1TXjOi4fQThHtWZs3AIwZqoE-lnb-zP4xJh-KMkg9c,4298
+sage/rings/polynomial/pbori/rank.py,sha256=k8r_T2okbuZpgdNRi-H5rxIaA5cMyzHipXo8Cyq0FBU,699
+sage/rings/polynomial/pbori/specialsets.py,sha256=kS4sii6FLxaLRkVAUPi9yjM2c33h7Hn_y_Y6s8Ti1ro,3692
+sage/rings/polynomial/pbori/statistics.py,sha256=1XbDXlIevARUfjmRO17UKg60p7t0d-lRDdVfAGPTcQA,867
+passagemath_brial-10.8.1a3.dist-info/METADATA,sha256=wf4WuZOQ01CUKkbCAx4Wb8L7nE3DX3-1VOKunPNX1tE,4612
+passagemath_brial-10.8.1a3.dist-info/WHEEL,sha256=0pvOHbmfRgKx5XLW_GLLcBRMiVWAGGbU5VJH4qo_KVg,155
+passagemath_brial-10.8.1a3.dist-info/top_level.txt,sha256=IaysPN4SFFFJLfRhdy8REPwed_xkmY6Qtx0N0YEoDyk,24
+passagemath_brial-10.8.1a3.dist-info/RECORD,,

passagemath_brial-10.8.1a3.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: false
+Tag: cp314-cp314-manylinux_2_24_aarch64
+Tag: cp314-cp314-manylinux_2_28_aarch64
+

passagemath_brial-10.8.1a3.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+
+passagemath_brial
+sage

sage/all__sagemath_brial.py

@@ -0,0 +1,9 @@
+# sage_setup: distribution = sagemath-brial
+# delvewheel: patch
+
+from .all__sagemath_categories import *
+
+try:
+    from .all__sagemath_modules import *
+except ImportError:
+    pass

sage/libs/all__sagemath_brial.py

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

sage/libs/polybori/__init__.pxd

@@ -0,0 +1,2 @@
+# sage_setup: distribution = sagemath-brial
+# Insert a comment here to prevent repo corruption.

sage/libs/polybori/decl.pxd

@@ -0,0 +1,401 @@
+# sage_setup: distribution = sagemath-brial
+# distutils: language = c++
+# distutils: extra_compile_args = -std=c++17
+
+from libcpp.string cimport string as std_string
+from libcpp.vector cimport vector
+
+
+cdef extern from "polybori/pbori_defs.h" namespace "COrderEnums":
+    cdef enum ordercodes:
+        pblp            "CTypes::lp"
+        pbdlex          "CTypes::dlex"
+        pbdp_asc        "CTypes::dp_asc"
+        pbblock_dlex    "CTypes::block_dlex"
+        pbblock_dp_asc  "CTypes::block_dp_asc"
+        pbdp            "static_cast<COrderEnums::ordercodes>(17)"
+        pbblock_dp      "static_cast<COrderEnums::ordercodes>(19)"
+
+    cdef enum comparecodes:
+        less_than               "CTypes::less_than"
+        equality                "CTypes::equality"
+        greater_than            "CTypes::greater_than"
+        less_or_equal_max       "CTypes::less_or_equal_max"
+        greater_or_equal_min    "CTypes::greater_or_equal_min"
+
+
+cdef extern from "pb_wrap.h":
+    cdef cppclass PBNavigator "CCuddNavigator":
+        PBNavigator thenBranch()
+        PBNavigator elseBranch()
+        int value "operator*"()
+        bint isConstant()
+        bint isTerminated()
+        bint operator==(const PBNavigator&)
+        size_t hash()
+
+    cdef cppclass PBBlockIter "COrderingBase::block_iterator":
+        long dereference "operator*"()
+        void increment "operator++"()
+        bint operator!=(const PBBlockIter&)
+
+    cdef cppclass PBOrdering "COrderingBase":
+        int getOrderCode()
+        int getBaseOrderCode()
+        void appendBlock(int nextBlockStartIndex)
+        PBBlockIter blockBegin()
+        PBBlockIter blockEnd()
+        int lastBlockStart()
+        bint isDegreeOrder()
+
+    cdef cppclass PBSet "DefaultRinged<BooleSet> "
+    cdef cppclass PBPoly "DefaultRinged<BoolePolynomial> "
+
+    cdef cppclass PBBooleVariable "BooleVariable":
+        PBBooleVariable(int idx, const PBRing& r)
+
+    cdef cppclass PBVar "DefaultRinged<BooleVariable> ":
+        void operator=(const PBBooleVariable&)
+        int index()
+        bint operator==(const PBVar&)
+
+    cdef cppclass PBRing "BoolePolyRing":
+        PBRing()
+        PBRing(int nvars, int order)
+        size_t id()
+        size_t nVariables()
+        PBVar variable(int n)
+        PBOrdering ordering()
+        void changeOrdering(int)
+        size_t hash()
+        void setVariableName(int idx, char *varname)
+        char* getVariableName(int idx)
+        PBRing clone()
+        PBPoly coerce(PBPoly rhs)
+        PBPoly zero()
+        PBPoly one()
+
+    cdef cppclass PBVarBlock "VariableBlock":
+        PBVarBlock(int size, int start_index, int offset, bint reverse,
+                   PBRing r)
+        PBVar operator()(int index)
+
+    cdef cppclass PBMonomIter "BooleMonomial::const_iterator":
+        int dereference()
+        void increment()
+        bint operator==(const PBMonomIter&)
+
+    cdef cppclass PBMonomVarIter "BooleMonomial::variable_iterator":
+        PBVar dereference()
+        void increment()
+        bint operator==(const PBMonomVarIter&)
+
+    cdef cppclass PBMonom "DefaultRinged<BooleMonomial> ":
+        PBMonom()
+        PBMonom(PBRing r)
+        PBMonom(PBVar m)
+        void operator=(const PBBooleSet&)
+        bint reducibleBy(PBMonom rhs)
+        int deg()
+        size_t hash()
+        size_t stableHash()
+        int firstIndex()
+        comparecodes compare(PBMonom rhs)
+        PBSet set()
+        PBSet divisors()
+        PBSet multiples(PBMonom rhs)
+        PBMonomIter begin()
+        PBMonomIter end()
+        PBMonomVarIter variableBegin()
+        PBMonomVarIter variableEnd()
+        void imul "operator*="(PBMonom right)
+        void idiv "operator/="(PBMonom right)
+        PBNavigator navigation()
+        PBMonom GCD(PBMonom rhs)
+        PBRing ring()
+
+    cdef cppclass PBSetIter "BooleSet::const_iterator":
+        PBSetIter(const PBSetIter&)
+        PBMonom dereference()
+        void increment()
+        bint operator==(const PBSetIter&)
+
+    cdef cppclass PBBooleSet "BooleSet":
+        PBBooleSet()
+        PBBooleSet(PBRing r)
+        PBBooleSet(PBPoly p)
+        PBBooleSet(PBNavigator d, PBRing r)
+        PBBooleSet(int ind, PBNavigator a, PBNavigator b, PBRing r)
+
+    cdef cppclass PBSet "DefaultRinged<BooleSet> ":
+        void operator=(const PBBooleSet&)
+        bint owns(PBMonom val)
+        int nNodes()
+        int nSupport()
+        int size()
+        size_t hash()
+        size_t stableHash()
+        PBNavigator navigation()
+        PBSet cartesianProduct(PBSet rhs)
+        PBSet diff(PBSet rhs)
+        PBSet divide(PBMonom rhs)
+        PBSet change(int idx)
+        PBSet subset0(int i)
+        PBSet subset1(int i)
+        PBSet unite(PBSet rhs)
+        PBSet intersect(PBSet rhs)
+        PBMonom usedVariables()
+        PBSet divisorsOf(PBMonom rhs)
+        PBSet multiplesOf(PBMonom rhs)
+        double sizeDouble()
+        PBSetIter begin()
+        PBSetIter end()
+        bint isZero()
+        bint isOne()
+
+    PBSet pb_include_divisors "include_divisors"(PBSet p)
+    PBSet pb_minimal_elements "minimal_elements"(PBSet p)
+
+    cdef cppclass PBPolyIter "BoolePolynomial::ordered_iterator":
+        PBPolyIter(const PBPolyIter&)
+        PBMonom dereference()
+        void increment()
+        bint operator==(const PBPolyIter&)
+
+    cdef cppclass PBBoolePolynomial "BoolePolynomial":
+        void operator=(const PBPoly&)
+        PBBoolePolynomial(PBRing r)
+        PBBoolePolynomial(PBSet d)
+        PBBoolePolynomial(PBMonom d)
+        PBBoolePolynomial(PBVar d)
+        PBBoolePolynomial(int d, PBRing r)
+
+    cdef cppclass PBPoly "DefaultRinged<BoolePolynomial> ":
+        PBPoly()
+        void operator=(const PBBoolePolynomial&)
+        int deg()
+        int leadDeg()
+        int lexLeadDeg()
+        int totalDeg()
+        int length()
+        int eliminationLength()
+        int nUsedVariables()
+        int nNodes()
+        size_t hash()
+        size_t stableHash()
+        bint isZero()
+        bint isOne()
+        bint isConstant()
+        bint isSingleton()
+        bint isPair()
+        bint isSingletonOrPair()
+        bint hasConstantPart()
+        bint firstReducibleBy(PBPoly rhs)
+        PBMonom lead()
+        PBMonom lexLead()
+        PBMonom firstTerm()
+        PBMonom usedVariables()
+        PBPoly gradedPart(int d)
+        PBSet diagram()
+        PBSet set()
+        PBSet leadDivisors()
+        PBNavigator navigation()
+        PBPolyIter orderedBegin()
+        PBPolyIter orderedEnd()
+        void iadd "operator+="(PBPoly right)
+        void iadd_PBMonom "operator+="(PBMonom right)
+        void imul "operator*="(PBPoly right)
+        void imul_monom "operator*="(PBMonom right)
+        void idiv "operator/="(PBPoly right)
+        void idiv_monom "operator/="(PBMonom right)
+        bint operator==(const PBPoly&)
+
+    PBSet pb_zeros "zeros"(PBPoly p, PBSet s)
+    PBPoly pb_spoly "spoly"(PBPoly p, PBPoly r)
+    PBPoly pb_map_every_x_to_x_plus_one "map_every_x_to_x_plus_one"(PBPoly)
+
+
+ctypedef vector[PBBoolePolynomial] PBPolyVector
+ctypedef vector[PBBoolePolynomial].iterator PBPolyVectorIter
+
+
+cdef extern from *:
+    cdef cppclass PBPolyEntry "PolyEntry":
+        PBPoly p
+
+    cdef cppclass PBRedStrategy "ReductionStrategy":
+        PBRedStrategy()
+        PBRedStrategy(const PBRing&)
+        PBSet leadingTerms
+        PBSet minimalLeadingTerms
+        PBSet leadingTerms11
+        PBSet leadingTerms00
+        PBSet llReductor
+        PBSet monomials
+        PBSet monomials_plus_one
+        bint optBrutalReductions
+        bint optLL
+        PBPoly nf(PBPoly p)
+        bint optRedTailDegGrowth
+        bint optRedTail
+        void setupSetsForLastElement()
+        bint canRewrite(PBPoly p)
+        void addGenerator(PBPoly p)
+        int select1(PBMonom p)
+
+        int select_short(PBPoly p)
+        PBPoly headNormalForm(PBPoly p)
+        PBPoly reducedNormalForm(PBPoly p)
+
+        size_t size()
+        PBPolyEntry operator[](int)
+
+    cdef cppclass PBFGLMStrategy "FGLMStrategy":
+        PBFGLMStrategy(PBRing from_ring, PBRing to_ring, PBPolyVector vec)
+        PBPolyVector main()
+
+    cdef cppclass PBGBStrategy "GroebnerStrategy":
+        PBGBStrategy(PBRing)
+        bint reduceByTailReduced
+        PBRedStrategy generators
+
+        bint enabledLog
+        unsigned int reductionSteps
+        int normalForms
+        int currentDegree
+        int chainCriterions
+        int variableChainCriterions
+        int easyProductCriterions
+        int extendedProductCriterions
+        int averageLength
+
+        bint optHFE
+        bint optLazy
+
+        bint optDelayNonMinimals
+
+        bint optExchange
+        bint optAllowRecursion
+
+        bint optStepBounded
+        bint optLinearAlgebraInLastBlock
+        bint optModifiedLinearAlgebra
+        bint optRedTailInLastBlock
+        bint optDrawMatrices
+        std_string matrixPrefix
+
+        PBSet llReductor
+        PBSet minimalLeadingTerms
+        PBSet leadingTerms
+        bint containsOne()
+        bint variableHasValue(int idx)
+        int addGenerator(PBPoly, bint is_impl)
+        void addGeneratorDelayed(PBPoly)
+        void addAsYouWish(PBPoly)
+        void addNonTrivialImplicationsDelayed(const PBPolyEntry&)
+        void symmGB_F2()
+        void llReduceAll()
+        void cleanTopByChainCriterion "pairs.cleanTopByChainCriterion"()
+        size_t npairs "pairs.queue.size"()
+        int suggestPluginVariable()
+        PBPoly nextSpoly()
+        PBPoly nf(PBPoly p)
+        PBPolyVector allGenerators()
+        PBPolyVector minimalize()
+        PBPolyVector minimalizeAndTailReduce()
+        PBPolyVector faugereStepDense(PBPolyVector v)
+
+    int pairs_top_sugar(PBGBStrategy strat)
+    PBPolyVector someNextDegreeSpolys(PBGBStrategy strat, size_t n)
+    PBPolyVector nextDegreeSpolys(PBGBStrategy strat)
+    PBPolyVector small_next_degree_spolys(PBGBStrategy strat, double f, size_t n)
+    void implications(PBGBStrategy strat, int i)
+
+    PBPoly cheap_reductions(PBRedStrategy strat, PBPoly p)
+
+    PBPoly pb_add_up_polynomials "add_up_polynomials" \
+        (PBPolyVector v, PBPoly p)
+
+    PBPoly pb_nf3 "nf3" (PBRedStrategy strat, PBPoly p, PBMonom m)
+
+    PBPoly pb_red_tail "red_tail" (PBRedStrategy strat, PBPoly p)
+
+    PBPoly pb_interpolate "interpolate" (PBSet z, PBSet o)
+
+    PBPoly pb_interpolate_smallest_lex "interpolate_smallest_lex" \
+        (PBSet z, PBSet o)
+
+    PBSet pb_contained_variables_cudd_style "contained_variables_cudd_style" \
+        (PBSet m)
+
+    PBSet pb_mod_var_set "mod_var_set" (PBSet a, PBSet v)
+
+    PBPoly pb_mult_fast_sim "mult_fast_sim" (PBPolyVector v, PBRing r)
+
+    PBSet pb_recursively_insert "recursively_insert"(PBNavigator p,
+                                                int idx, PBSet m)
+    PBPoly pb_ll_red_nf_noredsb "ll_red_nf_noredsb"(PBPoly p,
+                                                PBSet reductors)
+    PBPoly pb_ll_red_nf_noredsb_single_recursive_call "ll_red_nf_noredsb_single_recursive_call" \
+        (PBPoly p, PBSet reductors)
+
+    PBPoly pb_ll_red_nf "ll_red_nf"(PBPoly p, PBSet reductors)
+
+    PBSet pb_mod_mon_set "mod_mon_set"(PBSet as, PBSet vs)
+
+    PBPolyVector pb_parallel_reduce "parallel_reduce" \
+        (PBPolyVector inp, PBGBStrategy strat, int average_steps, double delay_f)
+
+    PBPolyVector pb_gauss_on_polys "gauss_on_polys" (PBPolyVector inp)
+
+    PBPolyVector pb_easy_linear_factors "easy_linear_factors"(PBPoly p)
+
+    PBPoly pb_substitute_variables "substitute_variables<BoolePolyRing, std::vector<BoolePolynomial>, BoolePolynomial>" \
+        (PBRing ring, PBPolyVector vec, PBPoly poly) except +
+
+    void pb_set_variable_name "BooleEnv::setVariableName" \
+        (int idx, char *varname)
+
+    char * pb_get_variable_name "BooleEnv::getVariableName" \
+        (int idx)
+
+    PBSet pb_random_set "random_set" (PBMonom variables, int length)
+    void pb_set_random_seed "set_random_seed" (unsigned int seed)
+
+    void PBPolyVector_set(PBPolyVector v, int i, PBPoly p)
+
+    cdef cppclass PBConstant "BooleConstant":
+        PBConstant()
+        PBConstant(int val)
+        bint isZero()
+        bint isOne()
+        bint isConstant()
+        bint hasConstantPart()
+        int deg()
+
+    cdef cppclass PBVariableFactory "VariableFactory":
+        PBVariableFactory(const PBRing&)
+
+    cdef cppclass PBVarFactory "DefaultRinged<VariableFactory> ":
+        void operator=(const PBVariableFactory&)
+        PBVar operator()(long index)
+
+    cdef cppclass PBMonomialFactory "MonomialFactory":
+        PBMonomialFactory(const PBRing&)
+
+    cdef cppclass PBMonomFactory "DefaultRinged<MonomialFactory> ":
+        void operator=(const PBMonomialFactory&)
+        PBMonom operator()()
+
+    cdef cppclass PBPolynomialFactory "PolynomialFactory":
+        PBPolynomialFactory(const PBRing &)
+
+    cdef cppclass PBPolyFactory "DefaultRinged<PolynomialFactory> ":
+        void operator=(const PBPolynomialFactory&)
+        PBPoly operator()(long)
+        PBPoly operator()(PBPoly)
+        PBPoly operator()(PBMonom)
+
+    cdef cppclass PBRefCounter:
+        PBRefCounter()
+        bint released()