polybori.dynamic.PyPolyBoRi
index
../../../../lib/python2.6/dist-packages/polybori/dynamic/PyPolyBoRi.so

 
Classes
       
Boost.Python.instance(__builtin__.object)
BooleConstant
BoolePolynomialVector
BooleRing
Ring
BooleSet
CCuddNavigator
GroebnerStrategy
IntVector
Monomial
Polynomial
Variable
VariableBlockFalse
VariableBlockTrue

 
class BooleConstant(Boost.Python.instance)
    Boolean constant value
 
 
Method resolution order:
BooleConstant
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*, polybori::BooleConstant) -> void*
 
Convert integer to Boolean value
C++ signature:
    __init__(_object*, int) -> void*
 
Convert bool to Boolean value
C++ signature:
    __init__(_object*, bool) -> void*
__repr__(...)
C++ signature:
__repr__(polybori::BooleConstant) -> boost::python::str
__str__(...)
C++ signature:
__str__(polybori::BooleConstant) -> boost::python::str

Data and other attributes defined here:
__instance_size__ = 12

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class BoolePolynomialVector(Boost.Python.instance)
    
Method resolution order:
BoolePolynomialVector
Boost.Python.instance
__builtin__.object

Methods defined here:
__contains__(...)
C++ signature:
__contains__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue}, _object*) -> bool
__delitem__(...)
C++ signature:
__delitem__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue}, _object*) -> void*
__eq__(...)
C++ signature:
__eq__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue}, std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >) -> _object*
__getitem__(...)
C++ signature:
__getitem__(boost::python::back_reference<std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >&>, _object*) -> boost::python::api::object
__init__ = init(self, iteratable=None)
__iter__(...)
C++ signature:
__iter__(boost::python::back_reference<std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >&>) -> boost::python::objects::iterator_range<boost::python::return_internal_reference<1u, boost::python::default_call_policies>, __gnu_cxx::__normal_iterator<polybori::BoolePolynomial*, std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > > >
__len__(...)
C++ signature:
__len__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue}) -> unsigned int
__setitem__(...)
C++ signature:
__setitem__(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue}, _object*, _object*) -> void*
append(...)
C++ signature:
append(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue}, boost::python::api::object) -> void*
extend(...)
C++ signature:
extend(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> > {lvalue}, boost::python::api::object) -> void*

Data and other attributes defined here:
__instance_size__ = 20

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class BooleRing(Boost.Python.instance)
    Boolean ring
 
 
Method resolution order:
BooleRing
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*, unsigned int) -> void*

Data and other attributes defined here:
__instance_size__ = 12

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class BooleSet(Boost.Python.instance)
    Represents set of Boolean terms
 
 
Method resolution order:
BooleSet
Boost.Python.instance
__builtin__.object

Methods defined here:
__contains__(...)
Check whether a term is included in BooleSet
C++ signature:
    __contains__(polybori::BooleSet {lvalue}, polybori::BooleMonomial) -> bool
__eq__(...)
C++ signature:
__eq__(polybori::BooleSet {lvalue}, polybori::BooleSet) -> _object*
__hash__(...)
Fast hash code, based on the pointer to the underlying ZDD node. 
It may vary from runtime to runtime.
C++ signature:
    __hash__(polybori::BooleSet {lvalue}) -> unsigned int
