Classes |
class | fair_kripke_succ_iterator |
| Iterator code for a Fair Kripke structure.This iterator can be used to simplify the writing of an iterator on a Fair Kripke structure (or lookalike). More...
|
class | fair_kripke |
| Interface for a Fair Kripke structure.A Kripke structure is a graph in which each node (=state) is labeled by a conjunction of atomic proposition, and a set of acceptance conditions. More...
|
class | kripke_succ_iterator |
| Iterator code for Kripke structureThis iterator can be used to simplify the writing of an iterator on a Kripke structure (or lookalike). More...
|
class | kripke |
| Interface for a Kripke structureA Kripke structure is a graph in which each node (=state) is labeled by a conjunction of atomic proposition. More...
|
class | state_kripke |
| Concrete class for kripke states. More...
|
class | kripke_explicit_succ_iterator |
| Implement iterator pattern on successor of a state_kripke. More...
|
class | kripke_explicit |
| Kripke Structure. More...
|
class | acc_compl |
| Helper class to convert acceptance conditions into promises. More...
|
class | acceptance_convertor |
| Help class to convert between acceptance conditions to other BDD formats. More...
|
class | bdd_allocator |
| Manage ranges of variables. More...
|
struct | bdd_less_than |
| Comparison functor for BDDs. More...
|
struct | bdd_hash |
| Hash functor for BDDs. More...
|
class | fixed_size_pool |
| A fixed-size memory pool implementation. More...
|
class | printable |
class | printable_value |
class | printable_id |
| The default callback simply writes "%c". More...
|
class | printable_percent |
| Called by default for "%%" and "%\0". More...
|
class | formater |
class | free_list |
| Manage list of free integers. More...
|
struct | ptr_hash |
| A hash function for pointers. More...
|
struct | identity_hash |
| A hash function that returns identity. More...
|
struct | char_ptr_less_than |
| Strict Weak Ordering for char* .This is meant to be used as a comparison functor for STL map whose key are of type const char* . More...
|
class | minato_isop |
| Generate an irredundant sum-of-products (ISOP) form of a BDD function.This algorithm implements a derecursived version the Minato-Morreale algorithm presented in the following paper. More...
|
class | loopless_modular_mixed_radix_gray_code |
| Loopless modular mixed radix Gray code iteration.This class is based on the loopless modular mixed radix gray code algorithm described in exercise 77 of "The Art of Computer
Programming", Pre-Fascicle 2A (Draft of section 7.2.1.1: generating all n-tuples) by Donald E. Knuth. More...
|
class | multiple_size_pool |
| A multiple-size memory pool implementation. More...
|
class | option_map |
| Manage a map of options.Each option is defined by a string and is associated to an integer value. More...
|
class | barand |
| Compute pseudo-random integer value between 0 and n included, following a binomial distribution for probability p. More...
|
struct | time_info |
| A structure to record elapsed time in clock ticks. More...
|
class | timer |
| A timekeeper that accumulate interval of time. More...
|
class | timer_map |
| A map of timer, where each timer has a name. More...
|
class | unique_ptr |
| Take ownership of a pointer at its construction, and destroy it at the end of the scope. More...
|
class | explicit_state_conjunction |
| Basic implementation of saba_state_conjunction.This class provides a basic implementation to iterate over a conjunction of states of a saba. More...
|
class | saba |
| A State-based Alternating (Generalized) Büchi Automaton.Browsing such automaton can be achieved using two functions: get_init_state , and succ_iter . The former returns the initial state while the latter lists the successor states of any state. More...
|
class | saba_complement_tgba |
| Complement a TGBA and produce a SABA.The original TGBA is transformed into a States-based Büchi Automaton. More...
|
class | saba_state |
| Abstract class for saba states. More...
|
struct | saba_state_ptr_less_than |
| Strict Weak Ordering for saba_state* .This is meant to be used as a comparison functor for STL map whose key are of type saba_state* . More...
|
struct | saba_state_ptr_equal |
| An Equivalence Relation for saba_state* .This is meant to be used as a comparison functor for Sgi hash_map whose key are of type saba_state* . More...
|
struct | saba_state_ptr_hash |
| Hash Function for saba_state* .This is meant to be used as a hash functor for Sgi's hash_map whose key are of type saba_state* . More...
|
struct | saba_state_shared_ptr_less_than |
| Strict Weak Ordering for shared_saba_state (shared_ptr<const saba_state*>).This is meant to be used as a comparison functor for STL map whose key are of type shared_saba_state . More...
|
struct | saba_state_shared_ptr_equal |
| An Equivalence Relation for shared_saba_state (shared_ptr<const saba_state*>).This is meant to be used as a comparison functor for Sgi hash_map whose key are of type shared_saba_state . More...
|
struct | saba_state_shared_ptr_hash |
| Hash Function for shared_saba_state (shared_ptr<const saba_state*>).This is meant to be used as a hash functor for Sgi's hash_map whose key are of type shared_saba_state . More...
|
class | saba_state_conjunction |
| Iterate over a conjunction of saba_state.This class provides the basic functionalities required to iterate over a conjunction of states of a saba. More...
|
class | saba_succ_iterator |
| Iterate over the successors of a saba_state.This class provides the basic functionalities required to iterate over the successors of a state of a saba. Since transitions of an alternating automaton are defined as a boolean function with conjunctions (universal) and disjunctions (non-deterministic),. More...
|
class | saba_reachable_iterator |
| Iterate over all reachable states of a spot::saba. More...
|
class | saba_reachable_iterator_depth_first |
| An implementation of spot::saba_reachable_iterator that browses states depth first. More...
|
class | saba_reachable_iterator_breadth_first |
| An implementation of spot::saba_reachable_iterator that browses states breadth first. More...
|
class | ta |
| A Testing Automaton.The Testing Automata (TA) were introduced by Henri Hansen, Wojciech Penczek and Antti Valmari in "Stuttering-insensitive automata for on-the-fly detection of livelock
properties" In Proc. of FMICSÕ02, vol. 66(2) of Electronic Notes in Theoretical Computer Science.Elsevier. More...
|
class | ta_succ_iterator |
| Iterate over the successors of a state.This class provides the basic functionalities required to iterate over the successors of a state, as well as querying transition labels. Because transitions are never explicitely encoded, labels (conditions and acceptance conditions) can only be queried while iterating over the successors. More...
|
class | scc_stack_ta |
class | ta_explicit |
class | state_ta_explicit |
class | ta_explicit_succ_iterator |
| Successor iterators used by spot::ta_explicit. More...
|
class | state_ta_product |
| A state for spot::ta_product.This state is in fact a pair of state: the state from the TA automaton and that of Kripke structure. More...
|
class | ta_succ_iterator_product |
| Iterate over the successors of a product computed on the fly. More...
|
class | ta_product |
| A lazy product between a Testing automaton and a Kripke structure. (States are computed on the fly.) More...
|
class | ta_succ_iterator_product_by_changeset |
class | tgta |
| A Transition-based Generalized Testing Automaton (TGTA).Transition-based Generalized Testing Automaton (TGTA) is a new kind of automaton that combines features from both TA and TGBA. From TA, we take the idea of labeling transitions with changesets, however we remove the use of livelock-acceptance (because it may require a two-pass emptiness check), and the implicit stuttering. From TGBA, we inherit the use of transition-based generalized acceptance conditions. The resulting Chimera, which we call {Transition-based Generalized Testing Automaton} (TGTA), accepts only stuttering-insensitive languages like TA, and inherits advantages from both TA and TGBA: it has a simple one-pass emptiness-check procedure (the same as algorithm the one for TGBA), and can benefit from reductions based on the stuttering of the properties pretty much like a TA. Livelock acceptance states, which are no longer supported are emulated using states with a Büchi accepting self-loop labeled by empty changeset. More...
|
class | tgta_explicit |
class | tgta_product |
| A lazy product. (States are computed on the fly.) More...
|
class | tgta_succ_iterator_product |
| Iterate over the successors of a product computed on the fly. More...
|
class | ta_check |
| An implementation of the emptiness-check algorithm for a product between a TA and a Kripke structure. More...
|
class | ta_reachable_iterator |
| Iterate over all reachable states of a spot::ta. More...
|
class | ta_reachable_iterator_depth_first |
| An implementation of spot::ta_reachable_iterator that browses states depth first. More...
|
class | ta_reachable_iterator_breadth_first |
| An implementation of spot::ta_reachable_iterator that browses states breadth first. More...
|
struct | ta_statistics |
class | bdd_dict |
| Map BDD variables to formulae. More...
|
class | future_conditions_collector |
| Wrap a tgba to offer information about upcoming conditions.This class is a spot::tgba wrapper that simply add a new method, future_conditions(), to any spot::tgba. More...
|
class | sba |
| A State-based Generalized Büchi Automaton.An SBA is a TGBA in which the outgoing transitions of a state are either all accepting (in which case the source state is said "accepting"(, or all non-accepting. More...
|
class | state |
| Abstract class for states. More...
|
struct | state_ptr_less_than |
| Strict Weak Ordering for state* .This is meant to be used as a comparison functor for STL map whose key are of type state* . More...
|
struct | state_ptr_equal |
| An Equivalence Relation for state* .This is meant to be used as a comparison functor for Sgi hash_map whose key are of type state* . More...
|
struct | state_ptr_hash |
| Hash Function for state* .This is meant to be used as a hash functor for Sgi's hash_map whose key are of type state* . More...
|
struct | state_shared_ptr_less_than |
| Strict Weak Ordering for shared_state (shared_ptr<const state*>).This is meant to be used as a comparison functor for STL map whose key are of type shared_state . More...
|
struct | state_shared_ptr_equal |
| An Equivalence Relation for shared_state (shared_ptr<const state*>).This is meant to be used as a comparison functor for Sgi hash_map whose key are of type shared_state . More...
|
struct | state_shared_ptr_hash |
| Hash Function for shared_state (shared_ptr<const state*>).This is meant to be used as a hash functor for Sgi's hash_map whose key are of type shared_state . More...
|
class | state_bdd |
class | tgba_succ_iterator |
| Iterate over the successors of a state.This class provides the basic functionalities required to iterate over the successors of a state, as well as querying transition labels. Because transitions are never explicitely encoded, labels (conditions and acceptance conditions) can only be queried while iterating over the successors. More...
|
class | tgba_succ_iterator_concrete |
class | taa_tgba |
| A self-loop Transition-based Alternating Automaton (TAA) which is seen as a TGBA (abstract class, see below). More...
|
class | state_set |
| Set of states deriving from spot::state. More...
|
class | taa_succ_iterator |
class | taa_tgba_labelled |
class | taa_tgba_string |
class | taa_tgba_formula |
class | tgba |
| A Transition-based Generalized Büchi Automaton.The acronym TGBA (Transition-based Generalized Büchi Automaton) was coined by Dimitra Giannakopoulou and Flavio Lerda in "From States to Transitions: Improving Translation of LTL
Formulae to Büchi Automata". (FORTE'02) 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...
|
struct | destroy_key |
struct | destroy_key< const ltl::formula * > |
class | state_explicit |
class | state_explicit_number |
class | state_explicit_string |
class | state_explicit_formula |
class | tgba_explicit_succ_iterator |
class | explicit_graph |
class | tgba_explicit |
class | sba_explicit |
class | explicit_conf |
class | explicit_conf< graph, state_explicit_string > |
class | explicit_conf< graph, state_explicit_formula > |
class | bdd_ordered |
class | tgba_kv_complement |
| Build a complemented automaton.The construction comes from: More...
|
class | state_product |
| A state for spot::tgba_product.This state is in fact a pair of state: the state from the left automaton and that of the right. More...
|
class | tgba_product |
| A lazy product. (States are computed on the fly.) More...
|
class | tgba_product_init |
| A lazy product with different initial states. More...
|
class | tgba_safra_complement |
| Build a complemented automaton.It creates an automaton that recognizes the negated language of aut. More...
|
class | tgba_scc |
| Wrap a tgba to offer information about strongly connected components.This class is a spot::tgba wrapper that simply add a new method scc_of_state() to retrieve the number of a SCC a state belongs to. More...
|
class | tgba_sgba_proxy |
| Change the labeling-mode of spot::tgba on the fly, producing a state-based generalized Büchi automaton.This class acts as a proxy in front of a spot::tgba, that should label on states on-the-fly. The result is still a spot::tgba, but acceptances conditions are also on states. More...
|
class | tgba_tba_proxy |
| Degeneralize a spot::tgba on the fly, producing a TBA.This class acts as a proxy in front of a spot::tgba, that should be degeneralized on the fly. The result is still a spot::tgba, but it will always have exactly one acceptance condition so it could be called TBA (without the G). More...
|
class | tgba_sba_proxy |
| Degeneralize a spot::tgba on the fly, producing an SBA.This class acts as a proxy in front of a spot::tgba, that should be degeneralized on the fly. More...
|
class | state_union |
| A state for spot::tgba_union.This state is in fact a pair. If the first member equals 0 and the second is different from 0, the state belongs to the left automaton. If the first member is different from 0 and the second is 0, the state belongs to the right automaton. If both members are 0, the state is the initial state. More...
|
class | tgba_succ_iterator_union |
| Iterate over the successors of an union computed on the fly. More...
|
class | tgba_union |
| A lazy union. (States are computed on the fly.) More...
|
class | bfs_steps |
| Make a BFS in a spot::tgba to compute a tgba_run::steps.This class should be used to compute the shortest path between a state of a spot::tgba and the first transition or state that matches some conditions. More...
|
struct | sccs_set |
class | enumerate_cycles |
| Enumerate elementary cycles in a SCC. More...
|
class | dotty_decorator |
| Choose state and link styles for spot::dotty_reachable. More...
|
class | emptiness_check_result |
| The result of an emptiness check. More...
|
class | emptiness_check |
| Common interface to emptiness check algorithms. More...
|
class | emptiness_check_instantiator |
struct | tgba_run |
| An accepted run, for a tgba. More...
|
struct | unsigned_statistics |
class | unsigned_statistics_copy |
| comparable statistics More...
|
class | ec_statistics |
| Emptiness-check statistics. More...
|
class | ars_statistics |
| Accepting Run Search statistics. More...
|
class | acss_statistics |
| Accepting Cycle Search Space statistics. More...
|
class | couvreur99_check_result |
| Compute a counter example from a spot::couvreur99_check_status. More...
|
class | explicit_connected_component |
| An SCC storing all its states explicitly. More...
|
class | connected_component_hash_set |
class | explicit_connected_component_factory |
| Abstract factory for explicit_connected_component. More...
|
class | connected_component_hash_set_factory |
| Factory for connected_component_hash_set. More...
|
class | couvreur99_check |
| An implementation of the Couvreur99 emptiness-check algorithm. More...
|
class | couvreur99_check_shy |
| A version of spot::couvreur99_check that tries to visit known states first. More...
|
class | numbered_state_heap_const_iterator |
| Iterator on numbered_state_heap objects. More...
|
class | numbered_state_heap |
| Keep track of a large quantity of indexed states. More...
|
class | numbered_state_heap_factory |
| Abstract factory for numbered_state_heap. More...
|
class | numbered_state_heap_hash_map |
| A straightforward implementation of numbered_state_heap with a hash map. More...
|
class | numbered_state_heap_hash_map_factory |
| Factory for numbered_state_heap_hash_map. More...
|
class | scc_stack |
class | couvreur99_check_status |
| The status of the emptiness-check on success. More...
|
class | postprocessor |
| Wrap TGBA/BA/Monitor post-processing algorithms in an easy interface. More...
|
struct | power_map |
class | tgba_reachable_iterator |
| Iterate over all reachable states of a spot::tgba. More...
|
class | tgba_reachable_iterator_depth_first |
| An implementation of spot::tgba_reachable_iterator that browses states depth first. More...
|
class | tgba_reachable_iterator_breadth_first |
| An implementation of spot::tgba_reachable_iterator that browses states breadth first. More...
|
class | tgba_run_dotty_decorator |
| Highlight a spot::tgba_run on a spot::tgba.An instance of this class can be passed to spot::dotty_reachable. More...
|
struct | scc_stats |
class | scc_map |
| Build a map of Strongly Connected components in in a TGBA. More...
|
struct | tgba_statistics |
struct | tgba_sub_statistics |
class | printable_formula |
class | stat_printer |
| prints various statistics about a TGBA More...
|
class | weight |
| Manage for a given automaton a vector of counter indexed by its acceptance condition. More...
|
class | gspn_exception |
| An exception used to forward GSPN errors. More...
|
class | gspn_interface |
class | gspn_ssp_interface |
Functions |
std::ostream & | kripke_save_reachable (std::ostream &os, const kripke *k) |
| Save the reachable part of Kripke structure in text format.
|
std::ostream & | kripke_save_reachable_renumbered (std::ostream &os, const kripke *k) |
| Save the reachable part of Kripke structure in text format.
|
kripke_explicit * | kripke_parse (const std::string &name, kripke_parse_error_list &error_list, bdd_dict *dict, ltl::environment &env=ltl::default_environment::instance(), bool debug=false) |
bool | format_kripke_parse_errors (std::ostream &os, const std::string &filename, kripke_parse_error_list &error_list) |
| Format diagnostics produced by spot::kripke_parse.
|
bool | is_bare_word (const char *str) |
std::string | quote_unless_bare_word (const std::string &str) |
| Double-quote words that are not bare.
|
bdd | compute_all_acceptance_conditions (bdd neg_acceptance_conditions) |
| Compute all acceptance conditions from all neg acceptance conditions.
|
bdd | compute_neg_acceptance_conditions (bdd all_acceptance_conditions) |
| Compute neg acceptance conditions from all acceptance conditions.
|
std::ostream & | escape_str (std::ostream &os, const std::string &str) |
| Escape characters " , \ , and \n in str.
|
std::string | escape_str (const std::string &str) |
| Escape characters " , \ , and \n in str.
|
void | trim (std::string &str) |
| Remove spaces at the front and back of str.
|
size_t | wang32_hash (size_t key) |
| Thomas Wang's 32 bit hash function.
|
size_t | knuth32_hash (size_t key) |
| Knuth's Multiplicative hash function.
|
void | int_array_array_compress2 (const int *array, size_t n, int *dest, size_t &dest_size) |
| Compress an int array of size n into a int array.
|
void | int_array_array_decompress2 (const int *array, size_t array_size, int *res, size_t size) |
| Uncompress an int array of size array_size into a int array of size size.
|
void | int_vector_vector_compress (const std::vector< int > &input, std::vector< unsigned int > &output) |
| Compress an int vector into a vector of unsigned int.
|
void | int_vector_vector_decompress (const std::vector< unsigned int > &array, std::vector< int > &output, size_t size) |
| Uncompress a vector of unsigned int into a vector of size size.
|
const std::vector< unsigned int > * | int_array_vector_compress (const int *array, size_t n) |
| Compress an int array if size n into a vector of unsigned int.
|
void | int_vector_array_decompress (const std::vector< unsigned int > *array, int *res, size_t size) |
| Uncompress a vector of unsigned int into an int array of size size.
|
void | int_array_array_compress (const int *array, size_t n, int *dest, size_t &dest_size) |
| Compress an int array of size n into a int array.
|
void | int_array_array_decompress (const int *array, size_t array_size, int *res, size_t size) |
| Uncompress an int array of size array_size into a int array of size size.
|
int | memusage () |
| Total number of pages in use by the program.
|
void | srand (unsigned int seed) |
| Reset the seed of the pseudo-random number generator.
|
int | rrand (int min, int max) |
| Compute a pseudo-random integer value between min and max included.
|
int | mrand (int max) |
| Compute a pseudo-random integer value between 0 and max-1 included.
|
double | drand () |
| Compute a pseudo-random double value between 0.0 and 1.0 (1.0 excluded).
|
double | nrand () |
| Compute a pseudo-random double value following a standard normal distribution. (Odeh & Evans)
|
double | bmrand () |
| Compute a pseudo-random double value following a standard normal distribution. (Box-Muller)
|
int | prand (double p) |
| Return a pseudo-random positive integer value following a Poisson distribution with parameter p.
|
template<typename T > |
unique_ptr< T > | make_unique (T *ptr) |
| Change a pointer into a unique_ptr.
|
const char * | version () |
| Return Spot's version.
|
tgba_explicit_string * | neverclaim_parse (const std::string &filename, neverclaim_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 Spin never claim file.
|
bool | format_neverclaim_parse_errors (std::ostream &os, const std::string &filename, neverclaim_parse_error_list &error_list) |
| Format diagnostics produced by spot::neverclaim_parse.
|
std::ostream & | saba_dotty_reachable (std::ostream &os, const saba *g) |
| Print reachable states in dot format.
|
std::ostream & | dotty_reachable (std::ostream &os, const ta *a) |
ta * | minimize_ta (const ta *ta_) |
| Construct a simplified TA by merging bisimilar states.
|
tgta_explicit * | minimize_tgta (const tgta_explicit *tgta_) |
| Construct a simplified TGTA by merging bisimilar states.
|
std::set< const state * > | get_states_set (const ta *t) |
| Compute states set for an automaton.
|
ta_statistics | stats_reachable (const ta *t) |
| Compute statistics for an automaton.
|
ta_explicit * | tgba_to_ta (const tgba *tgba_to_convert, bdd atomic_propositions_set, bool degeneralized=true, bool artificial_initial_state_mode=true, bool single_pass_emptiness_check=false, bool artificial_livelock_state_mode=false) |
| Build a spot::ta_explicit* (TA) from an LTL formula.This is based on the following paper.
|
tgta_explicit * | tgba_to_tgta (const tgba *tgba_to_convert, bdd atomic_propositions_set) |
| Build a spot::tgta_explicit* (TGTA) from an LTL formula.
|
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.
|
void | enable_utf8 () |
| Enable UTF-8 output for bdd printers.
|
bdd | formula_to_bdd (const ltl::formula *f, bdd_dict *d, void *for_me) |
| Convert a Boolean formula into a BDD.
|
const ltl::formula * | bdd_to_formula (bdd f, const bdd_dict *d) |
| Convert a BDD into a formula.
|
void | shared_state_deleter (state *s) |
tgba_bdd_concrete * | product (const tgba_bdd_concrete *left, const tgba_bdd_concrete *right) |
| Multiplies two spot::tgba_bdd_concrete automata.This function builds the resulting product as another spot::tgba_bdd_concrete automaton.
|
void | display_safra (const tgba_safra_complement *a) |
| Produce a dot output of the Safra automaton associated to a.
|
tgba * | wdba_complement (const tgba *aut) |
| Complement a weak deterministic Büchi automaton.
|
std::vector< std::vector
< sccs_set * > > * | find_paths (tgba *a, const scc_map &m) |
unsigned | max_spanning_paths (std::vector< sccs_set * > *paths, scc_map &m) |
std::list< tgba * > | split_tgba (tgba *a, const scc_map &m, unsigned split_number) |
sba * | degeneralize (const tgba *a) |
| Degeneralize a spot::tgba into an equivalent sba with only one acceptance condition.
|
std::ostream & | dotty_reachable (std::ostream &os, const tgba *g, bool assume_sba=false, dotty_decorator *dd=0) |
| Print reachable states in dot format.If assume_sba is set, this assumes that the automaton is an SBA and use double elipse to mark accepting states.
|
tgba_explicit_number * | tgba_dupexp_bfs (const tgba *aut) |
| Build an explicit automata from all states of aut, numbering states in bread first order as they are processed.
|
tgba_explicit_number * | tgba_dupexp_dfs (const tgba *aut) |
| Build an explicit automata from all states of aut, numbering states in depth first order as they are processed.
|
tgba_bdd_concrete * | eltl_to_tgba_lacim (const ltl::formula *f, bdd_dict *dict) |
| Build a spot::tgba_bdd_concrete from an ELTL formula.This is based on the following paper.
|
std::ostream & | print_tgba_run (std::ostream &os, const tgba *a, const tgba_run *run) |
| Display a tgba_run.
|
tgba * | tgba_run_to_tgba (const tgba *a, const tgba_run *run) |
| Return an explicit_tgba corresponding to run (i.e. comparable states are merged).
|
emptiness_check * | couvreur99 (const tgba *a, option_map options=option_map(), const numbered_state_heap_factory *nshf=numbered_state_heap_hash_map_factory::instance()) |
| Check whether the language of an automate is empty.
|
emptiness_check * | explicit_gv04_check (const tgba *a, option_map o=option_map()) |
| Emptiness check based on Geldenhuys and Valmari's TACAS'04 paper.
|
unsigned | count_nondet_states (const tgba *aut) |
| Count the number of non-deterministic states in aut.
|
bool | is_deterministic (const tgba *aut) |
| Return true iff aut is deterministic.
|
bool | is_weak_scc (scc_map &map, unsigned scc) |
| Whether the SCC number scc in map is weak.
|
std::ostream & | lbtt_reachable (std::ostream &os, const tgba *g) |
| Print reachable states in LBTT format.
|
const tgba * | lbtt_parse (std::istream &is, std::string &error, bdd_dict *dict, ltl::environment &env=ltl::default_environment::instance(), ltl::environment &envacc=ltl::default_environment::instance()) |
| Read an automaton in LBTT's format.
|
taa_tgba * | ltl_to_taa (const ltl::formula *f, bdd_dict *dict, bool refined_rules=false) |
| Build a spot::taa* from an LTL formula.This is based on the following.
|
tgba_explicit_formula * | ltl_to_tgba_fm (const ltl::formula *f, bdd_dict *dict, bool exprop=false, bool symb_merge=true, bool branching_postponement=false, bool fair_loop_approx=false, const ltl::atomic_prop_set *unobs=0, ltl::ltl_simplifier *simplifier=0) |
| Build a spot::tgba_explicit* from an LTL formula.This is based on the following paper.
|
tgba_bdd_concrete * | ltl_to_tgba_lacim (const ltl::formula *f, bdd_dict *dict) |
| Build a spot::tgba_bdd_concrete from an LTL formula.This is based on the following paper.
|
emptiness_check * | explicit_magic_search (const tgba *a, option_map o=option_map()) |
| Returns an emptiness checker on the spot::tgba automaton a.
|
emptiness_check * | bit_state_hashing_magic_search (const tgba *a, size_t size, option_map o=option_map()) |
| Returns an emptiness checker on the spot::tgba automaton a.
|
emptiness_check * | magic_search (const tgba *a, option_map o=option_map()) |
| Wrapper for the two magic_search implementations.
|
sba_explicit_number * | minimize_monitor (const tgba *a) |
| Construct a minimal deterministic monitor.
|
sba_explicit_number * | minimize_wdba (const tgba *a) |
| Minimize a Büchi automaton in the WDBA class.
|
tgba * | minimize_obligation (const tgba *aut_f, const ltl::formula *f=0, const tgba *aut_neg_f=0, bool reject_bigger=false) |
| Minimize an automaton if it represents an obligation property.
|
std::ostream & | never_claim_reachable (std::ostream &os, const tgba *g, const ltl::formula *f=0, bool comments=false) |
| Print reachable states in Spin never claim format.
|
tgba_run * | project_tgba_run (const tgba *a_run, const tgba *a_proj, const tgba_run *run) |
| Project a tgba_run on a tgba.If a tgba_run has been generated on a product, or any other on-the-fly algorithm with tgba operands,.
|
tgba * | random_graph (int n, float d, const ltl::atomic_prop_set *ap, bdd_dict *dict, int n_acc=0, float a=0.1, float t=0.5, ltl::environment *env=<l::default_environment::instance()) |
| Construct a tgba randomly.
|
tgba_run * | reduce_run (const tgba *a, const tgba_run *org) |
| Reduce an accepting run.Return a run which is accepting for and that is no longer that org.
|
const tgba * | reduc_tgba_sim (const tgba *a, int opt=Reduce_All) |
| Simplify the automaton using a simulation relation.
|
bool | replay_tgba_run (std::ostream &os, const tgba *a, const tgba_run *run, bool debug=false) |
| Replay a tgba_run on a tgba.This is similar to print_tgba_run(), except that the run is actually replayed on the automaton while it is printed. Doing so makes it possible to display transition annotations (returned by spot::tgba::transition_annotation()). The output will stop if the run cannot be completed.
|
bool | is_guarantee_automaton (const tgba *aut, const scc_map *sm=0) |
| Whether an automaton represents a guarantee property.
|
bool | is_safety_mwdba (const tgba *aut) |
| Whether a minimized WDBA represents a safety property.
|
std::ostream & | tgba_save_reachable (std::ostream &os, const tgba *g) |
| Save reachable states in text format.
|
scc_stats | build_scc_stats (const tgba *a) |
scc_stats | build_scc_stats (const scc_map &m) |
std::ostream & | dump_scc_dot (const tgba *a, std::ostream &out, bool verbose=false) |
std::ostream & | dump_scc_dot (const scc_map &m, std::ostream &out, bool verbose=false) |
tgba * | scc_filter (const tgba *aut, bool remove_all_useless=false) |
| Prune unaccepting SCCs and remove superfluous acceptance conditions.
|
emptiness_check * | explicit_se05_search (const tgba *a, option_map o=option_map()) |
| Returns an emptiness check on the spot::tgba automaton a.
|
emptiness_check * | bit_state_hashing_se05_search (const tgba *a, size_t size, option_map o=option_map()) |
| Returns an emptiness checker on the spot::tgba automaton a.
|
emptiness_check * | se05 (const tgba *a, option_map o) |
| Wrapper for the two se05 implementations.
|
tgba * | simulation (const tgba *automaton) |
| Attempt to reduce the automaton by direct simulation.
|
tgba * | cosimulation (const tgba *automaton) |
| Attempt to reduce the automaton by reverse simulation.
|
tgba * | iterated_simulations (const tgba *automaton) |
| Iterate simulation() and cosimulation().
|
tgba_statistics | stats_reachable (const tgba *g) |
| Compute statistics for an automaton.
|
tgba_sub_statistics | sub_stats_reachable (const tgba *g) |
| Compute subended statistics for an automaton.
|
sba_explicit_number * | strip_acceptance (const tgba *a) |
| Duplicate automaton a, removing all acceptance sets.
|
emptiness_check * | explicit_tau03_search (const tgba *a, option_map o=option_map()) |
| Returns an emptiness checker on the spot::tgba automaton a.
|
emptiness_check * | explicit_tau03_opt_search (const tgba *a, option_map o=option_map()) |
| Returns an emptiness checker on the spot::tgba automaton a.
|
tgba_explicit_string * | tgba_parse (const std::string &filename, tgba_parse_error_list &error_list, bdd_dict *dict, ltl::environment &env=ltl::default_environment::instance(), ltl::environment &envacc=ltl::default_environment::instance(), bool debug=false) |
| Build a spot::tgba_explicit from a text file.
|
bool | format_tgba_parse_errors (std::ostream &os, const std::string &filename, tgba_parse_error_list &error_list) |
| Format diagnostics produced by spot::tgba_parse.
|
kripke * | load_dve2 (const std::string &file, bdd_dict *dict, const ltl::atomic_prop_set *to_observe, const ltl::formula *dead=ltl::constant::true_instance(), int compress=0, bool verbose=true) |
std::ostream & | operator<< (std::ostream &os, const gspn_exception &e) |
couvreur99_check * | couvreur99_check_ssp_semi (const tgba *ssp_automata) |
couvreur99_check * | couvreur99_check_ssp_shy_semi (const tgba *ssp_automata) |
couvreur99_check * | couvreur99_check_ssp_shy (const tgba *ssp_automata, bool stack_inclusion=true, bool double_inclusion=false, bool reversed_double_inclusion=false, bool no_decomp=false) |
|
tgba_explicit_number * | tgba_powerset (const tgba *aut, power_map &pm) |
| Build a deterministic automaton, ignoring acceptance conditions.This create a deterministic automaton that recognizes the same language as aut would if its acceptance conditions were ignored. This is the classical powerset algorithm.
|
tgba_explicit_number * | tgba_powerset (const tgba *aut) |