 spot::acc_compl | Helper class to convert acceptance conditions into promises |
 spot::acceptance_convertor | Help class to convert between acceptance conditions to other BDD formats |
 spot::barand< gen > | Compute pseudo-random integer value between 0 and n included, following a binomial distribution for probability p |
 spot::bdd_hash | Hash functor for BDDs |
 spot::bdd_dict::bdd_info | |
 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::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::scc_stack_ta::connected_component | |
 spot::scc_stack::connected_component | |
  spot::explicit_connected_component | An SCC storing all its states explicitly |
   spot::connected_component_hash_set | |
 spot::couvreur99_check_status | The status of the emptiness-check on success |
 spot::destroy_key< T > | |
 spot::destroy_key< const ltl::formula * > | |
 spot::enumerate_cycles::dfs_entry | |
 spot::taa_succ_iterator::distance_sort | |
 spot::dotty_decorator | Choose state and link styles for spot::dotty_reachable |
  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::emptiness_check | Common interface to emptiness check algorithms |
  spot::couvreur99_check | An implementation of the Couvreur99 emptiness-check algorithm |
   spot::couvreur99_check_shy | A version of spot::couvreur99_check that tries to visit known states first |
 spot::emptiness_check_instantiator | |
 spot::emptiness_check_result | The result of an emptiness check |
  spot::couvreur99_check_result | Compute a counter example from a spot::couvreur99_check_status |
 spot::enumerate_cycles | Enumerate elementary cycles in a SCC |
 spot::ltl::environment | An environment that describes atomic propositions |
  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::evtgba | |
  spot::evtgba_explicit | |
  spot::evtgba_product | |
 spot::evtgba_iterator | |
 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_conf< graph, Type > | |
 spot::explicit_conf< graph, state_explicit_formula > | |
 spot::explicit_conf< graph, state_explicit_string > | |
 spot::explicit_connected_component_factory | Abstract factory for explicit_connected_component |
  spot::connected_component_hash_set_factory | Factory for connected_component_hash_set |
 spot::explicit_graph< State, Type > | |
 spot::fixed_size_pool | A fixed-size memory pool implementation |
 spot::formater | |
  spot::stat_printer | Prints various statistics about a TGBA |
 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::constant | A constant (True or False) |
  spot::ltl::ref_formula | A reference-counted LTL formula |
   spot::ltl::atomic_prop | Atomic propositions |
   spot::ltl::automatop | Automaton operators |
   spot::ltl::binop | Binary operator |
   spot::ltl::bunop | Bounded unary operator |
   spot::ltl::multop | Multi-operand operators |
   spot::ltl::unop | Unary operators |
 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::bdd_allocator | Manage ranges of variables |
   spot::bdd_dict | Map BDD variables to formulae |
  spot::bdd_dict::anon_free_list | |
 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 |
 job | |
 job_processor | |
 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 |
 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::ltl::formula::ltl_prop | |
 spot::ltl::ltl_simplifier | Rewrite or simplify f in various ways |
 spot::ltl::ltl_simplifier_options | |
 spot::ltl::mark_tools | |
 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::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_hash_map | A straightforward implementation of numbered_state_heap with a hash map |
 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_factory | Factory for numbered_state_heap_hash_map |
 spot::ltl::random_formula::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 |
 eltlyy::position | Abstract a position |
 neverclaimyy::position | Abstract a position |
 kripkeyy::position | Abstract a position |
 ltlyy::position | Abstract a position |
 spot::postprocessor | Wrap TGBA/BA/Monitor post-processing algorithms in an easy interface |
 spot::power_map | |
 spot::printable | |
  spot::printable_value< const ltl::formula * > | |
   spot::printable_formula | |
  spot::printable_id | The default callback simply writes "%c" |
  spot::printable_percent | Called by default for "%%" and "%\0" |
  spot::printable_value< T > | |
 spot::ptr_hash< T > | A hash function for pointers |
 spot::ltl::random_formula | Base class for random formula generators |
  spot::ltl::random_boolean | Generate random Boolean formulae.This class recursively constructs Boolean formulae of a given size. The formulae will use the use atomic propositions from the set of propositions passed to the constructor, in addition to the constant and all Boolean operators supported by Spot |
  spot::ltl::random_ltl | Generate random LTL formulae.This class recursively constructs LTL formulae of a given size. The formulae will use the use atomic propositions from the set of propositions passed to the constructor, in addition to the constant and all LTL operators supported by Spot |
   spot::ltl::random_psl | Generate random PSL formulae.This class recursively constructs PSL formulae of a given size. The formulae will use the use atomic propositions from the set of propositions passed to the constructor, in addition to the constant and all PSL operators supported by Spot |
  spot::ltl::random_sere | Generate random SERE.This class recursively constructs SERE of a given size. The formulae will use the use atomic propositions from the set of propositions passed to the constructor, in addition to the constant and all SERE operators supported by Spot |
 range | |
 spot::ltl::language_containment_checker::record_ | |
 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::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::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_stack_ta | |
 spot::scc_stats | |
 spot::sccs_set | |
 ltlyy::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 |
 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 |
 kripkeyy::stack< T, S > | |
 eltlyy::stack< T, S > | |
 ltlyy::stack< T, S > | |
 neverclaimyy::stack< T, S > | |
 spot::state | Abstract class for states |
  spot::state_bdd | |
  spot::state_evtgba_explicit | States used by spot::tgba_evtgba_explicit |
  spot::state_explicit< Label, label_hash > | |
  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_set | Set of states deriving from spot::state |
  spot::state_ta_explicit | |
  spot::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 |
  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::state_explicit< const ltl::formula *, ltl::formula_ptr_hash > | |
   spot::state_explicit_formula | |
  spot::state_explicit< int, identity_hash< int > > | |
   spot::state_explicit_number | |
  spot::state_explicit< std::string, string_hash > | |
   spot::state_explicit_string | |
 spot::evtgba_explicit::state | |
 spot::enumerate_cycles::state_info | |
 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_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::tgba_run::step | |
 spot::ltl::succ_iterator | |
 spot::couvreur99_check_shy::successor | |
 spot::symbol | |
 spot::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 |
  spot::ta_explicit | |
  spot::ta_product | A lazy product between a Testing automaton and a Kripke structure. (States are computed on the fly.) |
 spot::ta_reachable_iterator | Iterate over all reachable states of a spot::ta |
  spot::ta_reachable_iterator_breadth_first | An implementation of spot::ta_reachable_iterator that browses states breadth first |
  spot::ta_reachable_iterator_depth_first | An implementation of spot::ta_reachable_iterator that browses states depth first |
 spot::ta_statistics | |
 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::explicit_graph< State, tgba > | |
   spot::tgba_explicit< State > | |
  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::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::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 |
   spot::explicit_graph< State, sba > | |
    spot::sba_explicit< State > | |
  spot::taa_tgba | A self-loop Transition-based Alternating Automaton (TAA) which is seen as a TGBA (abstract class, see below) |
   spot::taa_tgba_labelled< label, label_hash > | |
   spot::taa_tgba_labelled< const ltl::formula *, ltl::formula_ptr_hash > | |
    spot::taa_tgba_formula | |
   spot::taa_tgba_labelled< std::string, string_hash > | |
    spot::taa_tgba_string | |
  spot::tgba_bdd_concrete | A concrete spot::tgba implemented using BDDs |
  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::tgta_product | A lazy product. (States are computed on the fly.) |
  spot::tgba_safra_complement | Build a complemented automaton.It creates an automaton that recognizes the negated language of aut |
  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::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::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_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_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_union | A lazy union. (States are computed on the fly.) |
  spot::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 |
   spot::tgta_explicit | |
 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_bdd_concrete_factory | Helper class to build a spot::tgba_bdd_concrete object |
 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_run | An accepted run, for a tgba |
 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::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::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::kripke_explicit_succ_iterator | Implement iterator pattern on successor of a state_kripke |
  spot::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 |
   spot::ta_explicit_succ_iterator | Successor iterators used by spot::ta_explicit |
   spot::ta_succ_iterator_product | Iterate over the successors of a product computed on the fly |
    spot::ta_succ_iterator_product_by_changeset | |
  spot::taa_succ_iterator | |
  spot::tgba_explicit_succ_iterator< State > | |
  spot::tgba_succ_iterator_concrete | |
  spot::tgba_succ_iterator_union | Iterate over the successors of an union computed on the fly |
  spot::tgta_succ_iterator_product | Iterate over the successors of a product 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::taa_tgba::transition | Explicit transitions |
 spot::state_ta_explicit::transition | Explicit transitions |
 spot::evtgba_explicit::transition | Explicit transitions (used by spot::evtgba_explicit) |
 spot::state_explicit< Label, label_hash >::transition | |
 spot::ltl::nfa::transition | Explicit transitions |
 spot::ltl::automatop::tripletcmp | Comparison functor used internally by ltl::automatop |
 spot::unique_ptr< T > | Take ownership of a pointer at its construction, and destroy it at the end of the scope |
 spot::unsigned_statistics | |
  spot::ars_statistics | Accepting Run Search statistics |
   spot::acss_statistics | Accepting Cycle Search Space statistics |
    spot::couvreur99_check_result | Compute a counter example from a spot::couvreur99_check_status |
  spot::ec_statistics | Emptiness-check statistics |
   spot::couvreur99_check | An implementation of the Couvreur99 emptiness-check algorithm |
   spot::ta_check | An implementation of the emptiness-check algorithm for a product between a TA and a Kripke structure |
 spot::unsigned_statistics_copy | Comparable statistics |
 spot::ltl::visitor | Formula visitorImplementing visitors is the prefered way to traverse a formula, since it does not involve any cast |
  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::ltl::simplify_f_g_visitor | Replace true U f and false R g by F f and G g |
   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::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::weight | Manage for a given automaton a vector of counter indexed by its acceptance condition |