polybori
index
../../../../lib/python2.6/dist-packages/polybori/__init__.py

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-2008
 
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 http://arxiv.org/abs/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

 
Package Contents
       
PyPolyBoRi
aes
blocks
check_claims
custom
disttar
doxygen
dynamic (package)
gbcore
gbrefs
heuristics
interpolate
interred
ll
memusage
ncf
nf
partial
randompoly
simplebb
specialsets
statistics

 
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_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>

 
Data
        block_dlex = polybori.dynamic.PyPolyBoRi.OrderCode.block_dlex
block_dp_asc = polybori.dynamic.PyPolyBoRi.OrderCode.block_dp_asc
dlex = polybori.dynamic.PyPolyBoRi.OrderCode.dlex
dp_asc = polybori.dynamic.PyPolyBoRi.OrderCode.dp_asc
k = 4
lp = polybori.dynamic.PyPolyBoRi.OrderCode.lp
modules = {'StringIO': <module 'StringIO' from '/usr/lib/python2.6/StringIO.pyc'>, 'UserDict': <module 'UserDict' from '/usr/lib/python2.6/UserDict.pyc'>, '__builtin__': <module '__builtin__' (built-in)>, '__future__': <module '__future__' from '/usr/lib/python2.6/__future__.pyc'>, '__main__': <module '__main__' from 'doc/python/genpythondoc.py'>, '_abcoll': <module '_abcoll' from '/usr/lib/python2.6/_abcoll.pyc'>, '_codecs': <module '_codecs' (built-in)>, '_collections': <module '_collections' (built-in)>, '_random': <module '_random' (built-in)>, '_sre': <module '_sre' (built-in)>, ...}