__init__ = booleset_new_init(self, arg=None, second=None)
__iter__(...)
C++ signature:
__iter__(boost::python::back_reference<polybori::BooleSet&>) -> boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, polybori::CGenericIter<polybori::LexOrder, polybori::CCuddNavigator, polybori::BooleMonomial> >
__len__(...)
C++ signature:
__len__(polybori::BooleSet {lvalue}) -> unsigned int
__mod__(...)
C++ signature:
__mod__(polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
__repr__(...)
C++ signature:
__repr__(polybori::BooleSet) -> boost::python::str
__str__(...)
C++ signature:
__str__(polybori::BooleSet) -> boost::python::str
cartesianProduct(...)
Cartesian product
C++ signature:
    cartesianProduct(polybori::BooleSet {lvalue}, polybori::BooleSet) -> polybori::BooleSet
change(...)
Substitute variable of given index by its complement
C++ signature:
    change(polybori::BooleSet {lvalue}, int) -> polybori::BooleSet
diff(...)
Set difference
C++ signature:
    diff(polybori::BooleSet {lvalue}, polybori::BooleSet) -> polybori::BooleSet
divide(...)
Set division by a given term
C++ signature:
    divide(polybori::BooleSet {lvalue}, polybori::BooleMonomial) -> polybori::BooleSet
divisorsOf(...)
Compute intersection with divisors of the right-hand side term
C++ signature:
    divisorsOf(polybori::BooleSet {lvalue}, polybori::BooleMonomial) -> polybori::BooleSet
empty(...)
Check, whether BooleSet is empty
C++ signature:
    empty(polybori::BooleSet {lvalue}) -> bool
existAbstract(...)
a.existsAbstract(m) returns a BooleSet, where every term t is included, where exists n such that n*m=t*m and n is element of a
C++ signature:
    existAbstract(polybori::BooleSet {lvalue}, polybori::BooleMonomial) -> polybori::BooleSet
includeDivisors(...)
C++ signature:
includeDivisors(polybori::BooleSet) -> polybori::BooleSet
intersect(...)
Set intersection
C++ signature:
    intersect(polybori::BooleSet {lvalue}, polybori::BooleSet) -> polybori::BooleSet
minimalElements(...)
Get minimal elements with respect to inclusion
C++ signature:
    minimalElements(polybori::BooleSet) -> polybori::BooleSet
multiplesOf(...)
Compute intersection with multiples of the right-hand side term
C++ signature:
    multiplesOf(polybori::BooleSet {lvalue}, polybori::BooleMonomial) -> polybori::BooleSet
nNodes(...)
Number of nodes of the underlying ZDD
C++ signature:
    nNodes(polybori::BooleSet {lvalue}) -> unsigned int
nSupport(...)
C++ signature:
nSupport(polybori::BooleSet {lvalue}) -> unsigned int
navigation(...)
Navigate through underlying ZDD structure
C++ signature:
    navigation(polybori::BooleSet {lvalue}) -> polybori::CCuddNavigator
ring(...)
Get corresponding ring
C++ signature:
    ring(polybori::BooleSet {lvalue}) -> polybori::BooleRing
set(...)
C++ signature:
set(polybori::BooleSet) -> polybori::BooleSet
sizeDouble(...)
Number of elements as double floating point number.
C++ signature:
    sizeDouble(polybori::BooleSet {lvalue}) -> double
stableHash(...)
Reproducible hash code
C++ signature:
    stableHash(polybori::BooleSet {lvalue}) -> unsigned int
subset0(...)
Returns BooleSet, where the nodes corresponding to Variables of given index is replaced by its else-branch
C++ signature:
    subset0(polybori::BooleSet {lvalue}, int) -> polybori::BooleSet
subset1(...)
Returns BooleSet, where the nodes corresponding to Variables of given index is replaced by its then-branch
C++ signature:
    subset1(polybori::BooleSet {lvalue}, int) -> polybori::BooleSet
union(...)
Set union
C++ signature:
    union(polybori::BooleSet {lvalue}, polybori::BooleSet) -> polybori::BooleSet
vars(...)
Variables occurring in BooleSet
C++ signature:
    vars(polybori::BooleSet {lvalue}) -> polybori::BooleMonomial

Data and other attributes defined here:
__instance_size__ = 16

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class CCuddNavigator(Boost.Python.instance)
    
Method resolution order:
CCuddNavigator
Boost.Python.instance
__builtin__.object

Methods defined here:
__eq__(...)
C++ signature:
__eq__(polybori::CCuddNavigator {lvalue}, polybori::CCuddNavigator) -> _object*
__hash__(...)
Fast hash code, based on the pointer to the underlying ZDD node. 
It may vary from runtime to runtime.
C++ signature:
    __hash__(polybori::CCuddNavigator {lvalue}) -> unsigned int
__init__(...)
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*) -> void*
 
Iterator-like object, which allows to navigate through ZDD-based data structures,
C++ signature:
    __init__(_object*, polybori::CCuddNavigator) -> void*
__ne__(...)
C++ signature:
__ne__(polybori::CCuddNavigator {lvalue}, polybori::CCuddNavigator) -> _object*
constant(...)
Terminal node test
C++ signature:
    constant(polybori::CCuddNavigator {lvalue}) -> bool
elseBranch(...)
Following else-edge of thr root node
C++ signature:
    elseBranch(polybori::CCuddNavigator) -> polybori::CCuddNavigator
terminalOne(...)
Check for terminal 1
C++ signature:
    terminalOne(polybori::CCuddNavigator {lvalue}) -> bool
thenBranch(...)
Following then-edge of thr root node
C++ signature:
    thenBranch(polybori::CCuddNavigator) -> polybori::CCuddNavigator
valid(...)
If navigator is constant, this checks for terminal one
C++ signature:
    valid(polybori::CCuddNavigator {lvalue}) -> bool
value(...)
C++ signature:
value(polybori::CCuddNavigator) -> int

Data and other attributes defined here:
__instance_size__ = 12

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class GroebnerStrategy(Boost.Python.instance)
    
Method resolution order:
GroebnerStrategy
Boost.Python.instance
__builtin__.object

Methods defined here:
__getitem__(...)
C++ signature:
    __getitem__(polybori::groebner::GroebnerStrategy, int) -> polybori::BoolePolynomial
C++ signature:
    __getitem__(polybori::groebner::GroebnerStrategy, polybori::BooleMonomial) -> polybori::BoolePolynomial
