spot
1.0
|
Namespaces | |
namespace | eltl |
namespace | ltl |
Classes | |
class | evtgba |
class | evtgba_iterator |
class | evtgba_explicit |
class | state_evtgba_explicit |
States used by spot::tgba_evtgba_explicit. More... | |
class | evtgba_product |
class | symbol |
class | rsymbol |
class | evtgba_reachable_iterator |
Iterate over all reachable states of a spot::evtgba. More... | |
class | evtgba_reachable_iterator_depth_first |
An implementation of spot::evtgba_reachable_iterator that browses states depth first. More... | |
class | evtgba_reachable_iterator_breadth_first |
An implementation of spot::evtgba_reachable_iterator that browses states breadth first. More... | |
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 |
Typedefs | |
typedef std::set< const symbol * > | symbol_set |
typedef std::set< rsymbol > | rsymbol_set |
typedef std::pair < evtgbayy::location, std::string > | evtgba_parse_error |
A parse diagnostic with its location. | |
typedef std::list < evtgba_parse_error > | evtgba_parse_error_list |
A list of parser diagnostics, as filled by parse. | |
typedef std::pair < kripkeyy::location, std::string > | kripke_parse_error |
A parse diagnostic with its location. | |
typedef std::list < kripke_parse_error > | kripke_parse_error_list |
A list of parser diagnostics, as filled by parse. | |
typedef std::pair < neverclaimyy::location, std::string > | neverclaim_parse_error |
A parse diagnostic with its location. | |
typedef std::list < neverclaim_parse_error > | neverclaim_parse_error_list |
A list of parser diagnostics, as filled by parse. | |
typedef boost::shared_ptr < const saba_state > | shared_saba_state |
typedef boost::shared_ptr < const state > | shared_state |
typedef explicit_conf < tgba_explicit < state_explicit_string > , state_explicit_string > | tgba_explicit_string |
typedef explicit_conf < tgba_explicit < state_explicit_formula > , state_explicit_formula > | tgba_explicit_formula |
typedef explicit_conf < tgba_explicit < state_explicit_number > , state_explicit_number > | tgba_explicit_number |
typedef explicit_conf < sba_explicit < state_explicit_string > , state_explicit_string > | sba_explicit_string |
typedef explicit_conf < sba_explicit < state_explicit_formula > , state_explicit_formula > | sba_explicit_formula |
typedef explicit_conf < sba_explicit < state_explicit_number > , state_explicit_number > | sba_explicit_number |
typedef std::vector< bdd_ordered > | acc_list_t |
typedef std::pair < tgbayy::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. | |
typedef Sgi::hash< std::string > | string_hash |
A hash function for strings. |
Enumerations | |
enum | reduce_tgba_options { Reduce_None = 0, Reduce_quotient_Dir_Sim = 1, Reduce_transition_Dir_Sim = 2, Reduce_quotient_Del_Sim = 4, Reduce_transition_Del_Sim = 8, Reduce_Scc = 16, Reduce_All = -1U } |
Options for reduce. More... |
Functions | |
std::ostream & | dotty_reachable (std::ostream &os, const evtgba *g) |
Print reachable states in dot format. | |
std::ostream & | evtgba_save_reachable (std::ostream &os, const evtgba *g) |
Save reachable states in text format. | |
evtgba_explicit * | tgba_to_evtgba (const tgba *a) |
Convert a tgba into an evtgba. | |
evtgba_explicit * | evtgba_parse (const std::string &filename, evtgba_parse_error_list &error_list, bool debug=false) |
Build a spot::evtgba_explicit from a text file. | |
bool | format_evtgba_parse_errors (std::ostream &os, const std::string &filename, evtgba_parse_error_list &error_list) |
Format diagnostics produced by spot::evtgba_parse. | |
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 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) |
typedef std::vector<bdd_ordered> spot::acc_list_t |
typedef std::pair<evtgbayy::location, std::string> spot::evtgba_parse_error |
A parse diagnostic with its location.
typedef std::list<evtgba_parse_error> spot::evtgba_parse_error_list |
A list of parser diagnostics, as filled by parse.
typedef std::pair<kripkeyy::location, std::string> spot::kripke_parse_error |
A parse diagnostic with its location.
typedef std::list<kripke_parse_error> spot::kripke_parse_error_list |
A list of parser diagnostics, as filled by parse.
typedef std::set<rsymbol> spot::rsymbol_set |
typedef explicit_conf<sba_explicit<state_explicit_formula>, state_explicit_formula> spot::sba_explicit_formula |
typedef explicit_conf<sba_explicit<state_explicit_number>, state_explicit_number> spot::sba_explicit_number |
typedef explicit_conf<sba_explicit<state_explicit_string>, state_explicit_string> spot::sba_explicit_string |
typedef boost::shared_ptr<const saba_state> spot::shared_saba_state |
typedef boost::shared_ptr<const state> spot::shared_state |
typedef std::set<const symbol*> spot::symbol_set |
typedef explicit_conf<tgba_explicit<state_explicit_formula>, state_explicit_formula> spot::tgba_explicit_formula |
typedef explicit_conf<tgba_explicit<state_explicit_number>, state_explicit_number> spot::tgba_explicit_number |
typedef explicit_conf<tgba_explicit<state_explicit_string>, state_explicit_string> spot::tgba_explicit_string |
std::string spot::bdd_format_accset | ( | const bdd_dict * | dict, |
bdd | b | ||
) |
Format a BDD as a set of acceptance conditions.
This is used when saving a TGBA.
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::string spot::bdd_format_formula | ( | const bdd_dict * | dict, |
bdd | b | ||
) |
Format a BDD as a formula.
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::string spot::bdd_format_sat | ( | const bdd_dict * | dict, |
bdd | b | ||
) |
Format a BDD as a list of literals.
This assumes that b is a conjunction of literals.
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::string spot::bdd_format_set | ( | const bdd_dict * | dict, |
bdd | b | ||
) |
Format a BDD as a set.
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::ostream& spot::bdd_print_acc | ( | std::ostream & | os, |
const bdd_dict * | dict, | ||
bdd | b | ||
) |
Print a BDD as a list of acceptance conditions.
This is used when saving a TGBA.
os | The output stream. |
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::ostream& spot::bdd_print_accset | ( | std::ostream & | os, |
const bdd_dict * | dict, | ||
bdd | b | ||
) |
Print a BDD as a set of acceptance conditions.
This is used when saving a TGBA.
os | The output stream. |
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::ostream& spot::bdd_print_dot | ( | std::ostream & | os, |
const bdd_dict * | dict, | ||
bdd | b | ||
) |
Print a BDD as a diagram in dotty format.
os | The output stream. |
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::ostream& spot::bdd_print_formula | ( | std::ostream & | os, |
const bdd_dict * | dict, | ||
bdd | b | ||
) |
Print a BDD as a formula.
os | The output stream. |
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::ostream& spot::bdd_print_sat | ( | std::ostream & | os, |
const bdd_dict * | dict, | ||
bdd | b | ||
) |
Print a BDD as a list of literals.
This assumes that b is a conjunction of literals.
os | The output stream. |
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::ostream& spot::bdd_print_set | ( | std::ostream & | os, |
const bdd_dict * | dict, | ||
bdd | b | ||
) |
Print a BDD as a set.
os | The output stream. |
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
std::ostream& spot::bdd_print_table | ( | std::ostream & | os, |
const bdd_dict * | dict, | ||
bdd | b | ||
) |
Print a BDD as a table.
os | The output stream. |
dict | The dictionary to use, to lookup variables. |
b | The BDD to print. |
const ltl::formula* spot::bdd_to_formula | ( | bdd | f, |
const bdd_dict * | d | ||
) |
Convert a BDD into a formula.
scc_stats spot::build_scc_stats | ( | const tgba * | a | ) |
scc_stats spot::build_scc_stats | ( | const scc_map & | m | ) |
bdd spot::compute_all_acceptance_conditions | ( | bdd | neg_acceptance_conditions | ) |
Compute all acceptance conditions from all neg acceptance conditions.
Referenced by spot::explicit_graph< State, tgba >::all_acceptance_conditions().
bdd spot::compute_neg_acceptance_conditions | ( | bdd | all_acceptance_conditions | ) |
Compute neg acceptance conditions from all acceptance conditions.
Referenced by spot::explicit_graph< State, tgba >::set_acceptance_conditions().
void spot::display_safra | ( | const tgba_safra_complement * | a | ) |
Produce a dot output of the Safra automaton associated to a.
a | The tgba_safra_complement with an intermediate Safra automaton to display |
std::ostream& spot::dotty_reachable | ( | std::ostream & | os, |
const evtgba * | g | ||
) |
Print reachable states in dot format.
std::ostream& spot::dotty_reachable | ( | std::ostream & | os, |
const ta * | a | ||
) |
std::ostream& spot::dump_scc_dot | ( | const tgba * | a, |
std::ostream & | out, | ||
bool | verbose = false |
||
) |
std::ostream& spot::dump_scc_dot | ( | const scc_map & | m, |
std::ostream & | out, | ||
bool | verbose = false |
||
) |
void spot::enable_utf8 | ( | ) |
Enable UTF-8 output for bdd printers.
evtgba_explicit* spot::evtgba_parse | ( | const std::string & | filename, |
evtgba_parse_error_list & | error_list, | ||
bool | debug = false |
||
) |
Build a spot::evtgba_explicit from a text file.
filename | The name of the file to parse. |
error_list | A list that will be filled with parse errors that occured during parsing. |
debug | When true, causes the parser to trace its execution. |
Note that the parser usually tries to recover from errors. It can return an non zero value even if it encountered error during the parsing of filename. If you want to make sure filename was parsed succesfully, check error_list for emptiness.
std::ostream& spot::evtgba_save_reachable | ( | std::ostream & | os, |
const evtgba * | g | ||
) |
Save reachable states in text format.
std::vector<std::vector<sccs_set* > >* spot::find_paths | ( | tgba * | a, |
const scc_map & | m | ||
) |
bool spot::format_evtgba_parse_errors | ( | std::ostream & | os, |
const std::string & | filename, | ||
evtgba_parse_error_list & | error_list | ||
) |
Format diagnostics produced by spot::evtgba_parse.
os | Where diagnostics should be output. |
filename | The filename that should appear in the diagnostics. |
error_list | The error list filled by spot::ltl::parse while parsing ltl_string. |
true
iff any diagnostic was output. bool spot::format_kripke_parse_errors | ( | std::ostream & | os, |
const std::string & | filename, | ||
kripke_parse_error_list & | error_list | ||
) |
Format diagnostics produced by spot::kripke_parse.
os | Where diagnostics should be output. |
filename | The filename that should appear in the diagnostics. |
error_list | The error list filled by spot::ltl::parse while parsing ltl_string. |
true
if any diagnostic was output. bdd spot::formula_to_bdd | ( | const ltl::formula * | f, |
bdd_dict * | d, | ||
void * | for_me | ||
) |
Convert a formula into a BDD.
Convert formula f into a Bdd, using existing variables from d, and registering new one as necessary. for_me is the address to use as owner of the variables used in the BDD.
Referenced by spot::explicit_graph< State, tgba >::add_condition().
std::set<const state*> spot::get_states_set | ( | const ta * | t | ) |
Compute states set for an automaton.
bool spot::is_guarantee_automaton | ( | const tgba * | aut, |
const scc_map * | sm = 0 |
||
) |
Whether an automaton represents a guarantee property.
A weak deterministic TGBA represents a guarantee property if any accepting path ends on an accepting state with only one transition that is a self-loop labelled by true.
Note that in the general case, this is only a sufficient condition : some guarantee automata might not be recognized with this check e.g. because of some non-determinism in the automaton. In that case, you should interpret a false
return value as "I don't know".
If you apply this function on a weak deterministic TGBA (e.g. after a successful minimization with minimize_obligation()), then the result leaves no doubt: false really means that the automaton is not a guarantee property.
bool spot::is_safety_mwdba | ( | const tgba * | aut | ) |
Whether a minimized WDBA represents a safety property.
A minimized WDBA (as returned by a successful run of minimize_obligation()) represent safety property if it contains only accepting transitions.
aut | the automaton to check |
kripke_explicit* spot::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 |
||
) |
kripke* spot::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 |
||
) |
|
inline |
Change a pointer into a unique_ptr.
unsigned spot::max_spanning_paths | ( | std::vector< sccs_set * > * | paths, |
scc_map & | m | ||
) |
int spot::memusage | ( | ) |
Total number of pages in use by the program.
std::ostream& spot::operator<< | ( | std::ostream & | os, |
const gspn_exception & | e | ||
) |
std::ostream& spot::saba_dotty_reachable | ( | std::ostream & | os, |
const saba * | g | ||
) |
Print reachable states in dot format.
tgba* spot::scc_filter | ( | const tgba * | aut, |
bool | remove_all_useless = false |
||
) |
Prune unaccepting SCCs and remove superfluous acceptance conditions.
This function will explore the SCCs of the automaton and remove dead SCCs (i.e. SCC that are not accepting, and those with no exit path leading to an accepting SCC).
Additionally, this will try to remove useless acceptance conditions. This operation may diminish the number of acceptance condition of the automaton (for instance when two acceptance conditions are always used together we only keep one) but it will never remove all acceptance conditions, even if it would be OK to have zero.
Acceptance conditions on transitions going to non-accepting SCC are all removed. Acceptance conditions going to an accepting SCC and coming from another SCC are only removed if remove_all_useless is set. The default value of remove_all_useless is false
because some algorithms (like the degeneralization) will work better if transitions going to an accepting SCC are accepting.
|
inline |
References spot::state::destroy().
std::list<tgba*> spot::split_tgba | ( | tgba * | a, |
const scc_map & | m, | ||
unsigned | split_number | ||
) |
evtgba_explicit* spot::tgba_to_evtgba | ( | const tgba * | a | ) |
Convert a tgba into an evtgba.
(This cannot be done on-the-fly because the alphabet of a tgba as unknown beforehand.)