spot::acceptance_convertor | Help class to convert between acceptance conditions to other BDD formats |
spot::acss_statistics | Accepting Cycle Search Space statistics |
spot::bdd_dict::anon_free_list | |
spot::ars_statistics | Accepting Run Search statistics |
spot::ltl::atomic_prop | Atomic propositions |
spot::ltl::automatop | Automaton operators |
spot::barand< gen > | Compute pseudo-random integer value between 0 and n included, following a binomial distribution for probability p |
spot::bdd_allocator | Manage ranges of variables |
spot::bdd_dict | Map BDD variables to formulae |
spot::bdd_hash | Hash functor for BDDs |
spot::bdd_less_than | Comparison functor for BDDs |
spot::bdd_ordered | |
spot::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 |
spot::ltl::binop | Binary operator |
spot::fixed_size_pool::block_ | |
spot::multiple_size_pool::block_ | |
spot::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* |
spot::fixed_size_pool::chunk_ | |
spot::multiple_size_pool::chunk_ | |
spot::ltl::clone_visitor | Clone a formula.This visitor is public, because it's convenient to derive from it and override part of its methods. But if you just want the functionality, consider using spot::ltl::formula::clone instead, it is way faster |
spot::scc_stack::connected_component | |
spot::connected_component_hash_set | |
spot::connected_component_hash_set_factory | Factory for connected_component_hash_set |
spot::ltl::const_visitor | Formula visitor that cannot modify the formula |
spot::ltl::constant | A constant (True or False) |
spot::couvreur99_check | An implementation of the Couvreur99 emptiness-check algorithm |
spot::couvreur99_check_result | Compute a counter example from a spot::couvreur99_check_status |
spot::couvreur99_check_shy | A version of spot::couvreur99_check that tries to visit known states first |
spot::couvreur99_check_status | The status of the emptiness-check on success |
spot::ltl::declarative_environment | A declarative environment.This environment recognizes all atomic propositions that have been previously declared. It will reject other |
spot::ltl::default_environment | A laxist environment.This environment recognizes all atomic propositions |
spot::delayed_simulation_relation | |
spot::direct_simulation_relation | |
spot::taa_succ_iterator::distance_sort | |
spot::dotty_decorator | Choose state and link styles for spot::dotty_reachable |
spot::duplicator_node | Duplicator node of parity game graph |
spot::duplicator_node_delayed | Duplicator node of parity game graph for delayed simulation |
spot::ec_statistics | Emptiness-check statistics |
spot::emptiness_check | Common interface to emptiness check algorithms |
spot::emptiness_check_instantiator | |
spot::emptiness_check_result | The result of an emptiness check |
spot::ltl::environment | An environment that describes atomic propositions |
spot::evtgba | |
spot::evtgba_explicit | |
spot::evtgba_iterator | |
spot::evtgba_product | |
spot::evtgba_reachable_iterator | Iterate over all reachable states of a spot::evtgba |
spot::evtgba_reachable_iterator_breadth_first | An implementation of spot::evtgba_reachable_iterator that browses states breadth first |
spot::evtgba_reachable_iterator_depth_first | An implementation of spot::evtgba_reachable_iterator that browses states depth first |
spot::explicit_connected_component | An SCC storing all its states explicitly |
spot::explicit_connected_component_factory | Abstract factory for explicit_connected_component |
spot::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 |
spot::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 |
spot::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) |
spot::fixed_size_pool | A fixed-size memory pool implementation |
spot::ltl::formula | An LTL formula.The only way you can work with a formula is to build a spot::ltl::visitor or spot::ltl::const_visitor |
spot::ltl::formula_ptr_hash | Hash Function for const formula* .This is meant to be used as a hash functor for Sgi's hash_map whose key are of type const formula* |
spot::ltl::formula_ptr_less_than | Strict Weak Ordering for const formula* .This is meant to be used as a comparison functor for STL map whose key are of type const formula* |
spot::free_list | Manage list of free integers |
spot::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 |
spot::gspn_exception | An exception used to forward GSPN errors |
spot::gspn_interface | |
spot::gspn_ssp_interface | |
spot::identity_hash< T > | A hash function that returns identity |
spot::kripke | Interface for a Kripke structureA Kripke structure is a graph in which each node (=state) is labeled by a conjunction of atomic proposition |
spot::kripke_explicit | Kripke Structure |
spot::kripke_explicit_succ_iterator | Implement iterator pattern on successor of a state_kripke |
spot::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) |
spot::ltl::language_containment_checker | |
spot::minato_isop::local_vars | Internal variables for minato_isop |
eltlyy::location | Abstract a location |
neverclaimyy::location | Abstract a location |
kripkeyy::location | Abstract a location |
ltlyy::location | Abstract a location |
sautyy::location | Abstract a location |
spot::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 |
spot::ltl::ltl_file | Read LTL formulae from a file, one by one |
spot::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 |
spot::multiple_size_pool | A multiple-size memory pool implementation |
spot::ltl::multop | Multi-operand operators.These operators are considered commutative and associative |
spot::ltl::nfa | Nondeterministic Finite Automata used by automata operators |
spot::ltl::formula_tree::node | |
spot::ltl::formula_tree::node_atomic | |
spot::ltl::formula_tree::node_binop | |
spot::ltl::formula_tree::node_multop | |
spot::ltl::formula_tree::node_nfa | |
spot::ltl::formula_tree::node_unop | |
spot::numbered_state_heap | Keep track of a large quantity of indexed states |
spot::numbered_state_heap_const_iterator | Iterator on numbered_state_heap objects |
spot::numbered_state_heap_factory | Abstract factory for numbered_state_heap |
spot::numbered_state_heap_hash_map | A straightforward implementation of numbered_state_heap with a hash map |
spot::numbered_state_heap_hash_map_factory | Factory for numbered_state_heap_hash_map |
spot::ltl::random_ltl::op_proba | |
spot::option_map | Manage a map of options.Each option is defined by a string and is associated to an integer value |
spot::ltl::multop::paircmp | Comparison functor used internally by ltl::multop |
spot::parity_game_graph | Parity game graph which compute a simulation relation |
spot::parity_game_graph_delayed | |
spot::parity_game_graph_direct | Parity game graph which compute the direct simulation relation |
eltlyy::position | Abstract a position |
neverclaimyy::position | Abstract a position |
kripkeyy::position | Abstract a position |
sautyy::position | Abstract a position |
ltlyy::position | Abstract a position |
spot::ltl::postfix_visitor | Apply an algorithm on each node of an AST, during a postfix traversal.Override one or more of the postifix_visitor::doit methods with the algorithm to apply |
spot::power_map | |
spot::ptr_hash< T > | A hash function for pointers |
spot::ltl::random_ltl | Generate random LTL formulae.This class recursively construct LTL formulae of a given size. The formulae will use the use atomic propositions from the set of proposition passed to the constructor, in addition to the constant and all LTL operators supported by Spot |
spot::ltl::language_containment_checker::record_ | |
spot::ltl::ref_formula | A reference-counted LTL formula |
spot::rsymbol | |
spot::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 |
spot::saba_complement_tgba | Complement a TGBA and produce a SABA.The original TGBA is transformed into a States-based Büchi Automaton |
spot::saba_reachable_iterator | Iterate over all reachable states of a spot::saba |
spot::saba_reachable_iterator_breadth_first | An implementation of spot::saba_reachable_iterator that browses states breadth first |
spot::saba_reachable_iterator_depth_first | An implementation of spot::saba_reachable_iterator that browses states depth first |
spot::saba_state | Abstract class for saba states |
spot::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 |
spot::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* |
spot::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* |
spot::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* |
spot::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 |
spot::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 |
spot::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 |
spot::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), |
spot::scc_map::scc | |
spot::scc_map | Build a map of Strongly Connected components in in a TGBA |
spot::scc_stack | |
spot::scc_stats | |
spot::sccs_set | |
spot::ltl::simplify_f_g_visitor | Replace true U f and false R g by F f and G g |
eltlyy::slice< T, S > | Present a slice of the top of a stack |
kripkeyy::slice< T, S > | Present a slice of the top of a stack |
neverclaimyy::slice< T, S > | Present a slice of the top of a stack |
sautyy::slice< T, S > | Present a slice of the top of a stack |
ltlyy::slice< T, S > | Present a slice of the top of a stack |
spot::spoiler_node | Spoiler node of parity game graph |
spot::spoiler_node_delayed | Spoiler node of parity game graph for delayed simulation |
neverclaimyy::stack< T, S > | |
kripkeyy::stack< T, S > | |
eltlyy::stack< T, S > | |
sautyy::stack< T, S > | |
ltlyy::stack< T, S > | |
spot::evtgba_explicit::state | |
spot::state | Abstract class for states |
spot::state_bdd | |
spot::state_evtgba_explicit | States used by spot::tgba_evtgba_explicit |
spot::state_explicit | |
spot::state_kripke | Concrete class for kripke states |
spot::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 |
spot::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* |
spot::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* |
spot::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* |
spot::state_set | Set of states deriving from spot::state |
spot::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 |
spot::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 |
spot::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 |
spot::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 |
spot::tgba_run::step | |
spot::ltl::succ_iterator | |
spot::couvreur99_check_shy::successor | |
spot::symbol | |
spot::taa_succ_iterator | |
spot::taa_tgba | A self-loop Transition-based Alternating Automaton (TAA) which is seen as a TGBA (abstract class, see below) |
spot::taa_tgba_formula | |
spot::taa_tgba_labelled< label, label_hash > | |
spot::taa_tgba_string | |
spot::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) |
spot::tgba_bdd_concrete | A concrete spot::tgba implemented using BDDs |
spot::tgba_bdd_concrete_factory | Helper class to build a spot::tgba_bdd_concrete object |
spot::tgba_bdd_core_data | Core data for a TGBA encoded using BDDs |
spot::tgba_bdd_factory | Abstract class for spot::tgba_bdd_concrete factories |
spot::tgba_explicit | |
spot::tgba_explicit_formula | |
spot::tgba_explicit_labelled< label, label_hash > | A tgba_explicit instance with states labeled by a given type |
spot::tgba_explicit_number | |
spot::tgba_explicit_string | |
spot::tgba_explicit_succ_iterator | |
spot::tgba_kv_complement | Build a complemented automaton.The construction comes from: |
spot::tgba_product | A lazy product. (States are computed on the fly.) |
spot::tgba_product_init | A lazy product with different initial states |
spot::tgba_reachable_iterator | Iterate over all reachable states of a spot::tgba |
spot::tgba_reachable_iterator_breadth_first | An implementation of spot::tgba_reachable_iterator that browses states breadth first |
spot::tgba_reachable_iterator_depth_first | An implementation of spot::tgba_reachable_iterator that browses states depth first |
spot::tgba_reduc | |
spot::tgba_run | An accepted run, for a tgba |
spot::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 |
spot::tgba_safra_complement | Build a complemented automaton.It creates an automaton that recognizes the negated language of aut |
spot::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 |
spot::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 |
spot::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 |
spot::tgba_statistics | |
spot::tgba_sub_statistics | |
spot::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 |
spot::tgba_succ_iterator_concrete | |
spot::tgba_succ_iterator_union | Iterate over the successors of an union computed on the fly |
spot::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) |
spot::tgba_union | A lazy union. (States are computed on the fly.) |
spot::time_info | A structure to record elapsed time in clock ticks |
spot::timer | A timekeeper that accumulate interval of time |
spot::timer_map | A map of timer, where each timer has a name |
spot::couvreur99_check_shy::todo_item | |
spot::ltl::nfa::transition | Explicit transitions |
spot::state_explicit::transition | Explicit transitions |
spot::evtgba_explicit::transition | Explicit transitions (used by spot::evtgba_explicit) |
spot::taa_tgba::transition | Explicit transitions |
spot::ltl::automatop::tripletcmp | Comparison functor used internally by ltl::automatop |
spot::ltl::unabbreviate_logic_visitor | Clone and rewrite a formula to remove most of the abbreviated logical operators.This will rewrite binary operators such as binop::Implies, binop::Equals, and binop::Xor, using only unop::Not, multop::Or, and multop::And |
spot::ltl::unabbreviate_ltl_visitor | Clone and rewrite a formula to remove most of the abbreviated LTL and logical operators.The rewriting performed on logical operator is the same as the one done by spot::ltl::unabbreviate_logic_visitor |
spot::ltl::unop | Unary operators |
spot::unsigned_statistics | |
spot::unsigned_statistics_copy | Comparable statistics |
spot::ltl::visitor | Formula visitor that can modify the formula.Writing visitors is the prefered way to traverse a formula, since it doesn't involve any cast |
spot::weight | Manage for a given automaton a vector of counter indexed by its acceptance condition |