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 |
class | gspn_eesrg_interface |
class | gspn_environment |
class | gspn_exeption |
An exeption used to forward GSPN errors. More... | |
class | gspn_interface |
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... | |
struct | tgba_statistics |
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 | |
std::ostream & | escape_str (std::ostream &os, const std::string &str) |
Escape " and \ characters in str. | |
std::string | escape_str (const std::string &str) |
Escape " and \ characters in str. | |
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::string | bdd_format_accset (const bdd_dict *dict, bdd b) |
Format 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. | |
std::ostream & | nonacceptant_lbtt_reachable (std::ostream &os, const tgba *g) |
Print an LBTT automaton for statistics. | |
tgba_explicit * | ltl_to_tgba_fm (const ltl::formula *f, bdd_dict *dict, bool exprop=false, bool symb_merge=true) |
Build a spot::tgba_explicit* from an LTL formula. | |
tgba_bdd_concrete * | ltl_to_tgba_lacim (const ltl::formula *f, bdd_dict *dict) |
tgba_explicit * | tgba_powerset (const tgba *aut) |
Build a deterministic automaton, ignoring acceptance conditions. | |
std::ostream & | tgba_save_reachable (std::ostream &os, const tgba *g) |
Save reachable states in text format. | |
tgba_statistics | stats_reachable (const tgba *g) |
Compute statistics for an automata. | |
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. | |
std::ostream & | operator<< (std::ostream &os, const gspn_exeption &e) |
|
A parse diagnostic with its location.
|
|
A list of parser diagnostics, as filled by parse.
|
|
Format a BDD as a set of acceptance conditions. This is used when saving a TGBA.
|
|
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.
|
|
Escape " and \ characters in str.
|
|
Escape " and \ characters in str.
|
|
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 the 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} } If \a exprop is set, the algorithm will consider all properties combinations possible on each state, in an attempt to reduce the non-determinism. The automaton will have the same size as without this option, but because the transition will be more deterministic product automaton will be smaller (or, at worse, equal). If \a symb_merge is set to false, states with the same symbolic representation (these are equivalent formulae) will not be merged. |
|
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} } |
|
Print an LBTT automaton for statistics. Output g in LBTT's format but ignoring the acceptance conditions, of all its transitions. This produces an automaton that has the same size as g, and whose synchronized product with another automaton also has the same size. This will also declare as much acceptance conditions has there is in g (they will just be never used). The produced automaton will not recognize any word (unless g has no acceptance condition, in which case this function is a no-op). The produced automaton is useful to obtain accurate statistics from LBTT, without any size blow up of the automata. |
|
|
|
Multiplies two tgba::tgba_bdd_concrete automata. This function build the resulting product, as another tgba::tgba_bdd_concrete automaton. |
|
Compute statistics for an automata.
|
|
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.
|
|
Build a deterministic automaton, ignoring acceptance conditions. This create a deterministic automaton that recognize the same language as aut would if its acceptance conditions were ignored. This is the classical powerset algorithm. |
|
Save reachable states in text format.
|
|
Return Spot's version.
|