__init__(...)
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*, polybori::groebner::GroebnerStrategy) -> void*
__iter__(...)
C++ signature:
__iter__(boost::python::back_reference<polybori::groebner::GroebnerStrategy const&>) -> boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, StrategyIterator>
__len__(...)
C++ signature:
__len__(polybori::groebner::GroebnerStrategy) -> int
addAsYouWish(...)
C++ signature:
addAsYouWish(polybori::groebner::GroebnerStrategy {lvalue}, polybori::BoolePolynomial) -> void*
addGenerator(...)
C++ signature:
addGenerator(polybori::groebner::GroebnerStrategy {lvalue}, polybori::BoolePolynomial) -> void*
addGeneratorDelayed(...)
C++ signature:
addGeneratorDelayed(polybori::groebner::GroebnerStrategy {lvalue}, polybori::BoolePolynomial) -> void*
allGenerators(...)
C++ signature:
allGenerators(polybori::groebner::GroebnerStrategy {lvalue}) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
allSpolysInNextDegree(...)
C++ signature:
allSpolysInNextDegree(polybori::groebner::GroebnerStrategy {lvalue}) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
canRewrite(...)
C++ signature:
canRewrite(polybori::groebner::GroebnerStrategy {lvalue}, polybori::BoolePolynomial) -> bool
cleanTopByChainCriterion(...)
C++ signature:
cleanTopByChainCriterion(polybori::groebner::GroebnerStrategy {lvalue}) -> void*
containsOne(...)
C++ signature:
containsOne(polybori::groebner::GroebnerStrategy) -> bool
faugereStepDense(...)
C++ signature:
faugereStepDense(polybori::groebner::GroebnerStrategy {lvalue}, std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
implications(...)
C++ signature:
implications(polybori::groebner::GroebnerStrategy {lvalue}, int) -> void*
llReduceAll(...)
C++ signature:
llReduceAll(polybori::groebner::GroebnerStrategy {lvalue}) -> void*
minimalize(...)
C++ signature:
minimalize(polybori::groebner::GroebnerStrategy {lvalue}) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
minimalizeAndTailReduce(...)
C++ signature:
minimalizeAndTailReduce(polybori::groebner::GroebnerStrategy {lvalue}) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
nextSpoly(...)
C++ signature:
nextSpoly(polybori::groebner::GroebnerStrategy {lvalue}) -> polybori::BoolePolynomial
nf(...)
C++ signature:
nf(polybori::groebner::GroebnerStrategy {lvalue}, polybori::BoolePolynomial) -> polybori::BoolePolynomial
noroStep(...)
C++ signature:
noroStep(polybori::groebner::GroebnerStrategy {lvalue}, std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
npairs(...)
C++ signature:
npairs(polybori::groebner::GroebnerStrategy) -> int
redTail(...)
C++ signature:
redTail(polybori::groebner::GroebnerStrategy {lvalue}, polybori::BoolePolynomial) -> polybori::BoolePolynomial
select(...)
C++ signature:
select(polybori::groebner::GroebnerStrategy, polybori::BooleMonomial) -> int
smallSpolysInNextDegree(...)
C++ signature:
smallSpolysInNextDegree(polybori::groebner::GroebnerStrategy {lvalue}, double, int) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
someSpolysInNextDegree(...)
C++ signature:
someSpolysInNextDegree(polybori::groebner::GroebnerStrategy {lvalue}, int) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
suggestPluginVariable(...)
C++ signature:
suggestPluginVariable(polybori::groebner::GroebnerStrategy {lvalue}) -> int
symmGB_F2(...)
C++ signature:
symmGB_F2(polybori::groebner::GroebnerStrategy {lvalue}) -> void*
toStdOut(...)
C++ signature:
toStdOut(polybori::groebner::GroebnerStrategy {lvalue}) -> void*
topSugar(...)
C++ signature:
topSugar(polybori::groebner::GroebnerStrategy) -> int
variableHasValue(...)
C++ signature:
variableHasValue(polybori::groebner::GroebnerStrategy {lvalue}, int) -> bool

Data descriptors defined here:
chainCriterions
easyProductCriterions
enabledLog
extendedProductCriterions
leadingTerms
llReductor
minimalLeadingTerms
monomials
optAllowRecursion
optBrutalReductions
optExchange
optLL
optLazy
optLinearAlgebraInLastBlock
optRedByReduced
optRedTail
optRedTailDegGrowth
variableChainCriterions

Data and other attributes defined here:
__instance_size__ = 228

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class IntVector(Boost.Python.instance)
    
Method resolution order:
IntVector
Boost.Python.instance
__builtin__.object

Methods defined here:
__contains__(...)
C++ signature:
__contains__(std::vector<int, std::allocator<int> > {lvalue}, _object*) -> bool
__delitem__(...)
C++ signature:
__delitem__(std::vector<int, std::allocator<int> > {lvalue}, _object*) -> void*
__eq__(...)
C++ signature:
__eq__(std::vector<int, std::allocator<int> > {lvalue}, std::vector<int, std::allocator<int> >) -> _object*
__getitem__(...)
C++ signature:
__getitem__(boost::python::back_reference<std::vector<int, std::allocator<int> >&>, _object*) -> boost::python::api::object
__init__ = init(self, iteratable=None)
__iter__(...)
C++ signature:
__iter__(boost::python::back_reference<std::vector<int, std::allocator<int> >&>) -> boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > > >
__len__(...)
C++ signature:
__len__(std::vector<int, std::allocator<int> > {lvalue}) -> unsigned int
__setitem__(...)
C++ signature:
__setitem__(std::vector<int, std::allocator<int> > {lvalue}, _object*, _object*) -> void*
append(...)
C++ signature:
append(std::vector<int, std::allocator<int> > {lvalue}, boost::python::api::object) -> void*
extend(...)
C++ signature:
extend(std::vector<int, std::allocator<int> > {lvalue}, boost::python::api::object) -> void*

Data and other attributes defined here:
__instance_size__ = 20

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Monomial(Boost.Python.instance)
    Boolean monomial
 
 
Method resolution order:
Monomial
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
C++ signature:
    __add__(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __add__(polybori::BooleMonomial {lvalue}, int) -> _object*
C++ signature:
    __add__(polybori::BooleMonomial {lvalue}, polybori::BooleVariable) -> _object*
__div__ = monomial_python_div(self, arg)
__eq__(...)
C++ signature:
    __eq__(polybori::BooleMonomial {lvalue}, int) -> _object*
C++ signature:
    __eq__(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __eq__(polybori::BooleMonomial {lvalue}, bool) -> _object*
__ge__(...)
C++ signature:
__ge__(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> _object*
__gt__(...)
C++ signature:
__gt__(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> _object*
__hash__(...)
Fast hash code, based on the pointer to the underlying ZDD node. 
It may vary from runtime to runtime.
C++ signature:
    __hash__(polybori::BooleMonomial {lvalue}) -> unsigned int
__idiv__(...)
C++ signature:
__idiv__(boost::python::back_reference<polybori::BooleMonomial&>, polybori::BooleMonomial) -> _object*
__imul__(...)
C++ signature:
__imul__(boost::python::back_reference<polybori::BooleMonomial&>, polybori::BooleMonomial) -> _object*
__init__ = monomial_new_init(self, arg=None)
__le__(...)
C++ signature:
__le__(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> _object*
__len__(...)
Equivalent to deg
C++ signature:
    __len__(polybori::BooleMonomial {lvalue}) -> unsigned int
__lt__(...)
C++ signature:
__lt__(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> _object*
__mul__(...)
C++ signature:
    __mul__(polybori::BooleMonomial {lvalue}, int) -> _object*
C++ signature:
    __mul__(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __mul__(polybori::BooleMonomial {lvalue}, int) -> _object*
__ne__(...)
C++ signature:
    __ne__(polybori::BooleMonomial {lvalue}, int) -> _object*
C++ signature:
    __ne__(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __ne__(polybori::BooleMonomial {lvalue}, bool) -> _object*
__pow__(...)
C++ signature:
__pow__(polybori::BooleMonomial, int) -> polybori::BooleMonomial
__radd__(...)
C++ signature:
    __radd__(polybori::BooleMonomial {lvalue}, int) -> _object*
C++ signature:
    __radd__(polybori::BooleMonomial {lvalue}, polybori::BooleVariable) -> _object*
__repr__(...)
C++ signature:
__repr__(polybori::BooleMonomial) -> boost::python::str
__rmul__(...)
C++ signature:
    __rmul__(polybori::BooleMonomial {lvalue}, int) -> _object*
C++ signature:
    __rmul__(polybori::BooleMonomial {lvalue}, int) -> _object*
__rsub__(...)
C++ signature:
    __rsub__(polybori::BooleMonomial {lvalue}, int) -> _object*
C++ signature:
    __rsub__(polybori::BooleMonomial {lvalue}, polybori::BooleVariable) -> _object*
__str__(...)
C++ signature:
__str__(polybori::BooleMonomial) -> boost::python::str
__sub__(...)
C++ signature:
__sub__(polybori::BooleMonomial {lvalue}, polybori::BooleVariable) -> _object*
deg(...)
Degree of the monomial
C++ signature:
    deg(polybori::BooleMonomial {lvalue}) -> unsigned int
divisors(...)
Return Boolean set consisting of all divisors of the monomial
C++ signature:
    divisors(polybori::BooleMonomial {lvalue}) -> polybori::BooleSet
multiples(...)
Return Boolean set consisting of all multiples of the monomial
C++ signature:
    multiples(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> polybori::BooleSet
reducibleBy(...)
Test for reducibility
C++ signature:
    reducibleBy(polybori::BooleMonomial {lvalue}, polybori::BooleMonomial) -> bool
ring(...)
Get corresponding ring
C++ signature:
    ring(polybori::BooleMonomial {lvalue}) -> polybori::BooleRing
set(...)
Convert to BooleSet
C++ signature:
    set(polybori::BooleMonomial {lvalue}) -> polybori::BooleSet
stableHash(...)
Reproducible hash code
C++ signature:
    stableHash(polybori::BooleMonomial {lvalue}) -> unsigned int
variables(...)
C++ signature:
variables(boost::python::back_reference<polybori::BooleMonomial&>) -> boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, polybori::CVariableIter<polybori::CCuddFirstIter, polybori::BooleVariable> >
varsAsMonomial(...)
Variables occurring in Polynomial
C++ signature:
    varsAsMonomial(polybori::BooleMonomial) -> polybori::BooleMonomial

Data and other attributes defined here:
__instance_size__ = 16

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Polynomial(Boost.Python.instance)
    Construct a BoolePolynomial object   in the given Boolean polynomial ring.
 
 
Method resolution order:
Polynomial
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
C++ signature:
    __add__(polybori::BoolePolynomial {lvalue}, polybori::BooleVariable) -> _object*
C++ signature:
    __add__(polybori::BoolePolynomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __add__(polybori::BoolePolynomial {lvalue}, int) -> _object*
C++ signature:
    __add__(polybori::BoolePolynomial {lvalue}, polybori::BooleVariable) -> _object*
C++ signature:
    __add__(polybori::BoolePolynomial {lvalue}, polybori::BoolePolynomial) -> _object*
__div__(...)
C++ signature:
    __div__(polybori::BoolePolynomial {lvalue}, int) -> _object*
C++ signature:
    __div__(polybori::BoolePolynomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __div__(polybori::BoolePolynomial {lvalue}, polybori::BoolePolynomial) -> _object*
__eq__(...)
C++ signature:
    __eq__(polybori::BoolePolynomial {lvalue}, polybori::BoolePolynomial) -> _object*
C++ signature:
    __eq__(polybori::BoolePolynomial {lvalue}, int) -> _object*
C++ signature:
    __eq__(polybori::BoolePolynomial {lvalue}, bool) -> _object*
__hash__(...)
Fast hash code, based on the pointer to the underlying ZDD node. 
It may vary from runtime to runtime.
C++ signature:
    __hash__(polybori::BoolePolynomial {lvalue}) -> unsigned int
__iadd__(...)
C++ signature:
    __iadd__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BoolePolynomial) -> _object*
C++ signature:
    __iadd__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BooleVariable) -> _object*
C++ signature:
    __iadd__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BooleMonomial) -> _object*
C++ signature:
    __iadd__(boost::python::back_reference<polybori::BoolePolynomial&>, int) -> _object*
__imul__(...)
C++ signature:
    __imul__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BoolePolynomial) -> _object*
C++ signature:
    __imul__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BooleMonomial) -> _object*
C++ signature:
    __imul__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BooleMonomial) -> _object*
C++ signature:
    __imul__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BooleVariable) -> _object*
__init__(...)
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*, polybori::BoolePolynomial) -> void*
C++ signature:
    __init__(_object*, polybori::CCuddNavigator, polybori::BooleRing) -> void*
C++ signature:
    __init__(_object*, int, polybori::BooleRing) -> void*
C++ signature:
    __init__(_object*, polybori::CDDInterface<polybori::CCuddZDD>) -> void*
C++ signature:
    __init__(_object*, polybori::BooleVariable) -> void*
C++ signature:
    __init__(_object*, polybori::BooleMonomial) -> void*
C++ signature:
    __init__(_object*, bool) -> void*
C++ signature:
    __init__(_object*, int) -> void*
__isub__(...)
C++ signature:
    __isub__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BoolePolynomial) -> _object*
C++ signature:
    __isub__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BooleVariable) -> _object*
C++ signature:
    __isub__(boost::python::back_reference<polybori::BoolePolynomial&>, polybori::BooleMonomial) -> _object*
C++ signature:
    __isub__(boost::python::back_reference<polybori::BoolePolynomial&>, int) -> _object*
__len__(...)
Number of terms
C++ signature:
    __len__(polybori::BoolePolynomial {lvalue}) -> unsigned int
__mod__(...)
C++ signature:
    __mod__(polybori::BoolePolynomial {lvalue}, polybori::BooleVariable) -> _object*
C++ signature:
    __mod__(polybori::BoolePolynomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __mod__(polybori::BoolePolynomial {lvalue}, polybori::BoolePolynomial) -> _object*
__mul__(...)
C++ signature:
    __mul__(polybori::BoolePolynomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __mul__(polybori::BoolePolynomial {lvalue}, polybori::BoolePolynomial) -> _object*
C++ signature:
    __mul__(polybori::BoolePolynomial {lvalue}, polybori::BooleVariable) -> _object*
__ne__(...)
C++ signature:
    __ne__(polybori::BoolePolynomial {lvalue}, int) -> _object*
C++ signature:
    __ne__(polybori::BoolePolynomial {lvalue}, polybori::BoolePolynomial) -> _object*
C++ signature:
    __ne__(polybori::BoolePolynomial {lvalue}, bool) -> _object*
__pow__(...)
C++ signature:
__pow__(polybori::BoolePolynomial, int) -> polybori::BoolePolynomial
__radd__(...)
C++ signature:
    __radd__(polybori::BoolePolynomial {lvalue}, polybori::BooleVariable) -> _object*
C++ signature:
    __radd__(polybori::BoolePolynomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __radd__(polybori::BoolePolynomial {lvalue}, int) -> _object*
__repr__(...)
C++ signature:
__repr__(polybori::BoolePolynomial) -> boost::python::str
__rmul__(...)
C++ signature:
__rmul__(polybori::BoolePolynomial {lvalue}, polybori::BooleMonomial) -> _object*
__rsub__(...)
C++ signature:
    __rsub__(polybori::BoolePolynomial {lvalue}, polybori::BooleVariable) -> _object*
C++ signature:
    __rsub__(polybori::BoolePolynomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __rsub__(polybori::BoolePolynomial {lvalue}, int) -> _object*
__str__(...)
C++ signature:
__str__(polybori::BoolePolynomial) -> boost::python::str
__sub__(...)
C++ signature:
    __sub__(polybori::BoolePolynomial {lvalue}, polybori::BooleVariable) -> _object*
C++ signature:
    __sub__(polybori::BoolePolynomial {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __sub__(polybori::BoolePolynomial {lvalue}, int) -> _object*
C++ signature:
    __sub__(polybori::BoolePolynomial {lvalue}, polybori::BooleVariable) -> _object*
C++ signature:
    __sub__(polybori::BoolePolynomial {lvalue}, polybori::BoolePolynomial) -> _object*
constant(...)
Test, whether Polynomial os constant
C++ signature:
    constant(polybori::BoolePolynomial {lvalue}) -> bool
deg(...)
Polynomial degree
C++ signature:
    deg(polybori::BoolePolynomial {lvalue}) -> unsigned int
elength(...)
Elimination length
C++ signature:
    elength(polybori::BoolePolynomial {lvalue}) -> unsigned int
firstTerm(...)
First lexicographical term
C++ signature:
    firstTerm(polybori::BoolePolynomial {lvalue}) -> polybori::BooleMonomial
gradedPart(...)
Get part of given degree
C++ signature:
    gradedPart(polybori::BoolePolynomial {lvalue}, unsigned int) -> polybori::BoolePolynomial
hasConstantPart(...)
Check, whether Polynomials owns constant term
C++ signature:
    hasConstantPart(polybori::BoolePolynomial {lvalue}) -> bool
isOne(...)
Test if Polynomial one
C++ signature:
    isOne(polybori::BoolePolynomial {lvalue}) -> bool
isZero(...)
Test if Polynomial is zero
C++ signature:
    isZero(polybori::BoolePolynomial {lvalue}) -> bool
lead(...)
Leading term with respect to current ordering
C++ signature:
    lead(polybori::BoolePolynomial {lvalue}) -> polybori::BooleMonomial
lexLead(...)
Lexicographical leading term
C++ signature:
    lexLead(polybori::BoolePolynomial {lvalue}) -> polybori::BooleMonomial
lexLmDeg(...)
Degree of the lexicographical leading term
C++ signature:
    lexLmDeg(polybori::BoolePolynomial {lvalue}) -> unsigned int
lmDeg(...)
Degree of the leading term
C++ signature:
    lmDeg(polybori::BoolePolynomial {lvalue}) -> unsigned int
lmDivisors(...)
Divisors of leading term
C++ signature:
    lmDivisors(polybori::BoolePolynomial {lvalue}) -> polybori::BooleSet
mapEveryXToXPlusOne(...)
Replace every variable x by x + 1
C++ signature:
    mapEveryXToXPlusOne(polybori::BoolePolynomial) -> polybori::BoolePolynomial
nNodes(...)
Number of diagram nodes in the underlying ZDD structure
C++ signature:
    nNodes(polybori::BoolePolynomial {lvalue}) -> unsigned int
nVars(...)
Number of variables occurring in Polynomial
C++ signature:
    nVars(polybori::BoolePolynomial {lvalue}) -> unsigned int
navigation(...)
Navigate through underlying ZDD structure
C++ signature:
    navigation(polybori::BoolePolynomial {lvalue}) -> polybori::CCuddNavigator
plot(...)
C++ signature:
plot(polybori::BoolePolynomial, char const*) -> void*
reducibleBy(...)
C++ signature:
reducibleBy(polybori::BoolePolynomial {lvalue}, polybori::BoolePolynomial) -> bool
ring(...)
Get corresponding ring
C++ signature:
    ring(polybori::BoolePolynomial {lvalue}) -> polybori::BooleRing
set(...)
Convert to BooleSet
C++ signature:
    set(polybori::BoolePolynomial {lvalue}) -> polybori::BooleSet
stableHash(...)
Reproducible hash code
C++ signature:
    stableHash(polybori::BoolePolynomial {lvalue}) -> unsigned int
terms(...)
C++ signature:
terms(boost::python::back_reference<polybori::BoolePolynomial&>) -> boost::python::objects::iterator_range<boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, polybori::COrderedIter<polybori::CCuddNavigator, polybori::BooleMonomial> >
toStdOut(...)
C++ signature:
toStdOut(polybori::BoolePolynomial) -> void*
totalDegree(...)
Total Polynomial degree
C++ signature:
    totalDegree(polybori::BoolePolynomial {lvalue}) -> unsigned int
varsAsMonomial(...)
Variables occurring in Polynomial
C++ signature:
    varsAsMonomial(polybori::BoolePolynomial {lvalue}) -> polybori::BooleMonomial
zerosIn(...)
Get BooleSet representing the zeros of the Polynomial
C++ signature:
    zerosIn(polybori::BoolePolynomial, polybori::BooleSet) -> polybori::BooleSet

Data and other attributes defined here:
__instance_size__ = 16

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Ring(BooleRing)
    Boolean polynomial ring
 
 
Method resolution order:
Ring
BooleRing
Boost.Python.instance
__builtin__.object

Methods defined here:
__init__(...)
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*, unsigned int) -> void*
 
Construct a Boolean polynomial ring with the following parameters:
            n -- number of variables (integer)
            order -- term ordering (optinal), one of the following values 
                lp: lexicographical ordering (default)
                dlex: degree lexicographical ordering
                dp_asc: degree reverse lexicographical ordering with inverted variable order
                block_dp_asc: Block ordering with blocks consisting of dp_asc
                block_dlex: Block ordering with blocks consisting of dlex
 
C++ signature:
    __init__(_object*, unsigned int, int) -> void*
nVars(...)
Number of ring variables
C++ signature:
    nVars(polybori::BoolePolyRing {lvalue}) -> unsigned int
one(...)
Polynomial one
C++ signature:
    one(polybori::BoolePolyRing) -> polybori::BoolePolynomial
set(...)
Activate current Ring
C++ signature:
    set(polybori::BoolePolyRing {lvalue}) -> void*
var(...)
i-th ring Variable
C++ signature:
    var(polybori::BoolePolyRing, int) -> polybori::BoolePolynomial
zero(...)
Polynomial zero
C++ signature:
    zero(polybori::BoolePolyRing) -> polybori::BoolePolynomial

Data and other attributes defined here:
__instance_size__ = 20

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class Variable(Boost.Python.instance)
    Boolean Variable
 
 
Method resolution order:
Variable
Boost.Python.instance
__builtin__.object

Methods defined here:
__add__(...)
C++ signature:
    __add__(polybori::BooleVariable {lvalue}, polybori::BooleVariable) -> _object*
C++ signature:
    __add__(polybori::BooleVariable {lvalue}, int) -> _object*
__div__ = variable_python_div(self, arg)
__eq__(...)
C++ signature:
__eq__(polybori::BooleVariable {lvalue}, polybori::BooleVariable) -> _object*
__ge__(...)
C++ signature:
__ge__(polybori::BooleVariable {lvalue}, polybori::BooleVariable) -> _object*
__gt__(...)
C++ signature:
__gt__(polybori::BooleVariable {lvalue}, polybori::BooleVariable) -> _object*
__hash__(...)
C++ signature:
__hash__(polybori::BooleVariable {lvalue}) -> int
__init__(...)
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*, polybori::BooleVariable) -> void*
 
Get Variable of given index
C++ signature:
    __init__(_object*, int) -> void*
__le__(...)
C++ signature:
__le__(polybori::BooleVariable {lvalue}, polybori::BooleVariable) -> _object*
__lt__(...)
C++ signature:
__lt__(polybori::BooleVariable {lvalue}, polybori::BooleVariable) -> _object*
__mul__(...)
C++ signature:
    __mul__(polybori::BooleVariable {lvalue}, polybori::BooleVariable) -> _object*
C++ signature:
    __mul__(polybori::BooleVariable {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __mul__(polybori::BooleVariable {lvalue}, int) -> _object*
__pow__(...)
C++ signature:
__pow__(polybori::BooleVariable, int) -> polybori::BooleMonomial
__radd__(...)
C++ signature:
__radd__(polybori::BooleVariable {lvalue}, int) -> _object*
__repr__(...)
C++ signature:
__repr__(polybori::BooleVariable) -> boost::python::str
__rmul__(...)
C++ signature:
    __rmul__(polybori::BooleVariable {lvalue}, polybori::BooleMonomial) -> _object*
C++ signature:
    __rmul__(polybori::BooleVariable {lvalue}, int) -> _object*
__str__(...)
C++ signature:
__str__(polybori::BooleVariable) -> boost::python::str
index(...)
Variable position in the ring
C++ signature:
    index(polybori::BooleVariable {lvalue}) -> int
ring(...)
Get corresponding ring
C++ signature:
    ring(polybori::BooleVariable {lvalue}) -> polybori::BooleRing
set(...)
Convert to BooleSet
C++ signature:
    set(polybori::BooleVariable {lvalue}) -> polybori::BooleSet
toStdOut(...)
C++ signature:
toStdOut(polybori::BooleVariable) -> void*
varsAsMonomial(...)
Variables occurring in Polynomial
C++ signature:
    varsAsMonomial(polybori::BooleVariable) -> polybori::BooleMonomial

Data and other attributes defined here:
__instance_size__ = 16

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class VariableBlockFalse(Boost.Python.instance)
    
Method resolution order:
VariableBlockFalse
Boost.Python.instance
__builtin__.object

Methods defined here:
__call__(...)
C++ signature:
__call__(VariableBlock<false> {lvalue}, int) -> polybori::BooleVariable
__init__(...)
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*, VariableBlock<false>) -> void*
C++ signature:
    __init__(_object*, int, int, int) -> void*

Data and other attributes defined here:
__instance_size__ = 20

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class VariableBlockTrue(Boost.Python.instance)
    
Method resolution order:
VariableBlockTrue
Boost.Python.instance
__builtin__.object

Methods defined here:
__call__(...)
C++ signature:
__call__(VariableBlock<true> {lvalue}, int) -> polybori::BooleVariable
__init__(...)
C++ signature:
    __init__(_object*) -> void*
C++ signature:
    __init__(_object*, VariableBlock<true>) -> void*
C++ signature:
    __init__(_object*, int, int, int) -> void*

Data and other attributes defined here:
__instance_size__ = 20

Data descriptors inherited from Boost.Python.instance:
__dict__
__weakref__

Data and other attributes inherited from Boost.Python.instance:
__new__ = <built-in method __new__ of Boost.Python.class object at 0x4083f9a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
Functions
       
VariableBlock(...)
C++ signature:
VariableBlock(int, int, int, bool) -> boost::python::api::object
add_up_polynomials(...)
C++ signature:
add_up_polynomials(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >) -> polybori::BoolePolynomial
append_ring_block(...)
Append integer, which marks start of next block (for block orderings)
C++ signature:
    append_ring_block(int) -> void*
change_ordering(...)
C++ signature:
change_ordering(int) -> void*
contained_vars(...)
C++ signature:
contained_vars(polybori::BooleSet) -> polybori::BooleSet
count_double(...)
C++ signature:
count_double(polybori::BooleSet) -> double
get_order_code(...)
C++ signature:
get_order_code(void) -> int
global_ring(...)
C++ signature:
global_ring(void) -> polybori::BoolePolyRing
have_degree_order(...)
Determines, whether ring ordering is a degree ordering
C++ signature:
    have_degree_order(void) -> bool
if_then_else(...)
if-then else operator
C++ signature:
    if_then_else(int, polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
 
if-then else operator
C++ signature:
    if_then_else(polybori::BooleVariable, polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
interpolate(...)
C++ signature:
interpolate(polybori::BooleSet, polybori::BooleSet) -> polybori::BoolePolynomial
interpolate_smallest_lex(...)
C++ signature:
interpolate_smallest_lex(polybori::BooleSet, polybori::BooleSet) -> polybori::BoolePolynomial
ll_red_nf(...)
C++ signature:
ll_red_nf(polybori::BoolePolynomial, polybori::BooleSet) -> polybori::BoolePolynomial
ll_red_nf_noredsb(...)
C++ signature:
ll_red_nf_noredsb(polybori::BoolePolynomial, polybori::BooleSet) -> polybori::BoolePolynomial
map_every_x_to_x_plus_one(...)
C++ signature:
map_every_x_to_x_plus_one(polybori::BoolePolynomial) -> polybori::BoolePolynomial
mapping(...)
C++ signature:
mapping(polybori::BoolePolynomial, polybori::BooleMonomial, polybori::BooleMonomial) -> polybori::BoolePolynomial
mod_mon_set(...)
C++ signature:
    mod_mon_set(polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
C++ signature:
    mod_mon_set(polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
mod_var_set(...)
C++ signature:
mod_var_set(polybori::BooleSet, polybori::BooleSet) -> polybori::BooleSet
mult_fast_sim_C(...)
C++ signature:
mult_fast_sim_C(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >) -> polybori::BoolePolynomial
nf3(...)
C++ signature:
nf3(polybori::groebner::GroebnerStrategy, polybori::BoolePolynomial, polybori::BooleMonomial) -> polybori::BoolePolynomial
number_of_variables(...)
Number of variables in the active ring
C++ signature:
    number_of_variables(void) -> unsigned int
one(...)
Constant one of the active ring
C++ signature:
    one(void) -> polybori::CDDInterface<polybori::CCuddZDD>
parallel_reduce(...)
C++ signature:
parallel_reduce(std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >, polybori::groebner::GroebnerStrategy {lvalue}, int, double) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
print_ring_info(...)
C++ signature:
print_ring_info(void) -> void*
random_set(...)
C++ signature:
random_set(polybori::BooleMonomial, unsigned int) -> polybori::BooleSet
recursively_insert(...)
C++ signature:
recursively_insert(polybori::CCuddNavigator, int, polybori::BooleSet) -> polybori::BooleSet
set_variable_name(...)
C++ signature:
set_variable_name(int, char const*) -> void*
spoly(...)
Compute s-Polynomial between two Polynomials
C++ signature:
    spoly(polybori::BoolePolynomial, polybori::BoolePolynomial) -> polybori::BoolePolynomial
test_iterate_lex(...)
C++ signature:
test_iterate_lex(polybori::BoolePolynomial {lvalue}) -> unsigned long
test_iterate_ordered(...)
C++ signature:
test_iterate_ordered(polybori::BoolePolynomial {lvalue}) -> unsigned long
test_iterate_reference_ordered(...)
C++ signature:
test_iterate_reference_ordered(polybori::BoolePolynomial {lvalue}) -> unsigned long
testvalidstrat(...)
C++ signature:
testvalidstrat(polybori::groebner::GroebnerStrategy) -> void*
top_index(...)
C++ signature:
top_index(polybori::BooleSet) -> int
translate_indices(...)
C++ signature:
translate_indices(polybori::BoolePolynomial, std::vector<int, std::allocator<int> >) -> polybori::BoolePolynomial
variety_lex_groebner_basis(...)
C++ signature:
variety_lex_groebner_basis(polybori::BooleSet, polybori::BooleMonomial) -> std::vector<polybori::BoolePolynomial, std::allocator<polybori::BoolePolynomial> >
variety_lex_leading_terms(...)
C++ signature:
variety_lex_leading_terms(polybori::BooleSet, polybori::BooleMonomial) -> polybori::BooleSet
zero(...)
Constant zero of the active ring
C++ signature:
    zero(void) -> polybori::CDDInterface<polybori::CCuddZDD>