spot
0.8.1
|
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 | 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 | 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 | 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 | 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 | 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... | |
class | state_explicit |
class | tgba_explicit |
class | tgba_explicit_succ_iterator |
class | tgba_explicit_labelled |
A tgba_explicit instance with states labeled by a given type. More... | |
class | tgba_explicit_string |
class | tgba_explicit_formula |
class | tgba_explicit_number |
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 | direct_simulation_relation |
class | delayed_simulation_relation |
class | tgba_reduc |
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 | 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... | |
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 | parity_game_graph |
Parity game graph which compute a simulation relation. More... | |
class | spoiler_node |
Spoiler node of parity game graph. More... | |
class | duplicator_node |
Duplicator node of parity game graph. More... | |
class | parity_game_graph_direct |
Parity game graph which compute the direct simulation relation. More... | |
class | spoiler_node_delayed |
Spoiler node of parity game graph for delayed simulation. More... | |
class | duplicator_node_delayed |
Duplicator node of parity game graph for delayed simulation. More... | |
class | parity_game_graph_delayed |
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 | 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 std::vector< bdd_ordered > | acc_list_t |
typedef std::pair< const spot::state *, const spot::state * > | state_couple |
typedef std::vector < state_couple * > | simulation_relation |
typedef std::vector < spoiler_node * > | sn_v |
typedef std::vector < duplicator_node * > | dn_v |
typedef std::vector< const state * > | s_v |
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. | |
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. | |
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 & | 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) |
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) |
std::ostream & | dotty_reachable (std::ostream &os, const tgba *g, bool assume_sba=false, dotty_decorator *dd=dotty_decorator::instance()) |
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 * | 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 * | 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. | |
std::ostream & | lbtt_reachable (std::ostream &os, const tgba *g) |
Print reachable states in LBTT 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 * | 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, int reduce_ltl=ltl::Reduce_None) |
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. | |
tgba_explicit_number * | minimize_monitor (const tgba *a) |
Construct a minimal deterministic monitor. | |
tgba_explicit_number * | minimize_wdba (const tgba *a) |
Minimize a Büchi automaton in the WDBA class. | |
const tgba * | minimize_obligation (const tgba *aut_f, const ltl::formula *f=0, const tgba *aut_neg_f=0) |
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) |
Remove some node of the automata using a simulation relation. | |
direct_simulation_relation * | get_direct_relation_simulation (const tgba *a, std::ostream &os, int opt=-1) |
Compute a direct simulation relation on state of tgba f. | |
delayed_simulation_relation * | get_delayed_relation_simulation (const tgba *a, std::ostream &os, int opt=-1) |
void | free_relation_simulation (direct_simulation_relation *rel) |
To free a simulation relation. | |
void | free_relation_simulation (delayed_simulation_relation *rel) |
To free 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_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. | |
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 boost::shared_ptr<const saba_state> spot::shared_saba_state |
typedef boost::shared_ptr<const state> spot::shared_state |
typedef std::vector<state_couple*> spot::simulation_relation |
typedef std::pair<const spot::state*, const spot::state*> spot::state_couple |
typedef std::set<const symbol*> spot::symbol_set |
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 | ||
) |
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.
bdd spot::compute_neg_acceptance_conditions | ( | bdd | all_acceptance_conditions | ) |
Compute neg acceptance conditions from all 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::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 |
||
) |
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 | ||
) |
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 |
||
) |
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.
void spot::shared_state_deleter | ( | state * | s | ) | [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.)