 eltlyy | |
  location | Abstract a location |
  position | Abstract a position |
  stack | |
  slice | Present a slice of the top of a stack |
 kripkeyy | |
  location | Abstract a location |
  position | Abstract a position |
  stack | |
  slice | Present a slice of the top of a stack |
 ltlyy | |
  location | Abstract a location |
  position | Abstract a position |
  stack | |
  slice | Present a slice of the top of a stack |
 neverclaimyy | |
  location | Abstract a location |
  position | Abstract a position |
  stack | |
  slice | Present a slice of the top of a stack |
 spot | |
  eltl | |
  ltl | |
   formula_tree | Trees representing formulae where atomic propositions are unknown |
    node | |
    node_unop | |
    node_binop | |
    node_multop | |
    node_nfa | |
    node_atomic | |
   atomic_prop | Atomic propositions |
   automatop | Automaton operators |
    tripletcmp | Comparison functor used internally by ltl::automatop |
   binop | Binary operator |
   bunop | Bounded unary operator |
   constant | A constant (True or False) |
   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 |
    ltl_prop | |
   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* |
   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* |
   multop | Multi-operand operators |
    paircmp | Comparison functor used internally by ltl::multop |
   nfa | Nondeterministic Finite Automata used by automata operators |
    transition | Explicit transitions |
   succ_iterator | |
   ref_formula | A reference-counted LTL formula |
   unop | Unary operators |
   visitor | Formula visitorImplementing visitors is the prefered way to traverse a formula, since it does not involve any cast |
   declarative_environment | A declarative environment.This environment recognizes all atomic propositions that have been previously declared. It will reject other |
   default_environment | A laxist environment.This environment recognizes all atomic propositions |
   environment | An environment that describes atomic propositions |
   ltl_file | Read LTL formulae from a file, one by one |
   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 |
   language_containment_checker | |
    record_ | |
   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 |
   mark_tools | |
   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 |
   random_formula | Base class for random formula generators |
    op_proba | |
   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 |
   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 |
   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 |
   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 |
   simplify_f_g_visitor | Replace true U f and false R g by F f and G g |
   ltl_simplifier_options | |
   ltl_simplifier | Rewrite or simplify f in various ways |
   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 |
  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) |
  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 |
  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) |
  kripke | Interface for a Kripke structureA Kripke structure is a graph in which each node (=state) is labeled by a conjunction of atomic proposition |
  state_kripke | Concrete class for kripke states |
  kripke_explicit_succ_iterator | Implement iterator pattern on successor of a state_kripke |
  kripke_explicit | Kripke Structure |
  acc_compl | Helper class to convert acceptance conditions into promises |
  acceptance_convertor | Help class to convert between acceptance conditions to other BDD formats |
  bdd_allocator | Manage ranges of variables |
  bdd_less_than | Comparison functor for BDDs |
  bdd_hash | Hash functor for BDDs |
  fixed_size_pool | A fixed-size memory pool implementation |
   block_ | |
   chunk_ | |
  printable | |
  printable_value | |
  printable_id | The default callback simply writes "%c" |
  printable_percent | Called by default for "%%" and "%\0" |
  formater | |
  free_list | Manage list of free integers |
  ptr_hash | A hash function for pointers |
  identity_hash | A hash function that returns identity |
  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* |
  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 |
   local_vars | Internal variables for minato_isop |
  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 |
  multiple_size_pool | A multiple-size memory pool implementation |
   block_ | |
   chunk_ | |
  option_map | Manage a map of options.Each option is defined by a string and is associated to an integer value |
  barand | Compute pseudo-random integer value between 0 and n included, following a binomial distribution for probability p |
  time_info | A structure to record elapsed time in clock ticks |
  timer | A timekeeper that accumulate interval of time |
  timer_map | A map of timer, where each timer has a name |
  unique_ptr | Take ownership of a pointer at its construction, and destroy it at the end of the scope |
  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 |
  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 |
  saba_complement_tgba | Complement a TGBA and produce a SABA.The original TGBA is transformed into a States-based Büchi Automaton |
  saba_state | Abstract class for saba states |
  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* |
  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* |
  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* |
  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 |
  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 |
  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 |
  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 |
  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), |
  saba_reachable_iterator | Iterate over all reachable states of a spot::saba |
  saba_reachable_iterator_depth_first | An implementation of spot::saba_reachable_iterator that browses states depth first |
  saba_reachable_iterator_breadth_first | An implementation of spot::saba_reachable_iterator that browses states breadth first |
  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 |
  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 |
  scc_stack_ta | |
   connected_component | |
  ta_explicit | |
  state_ta_explicit | |
   transition | Explicit transitions |
  ta_explicit_succ_iterator | Successor iterators used by spot::ta_explicit |
  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 |
  ta_succ_iterator_product | Iterate over the successors of a product computed on the fly |
  ta_product | A lazy product between a Testing automaton and a Kripke structure. (States are computed on the fly.) |
  ta_succ_iterator_product_by_changeset | |
  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 |
  tgta_explicit | |
  tgta_product | A lazy product. (States are computed on the fly.) |
  tgta_succ_iterator_product | Iterate over the successors of a product computed on the fly |
  ta_check | An implementation of the emptiness-check algorithm for a product between a TA and a Kripke structure |
  ta_reachable_iterator | Iterate over all reachable states of a spot::ta |
  ta_reachable_iterator_depth_first | An implementation of spot::ta_reachable_iterator that browses states depth first |
  ta_reachable_iterator_breadth_first | An implementation of spot::ta_reachable_iterator that browses states breadth first |
  ta_statistics | |
  bdd_dict | Map BDD variables to formulae |
   anon_free_list | |
   bdd_info | |
  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 |
  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 |
  state | Abstract class for states |
  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* |
  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* |
  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* |
  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 |
  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 |
  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 |
  state_bdd | |
  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 |
  tgba_succ_iterator_concrete | |
  taa_tgba | A self-loop Transition-based Alternating Automaton (TAA) which is seen as a TGBA (abstract class, see below) |
   transition | Explicit transitions |
  state_set | Set of states deriving from spot::state |
  taa_succ_iterator | |
   distance_sort | |
  taa_tgba_labelled | |
  taa_tgba_string | |
  taa_tgba_formula | |
  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) |
  tgba_bdd_concrete | A concrete spot::tgba implemented using BDDs |
  tgba_bdd_concrete_factory | Helper class to build a spot::tgba_bdd_concrete object |
  tgba_bdd_core_data | Core data for a TGBA encoded using BDDs |
  tgba_bdd_factory | Abstract class for spot::tgba_bdd_concrete factories |
  destroy_key | |
  destroy_key< const ltl::formula * > | |
  state_explicit | |
   transition | |
  state_explicit_number | |
  state_explicit_string | |
  state_explicit_formula | |
  tgba_explicit_succ_iterator | |
  explicit_graph | |
  tgba_explicit | |
  sba_explicit | |
  explicit_conf | |
  explicit_conf< graph, state_explicit_string > | |
  explicit_conf< graph, state_explicit_formula > | |
  bdd_ordered | |
  tgba_kv_complement | Build a complemented automaton.The construction comes from: |
  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 |
  tgba_product | A lazy product. (States are computed on the fly.) |
  tgba_product_init | A lazy product with different initial states |
  tgba_safra_complement | Build a complemented automaton.It creates an automaton that recognizes the negated language of aut |
  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 |
  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 |
  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) |
  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 |
  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 |
  tgba_succ_iterator_union | Iterate over the successors of an union computed on the fly |
  tgba_union | A lazy union. (States are computed on the fly.) |
  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 |
  sccs_set | |
  enumerate_cycles | Enumerate elementary cycles in a SCC |
   dfs_entry | |
   state_info | |
  dotty_decorator | Choose state and link styles for spot::dotty_reachable |
  emptiness_check_result | The result of an emptiness check |
  emptiness_check | Common interface to emptiness check algorithms |
  emptiness_check_instantiator | |
  tgba_run | An accepted run, for a tgba |
   step | |
  unsigned_statistics | |
  unsigned_statistics_copy | Comparable statistics |
  ec_statistics | Emptiness-check statistics |
  ars_statistics | Accepting Run Search statistics |
  acss_statistics | Accepting Cycle Search Space statistics |
  couvreur99_check_result | Compute a counter example from a spot::couvreur99_check_status |
  explicit_connected_component | An SCC storing all its states explicitly |
  connected_component_hash_set | |
  explicit_connected_component_factory | Abstract factory for explicit_connected_component |
  connected_component_hash_set_factory | Factory for connected_component_hash_set |
  couvreur99_check | An implementation of the Couvreur99 emptiness-check algorithm |
  couvreur99_check_shy | A version of spot::couvreur99_check that tries to visit known states first |
   successor | |
   todo_item | |
  numbered_state_heap_const_iterator | Iterator on numbered_state_heap objects |
  numbered_state_heap | Keep track of a large quantity of indexed states |
  numbered_state_heap_factory | Abstract factory for numbered_state_heap |
  numbered_state_heap_hash_map | A straightforward implementation of numbered_state_heap with a hash map |
  numbered_state_heap_hash_map_factory | Factory for numbered_state_heap_hash_map |
  scc_stack | |
   connected_component | |
  couvreur99_check_status | The status of the emptiness-check on success |
  postprocessor | Wrap TGBA/BA/Monitor post-processing algorithms in an easy interface |
  power_map | |
  tgba_reachable_iterator | Iterate over all reachable states of a spot::tgba |
  tgba_reachable_iterator_depth_first | An implementation of spot::tgba_reachable_iterator that browses states depth first |
  tgba_reachable_iterator_breadth_first | An implementation of spot::tgba_reachable_iterator that browses states breadth first |
  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 |
  scc_stats | |
  scc_map | Build a map of Strongly Connected components in in a TGBA |
   scc | |
  tgba_statistics | |
  tgba_sub_statistics | |
  printable_formula | |
  stat_printer | Prints various statistics about a TGBA |
  weight | Manage for a given automaton a vector of counter indexed by its acceptance condition |
  gspn_exception | An exception used to forward GSPN errors |
  gspn_interface | |
  gspn_ssp_interface | |
 job | |
 job_processor | |
 range | |