 eltlyy | |
  location | Abstract a location |
  position | Abstract a position |
 ltlyy | |
  location | Abstract a location |
  position | Abstract a position |
 neverclaimyy | |
  location | Abstract a location |
  position | Abstract a position |
 spot | This class acts like a wrapper to the C code of the union find |
  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 |
    ltl_prop | |
   formula_ptr_less_than | Strict Weak Ordering for const formula* |
   formula_ptr_less_than_bool_first | Strict Weak Ordering for const formula* inside ltl::multop.This is the comparison functor used by to order the ltl::multop operands. It keeps Boolean formulae first in order to speed up implication checks |
   formula_ptr_hash | Hash Function for 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 visitor |
   declarative_environment | A declarative environment |
   default_environment | A laxist environment |
   environment | An environment that describes atomic propositions |
   ltl_file | Read LTL formulae from a file, one by one |
   clone_visitor | Clone a formula |
   language_containment_checker | Check containment between LTL formulae |
   unabbreviate_logic_visitor | Clone and rewrite a formula to remove most of the abbreviated logical operators |
   mark_tools | |
   postfix_visitor | Apply an algorithm on each node of an AST, during a postfix traversal |
   random_formula | Base class for random formula generators |
    op_proba | |
   random_ltl | Generate random LTL formulae |
   random_boolean | Generate random Boolean formulae |
   random_sere | Generate random SERE |
   random_psl | Generate random PSL formulae |
   relabeling_map | |
   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 |
  dstar_aut | Temporary encoding of an omega automaton produced by ltl2dstar |
  acc_dict | |
  ap_dict | This class is used to create a dictionary that will contain all atomic propositions that are needed by an (and possibly many) automaton |
  cube | This class represents conjunction of variables |
  fasttgba | |
  transition | Structure that will store the successors of a state |
  fast_explicit_state | |
  fast_explicit_iterator | Iterator for fast_explicit_state |
  fasttgbaexplicit | |
  fast_product_state | This class represents a product state |
  fast_product_iterator | This is an iterator for the product |
  fasttgba_product | This class allows to do a synchronized product between two fast tgba |
  fasttgba_state | This class act as an interface for all classes |
  fasttgba_state_ptr_equal | |
  fasttgba_state_ptr_hash | |
  fasttgba_succ_iterator | Iterate over the successors of a state |
  markset | This class represents a set of acceptance marks |
  dotty_dfs | |
  uf | |
  concur_ec_stat | |
  concur_opt_tarjan_scc | The class that will be used by thread performing a Tarjan SCC |
  concur_opt_dijkstra_scc | The class that will be used by thread performing a Dijkstra SCC |
  concur_opt_tarjan_ec | An emptiness based on the tarjan parallel computation algorithm above |
  dead_share | Wrapper Launch all threads |
  deadstore | This class represent a dead store. For now it's just a set but it can be combined with bitstate hasing |
  dijkstra_scc | |
   pair_state_iter | |
  dijkstracheck | |
   pair_state_iter | |
  ec | |
  instance_automaton | A simple wrapper for an automaton |
  instanciator | |
  simple_instance | |
  simple_instanciator | |
  lazycheck | |
   pair_state_iter | |
   stack_entry | |
  stack_of_lowlink | |
  compressed_stack_of_lowlink | This class represents a compaction of the lowlink stack |
   ll_elt | |
  opt_dijkstra_scc | This is the Dijkstra SCC computation algorithm This class also include the optimisation for the live stack (provided by Nuutila for Tarjan's algorithm but adapted here) and a possibly stack compression technique |
   pair_state_iter | |
  opt_dijkstra_ec | Transform the previous algorithm into an emptiness check. Only refine specific methods |
  opt_tarjan_scc | Compute the SCCs of a TGBA |
   pair_state_iter | |
  opt_tarjan_ec | This class is the implementation of the tarjan-based emptiness check. It onlys needs to refine two methods that deal with acceptance sets : update and pop |
  stack_of_roots | |
  compressed_stack_of_roots | |
  stats | |
   pair_state_iter | |
   stack_entry | |
   stats_entry | Structure to store stats about the product |
  tarjan_scc | |
   pair_state_iter | |
   stack_entry | |
  union_find | |
  setOfDisjointSetsIPC_LRPC | |
  setOfDisjointSetsIPC_LRPC_MS | |
  setOfDisjointSetsIPC_LRPC_MS_Dead | This class propose an union find based on a deadstore. The idea is to used a dedicated map for the storage of dead state but this storage is done in a lazy way. A counter maintain the realsize of the union find structure when a make dead is realized : this is possible with the assumption that make dead is performed on the dfs root of the SCC. So the structure maintain the real size of the structure which is the size of Alive states. Adding a new state only checks if this size is the size of the structure to avoid extra memory allocation. If it is not true this means that there are dead states insides the alive structure. Just pick one a insert it inside the dead store. Otherwise it's a classic insert |
  union_scc | |
   pair_state_iter | |
  unioncheck | |
   pair_state_iter | |
  generic_dfs | |
  lbtt_dfs | |
  stats_dfs | |
  fair_kripke_succ_iterator | Iterator code for a Fair Kripke structure |
  fair_kripke | Interface for a Fair Kripke structure |
  kripke_succ_iterator | Iterator code for Kripke structure |
  kripke | Interface for a Kripke structure |
  state_kripke | Concrete class for kripke states |
  kripke_explicit_succ_iterator | Implement iterator pattern on successor of a state_kripke |
  kripke_explicit | Kripke Structure |
  bdd_less_than | Comparison functor for BDDs |
  bdd_hash | Hash functor for BDDs |
  bitvect | A bit vector |
  bitvect_array | |
  fixed_size_pool | A fixed-size memory pool implementation |
  printable | |
  printable_value | |
  printable_id | The default callback simply writes "%c" |
  printable_percent | Called by default for "%%" and "%\0" |
  formater | |
  ptr_hash | A hash function for pointers |
  identity_hash | A hash function that returns identity |
  char_ptr_less_than | Strict Weak Ordering for char* |
  minato_isop | Generate an irredundant sum-of-products (ISOP) form of a BDD function |
  multiple_size_pool | A multiple-size memory pool implementation |
  option_map | Manage a map of options |
  barand | Compute pseudo-random integer value between 0 and n included, following a binomial distribution for probability p |
  clause_counter | |
  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 |
  temporary_file | Temporary file name |
  open_temporary_file | Open temporary file |
  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 |
  saba | A State-based Alternating (Generalized) Büchi Automaton |
  saba_complement_tgba | Complement a TGBA and produce a SABA |
  saba_state | Abstract class for saba states |
  saba_state_ptr_less_than | Strict Weak Ordering for saba_state* |
  saba_state_ptr_equal | An Equivalence Relation for saba_state* |
  saba_state_ptr_hash | Hash Function for saba_state* |
  saba_state_shared_ptr_less_than | Strict Weak Ordering for shared_saba_state (shared_ptr<const saba_state*>) |
  saba_state_shared_ptr_equal | An Equivalence Relation for shared_saba_state (shared_ptr<const saba_state*>) |
  saba_state_shared_ptr_hash | Hash Function for shared_saba_state (shared_ptr<const saba_state*>) |
  saba_state_conjunction | Iterate over a conjunction of saba_state |
  saba_succ_iterator | Iterate over the successors of a saba_state |
  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 |
  ta_succ_iterator | Iterate over the successors of a state |
  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 |
  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) |
  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 |
   bdd_info | |
  future_conditions_collector | Wrap a tgba to offer information about upcoming conditions |
  sba | A State-based Generalized Büchi Automaton |
  state | Abstract class for states |
  state_ptr_less_than | Strict Weak Ordering for state* |
  state_ptr_equal | An Equivalence Relation for state* |
  state_ptr_hash | Hash Function for state* |
  state_shared_ptr_less_than | Strict Weak Ordering for shared_state (shared_ptr<const state*>) |
  state_shared_ptr_equal | An Equivalence Relation for shared_state (shared_ptr<const state*>) |
  state_shared_ptr_hash | Hash Function for shared_state (shared_ptr<const state*>) |
  state_bdd | |
  tgba_succ_iterator | Iterate over the successors of a state |
  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 |
  set_state | Set of states deriving from spot::state |
  taa_succ_iterator | |
  taa_tgba_labelled | |
  taa_tgba_string | |
  taa_tgba_formula | |
  tgba | A Transition-based Generalized Büchi Automaton |
  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 |
  tgba_mask | A masked TGBA (abstract) |
  state_product | A state for spot::tgba_product |
  tgba_product | A lazy product. (States are computed on the fly.) |
  tgba_product_init | A lazy product with different initial states |
  tgba_proxy | A TGBA proxy |
  tgba_safra_complement | Build a complemented automaton |
  tgba_scc | Wrap a tgba to offer information about strongly connected components |
  tgba_sgba_proxy | Change the labeling-mode of spot::tgba on the fly, producing a state-based generalized Büchi automaton |
  tgba_tba_proxy | Degeneralize a spot::tgba on the fly, producing a TBA |
  tgba_sba_proxy | Degeneralize a spot::tgba on the fly, producing an SBA |
  state_union | A state for spot::tgba_union |
  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 |
  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_breadth_first | An implementation of spot::tgba_reachable_iterator that browses states breadth first |
  tgba_reachable_iterator_depth_first | Iterate over all states of an automaton using a DFS |
   stack_item | |
  tgba_reachable_iterator_depth_first_stack | Iterate over all states of an automaton using a DFS |
  tgba_run_dotty_decorator | Highlight a spot::tgba_run on a spot::tgba |
  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 |
  translator | Translate an LTL formula into an optimized spot::tgba |
  weight | Manage for a given automaton a vector of counter indexed by its acceptance condition |
  tgba_word | An infinite word stored as a lasso |
  fasttgba_kripke_product | |
  dve2product_instance | |
  dve2product_instanciator | |
  gspn_exception | An exception used to forward GSPN errors |
  gspn_interface | |
  gspn_ssp_interface | |
 tgbayy | |
  location | Abstract a location |
  position | Abstract a position |
 aut_stat_printer | |
 job | |
 job_processor | |
 printable_formula | |
 range | |