Classes | |
class | bdd_allocator |
Manage ranges of variables. More... | |
class | bdd_dict |
Map BDD variables to formulae. More... | |
struct | bdd_less_than |
Comparison functor for BDDs. More... | |
class | emptiness_check |
Check whether the language of an automate is empty. More... | |
struct | emptiness_check::connected_component |
struct | emptiness_check::connected_component_set |
struct | magic_search |
Emptiness check on spot::tgba_tba_proxy automata using the Magic Search algorithm. More... | |
struct | magic_search::magic |
Records whether a state has be seen with the magic bit on or off. More... | |
struct | magic_search::magic_state |
A state for the spot::magic_search algorithm. More... | |
class | minato_isop |
Generate an irredundant sum-of-products (ISOP) form of a BDD function. More... | |
struct | minato_isop::local_vars |
Internal variables for minato_isop. More... | |
struct | ptr_hash |
A hash function for pointers. More... | |
class | state |
Abstract class for states. More... | |
class | state_bdd |
A state whose representation is a BDD. More... | |
class | state_explicit |
States used by spot::tgba_explicit. More... | |
class | state_product |
A state for spot::tgba_product. More... | |
struct | state_ptr_equal |
An Equivalence Relation for state* . More... | |
struct | state_ptr_hash |
Hash Function for state* . More... | |
struct | state_ptr_less_than |
Strict Weak Ordering for state* . More... | |
struct | string_hash |
A hash function for strings. More... | |
class | tgba |
A Transition-based Generalized Büchi Automaton. More... | |
class | tgba_bdd_concrete |
A concrete spot::tgba implemented using BDDs. More... | |
class | tgba_bdd_concrete_factory |
Helper class to build a spot::tgba_bdd_concrete object. More... | |
struct | tgba_bdd_core_data |
Core data for a TGBA encoded using BDDs. More... | |
class | tgba_bdd_factory |
Abstract class for spot::tgba_bdd_concrete factories. More... | |
class | tgba_explicit |
Explicit representation of a spot::tgba. More... | |
struct | tgba_explicit::transition |
Explicit transitions (used by spot::tgba_explicit). More... | |
class | tgba_explicit_succ_iterator |
Successor iterators used by spot::tgba_explicit. More... | |
class | tgba_product |
A lazy product. (States are computed on the fly.). More... | |
class | tgba_reachable_iterator |
Iterate over all reachable states of a spot::tgba. More... | |
class | tgba_reachable_iterator_breadth_first |
An implementation of spot::tgba_reachable_iterator that browses states breadth first. More... | |
class | tgba_reachable_iterator_depth_first |
An implementation of spot::tgba_reachable_iterator that browses states depth first. More... | |
class | tgba_succ_iterator |
Iterate over the successors of a state. More... | |
class | tgba_succ_iterator_concrete |
A concrete iterator over successors of a TGBA state. More... | |
class | tgba_succ_iterator_product |
Iterate over the successors of a product computed on the fly. More... | |
class | tgba_tba_proxy |
Degeneralize a spot::tgba on the fly. More... | |
Typedefs | |
typedef std::pair< yy::Location, std::string > | tgba_parse_error |
A parse diagnostic with its location. | |
typedef std::list< tgba_parse_error > | tgba_parse_error_list |
A list of parser diagnostics, as filled by parse. | |
Functions | |
const char * | version () |
Return Spot's version. | |
std::ostream & | bdd_print_sat (std::ostream &os, const bdd_dict *dict, bdd b) |
Print a BDD as a list of literals. | |
std::string | bdd_format_sat (const bdd_dict *dict, bdd b) |
Format a BDD as a list of literals. | |
std::ostream & | bdd_print_acc (std::ostream &os, const bdd_dict *dict, bdd b) |
Print a BDD as a list of acceptance conditions. | |
std::ostream & | bdd_print_accset (std::ostream &os, const bdd_dict *dict, bdd b) |
Print a BDD as a set of acceptance conditions. | |
std::ostream & | bdd_print_set (std::ostream &os, const bdd_dict *dict, bdd b) |
Print a BDD as a set. | |
std::string | bdd_format_set (const bdd_dict *dict, bdd b) |
Format a BDD as a set. | |
std::ostream & | bdd_print_formula (std::ostream &os, const bdd_dict *dict, bdd b) |
Print a BDD as a formula. | |
std::string | bdd_format_formula (const bdd_dict *dict, bdd b) |
Format a BDD as a formula. | |
std::ostream & | bdd_print_dot (std::ostream &os, const bdd_dict *dict, bdd b) |
Print a BDD as a diagram in dotty format. | |
std::ostream & | bdd_print_table (std::ostream &os, const bdd_dict *dict, bdd b) |
Print a BDD as a table. | |
bdd | formula_to_bdd (const ltl::formula *f, bdd_dict *d, void *for_me) |
const ltl::formula * | bdd_to_formula (bdd f, const bdd_dict *d) |
tgba_bdd_concrete * | product (const tgba_bdd_concrete *left, const tgba_bdd_concrete *right) |
Multiplies two tgba::tgba_bdd_concrete automata. | |
std::ostream & | dotty_reachable (std::ostream &os, const tgba *g) |
Print reachable states in dot format. | |
tgba_explicit * | tgba_dupexp_bfs (const tgba *aut) |
tgba_explicit * | tgba_dupexp_dfs (const tgba *aut) |
std::ostream & | lbtt_reachable (std::ostream &os, const tgba *g) |
Print reachable states in LBTT format. | |
tgba_explicit * | ltl_to_tgba_fm (const ltl::formula *f, bdd_dict *dict) |
Build a spot::tgba_explicit* from an LTL formula. | |
tgba_bdd_concrete * | ltl_to_tgba_lacim (const ltl::formula *f, bdd_dict *dict) |
std::ostream & | tgba_save_reachable (std::ostream &os, const tgba *g) |
Save reachable states in text format. | |
tgba_explicit * | tgba_parse (const std::string &filename, tgba_parse_error_list &error_list, bdd_dict *dict, ltl::environment &env=ltl::default_environment::instance(), bool debug=false) |
Build a spot::tgba_explicit from a text file. | |
bool | format_tgba_parse_errors (std::ostream &os, tgba_parse_error_list &error_list) |
Format diagnostics produced by spot::tgba_parse. |
|
A parse diagnostic with its location.
|
|
A list of parser diagnostics, as filled by parse.
|
|
Format a BDD as a formula.
|
|
Format a BDD as a list of literals. This assumes that b is a conjunction of literals.
|
|
Format a BDD as a set.
|
|
Print a BDD as a list of acceptance conditions. This is used when saving a TGBA.
|
|
Print a BDD as a set of acceptance conditions. This is used when saving a TGBA.
|
|
Print a BDD as a diagram in dotty format.
|
|
Print a BDD as a formula.
|
|
Print a BDD as a list of literals. This assumes that b is a conjunction of literals.
|
|
Print a BDD as a set.
|
|
Print a BDD as a table.
|
|
|
|
Print reachable states in dot format.
|
|
Format diagnostics produced by spot::tgba_parse.
|
|
|
|
Print reachable states in LBTT format. Note that LBTT expects an automaton with transition labeled by propositional formulae, and generalized Büchi acceptance conditions on states. This is unlike our spot::tgba automata which put both generalized acceptance conditions and propositional formulae) on transitions.
This algorithm will therefore produce an automata where acceptance conditions have been moved from each transition to previous state. In the worst case, doing so will multiply the number of states and transitions of the automata by
|
|
Build a spot::tgba_explicit* from an LTL formula. This is based on the following paper. @InProceedings{couvreur.99.fm, author = {Jean-Michel Couvreur}, title = {On-the-fly Verification of Temporal Logic}, pages = {253--271}, editor = {Jeannette M. Wing and Jim Woodcock and Jim Davies}, booktitle = {Proceedings of the World Congress on Formal Methods in the Development of Computing Systems (FM'99)}, publisher = {Springer-Verlag}, series = {Lecture Notes in Computer Science}, volume = {1708}, year = {1999}, address = {Toulouse, France}, month = {September}, isbn = {3-540-66587-0} } |
|
Build a spot::tgba_bdd_concrete from an LTL formula. This is based on the following paper. @InProceedings{ couvreur.00.lacim, author = {Jean-Michel Couvreur}, title = {Un point de vue symbolique sur la logique temporelle lin{\'e}aire}, booktitle = {Actes du Colloque LaCIM 2000}, month = {August}, year = {2000}, pages = {131--140}, volume = {27}, series = {Publications du LaCIM}, publisher = {Universit{\'e} du Qu{\'e}bec {\`a} Montr{\'e}al}, editor = {Pierre Leroux} } |
|
Multiplies two tgba::tgba_bdd_concrete automata. This function build the resulting product, as another tgba::tgba_bdd_concrete automaton. |
|
Build an explicit automata from all states of aut, numbering states in bread first order as they are processed. |
|
Build an explicit automata from all states of aut, numbering states in depth first order as they are processed. |
|
Build a spot::tgba_explicit from a text file.
|
|
Save reachable states in text format.
|
|
Return Spot's version.
|