spot  1.2.1a
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
Classes | Typedefs | Enumerations | Functions | Variables
spot Namespace Reference

this class acts like a wrapper to the C code of the union find. More...

Classes

struct  dstar_aut
 Temporary encoding of an omega automaton produced by ltl2dstar. More...
 
class  acc_dict
 
class  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. More...
 
class  cube
 This class represents conjunction of variables. More...
 
class  fasttgba
 
struct  transition
 the structure that will store the successors of a state More...
 
class  fast_explicit_state
 
class  fast_explicit_iterator
 an iterator for fast_explicit_state More...
 
class  fasttgbaexplicit
 
class  fast_product_state
 This class represents a product state. More...
 
class  fast_product_iterator
 This is an iterator for the product. More...
 
class  fasttgba_product
 This class allows to do a synchronized product between two fast tgba. More...
 
class  fasttgba_state
 This class act as an interface for all classes. More...
 
struct  fasttgba_state_ptr_equal
 
struct  fasttgba_state_ptr_hash
 
class  fasttgba_succ_iterator
 Iterate over the successors of a state. More...
 
class  markset
 This class represents a set of acceptance marks. More...
 
class  dotty_dfs
 
class  uf
 
class  concur_ec_stat
 
class  concur_opt_tarjan_scc
 The class that will be used by thread performing a Tarjan SCC. More...
 
class  concur_opt_dijkstra_scc
 The class that will be used by thread performing a Dijkstra SCC. More...
 
class  concur_opt_tarjan_ec
 An emptiness based on the tarjan parallel computation algorithm above. More...
 
class  dead_share
 Wrapper Launch all threads. More...
 
class  deadstore
 This class represent a dead store. For now it's just a set but it can be combined with bitstate hasing. More...
 
class  dijkstra_scc
 
class  dijkstracheck
 
class  ec
 
class  instance_automaton
 A simple wrapper for an automaton. More...
 
class  instanciator
 
class  simple_instance
 
class  simple_instanciator
 
class  lazycheck
 
class  stack_of_lowlink
 
class  compressed_stack_of_lowlink
 this class represents a compaction of the lowlink stack More...
 
class  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. More...
 
class  opt_dijkstra_ec
 transform the previous algorithm into an emptiness check. Only refine specific methods More...
 
class  opt_tarjan_scc
 Compute the SCCs of a TGBA. More...
 
class  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. More...
 
class  stack_of_roots
 
class  compressed_stack_of_roots
 
class  stats
 
class  tarjan_scc
 
class  union_find
 
class  setOfDisjointSetsIPC_LRPC
 
class  setOfDisjointSetsIPC_LRPC_MS
 
class  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. More...
 
class  union_scc
 
class  unioncheck
 
class  generic_dfs
 
class  lbtt_dfs
 
class  stats_dfs
 
class  fair_kripke_succ_iterator
 Iterator code for a Fair Kripke structure. More...
 
class  fair_kripke
 Interface for a Fair Kripke structure. More...
 
class  kripke_succ_iterator
 Iterator code for Kripke structure. More...
 
class  kripke
 Interface for a Kripke structure. 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...
 
struct  bdd_less_than
 Comparison functor for BDDs. More...
 
struct  bdd_hash
 Hash functor for BDDs. More...
 
class  bitvect
 A bit vector. More...
 
class  bitvect_array
 
class  fixed_size_pool
 A fixed-size memory pool implementation. More...
 
class  printable
 
class  printable_value
 
class  printable_id
 The default callback simply writes "%c". More...
 
class  printable_percent
 Called by default for "%%" and "%\0". More...
 
class  formater
 
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*. More...
 
class  minato_isop
 Generate an irredundant sum-of-products (ISOP) form of a BDD function. More...
 
class  multiple_size_pool
 A multiple-size memory pool implementation. More...
 
class  option_map
 Manage a map of options. More...
 
class  barand
 Compute pseudo-random integer value between 0 and n included, following a binomial distribution for probability p. More...
 
class  clause_counter
 
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  temporary_file
 Temporary file name. More...
 
class  open_temporary_file
 Open temporary file. More...
 
class  unique_ptr
 Take ownership of a pointer at its construction, and destroy it at the end of the scope. More...
 
class  explicit_state_conjunction
 Basic implementation of saba_state_conjunction. More...
 
class  saba
 A State-based Alternating (Generalized) Büchi Automaton. More...
 
class  saba_complement_tgba
 Complement a TGBA and produce a SABA. More...
 
class  saba_state
 Abstract class for saba states. More...
 
struct  saba_state_ptr_less_than
 Strict Weak Ordering for saba_state*. More...
 
struct  saba_state_ptr_equal
 An Equivalence Relation for saba_state*. More...
 
struct  saba_state_ptr_hash
 Hash Function for saba_state*. More...
 
struct  saba_state_shared_ptr_less_than
 Strict Weak Ordering for shared_saba_state (shared_ptr<const saba_state*>). More...
 
struct  saba_state_shared_ptr_equal
 An Equivalence Relation for shared_saba_state (shared_ptr<const saba_state*>). More...
 
struct  saba_state_shared_ptr_hash
 Hash Function for shared_saba_state (shared_ptr<const saba_state*>). More...
 
class  saba_state_conjunction
 Iterate over a conjunction of saba_state. More...
 
class  saba_succ_iterator
 Iterate over the successors of a saba_state. 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  ta
 A Testing Automaton. More...
 
class  ta_succ_iterator
 Iterate over the successors of a state. More...
 
class  scc_stack_ta
 
class  ta_explicit
 
class  state_ta_explicit
 
class  ta_explicit_succ_iterator
 Successor iterators used by spot::ta_explicit. More...
 
class  state_ta_product
 A state for spot::ta_product. More...
 
class  ta_succ_iterator_product
 Iterate over the successors of a product computed on the fly. More...
 
class  ta_product
 A lazy product between a Testing automaton and a Kripke structure. (States are computed on the fly.) More...
 
class  ta_succ_iterator_product_by_changeset
 
class  tgta
 A Transition-based Generalized Testing Automaton (TGTA). More...
 
class  tgta_explicit
 
class  tgta_product
 A lazy product. (States are computed on the fly.) More...
 
class  tgta_succ_iterator_product
 Iterate over the successors of a product computed on the fly. More...
 
class  ta_check
 An implementation of the emptiness-check algorithm for a product between a TA and a Kripke structure. More...
 
class  ta_reachable_iterator
 Iterate over all reachable states of a spot::ta. More...
 
class  ta_reachable_iterator_depth_first
 An implementation of spot::ta_reachable_iterator that browses states depth first. More...
 
class  ta_reachable_iterator_breadth_first
 An implementation of spot::ta_reachable_iterator that browses states breadth first. More...
 
struct  ta_statistics
 
class  bdd_dict
 Map BDD variables to formulae. More...
 
class  future_conditions_collector
 Wrap a tgba to offer information about upcoming conditions. More...
 
class  sba
 A State-based Generalized Büchi Automaton. More...
 
class  state
 Abstract class for states. More...
 
struct  state_ptr_less_than
 Strict Weak Ordering for state*. More...
 
struct  state_ptr_equal
 An Equivalence Relation for state*. More...
 
struct  state_ptr_hash
 Hash Function for state*. More...
 
struct  state_shared_ptr_less_than
 Strict Weak Ordering for shared_state (shared_ptr<const state*>). More...
 
struct  state_shared_ptr_equal
 An Equivalence Relation for shared_state (shared_ptr<const state*>). More...
 
struct  state_shared_ptr_hash
 Hash Function for shared_state (shared_ptr<const state*>). More...
 
class  state_bdd
 
class  tgba_succ_iterator
 Iterate over the successors of a state. 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  set_state
 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. 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...
 
struct  destroy_key
 
struct  destroy_key< const ltl::formula * >
 
class  state_explicit
 
class  state_explicit_number
 
class  state_explicit_string
 
class  state_explicit_formula
 
class  tgba_explicit_succ_iterator
 
class  explicit_graph
 
class  tgba_explicit
 
class  sba_explicit
 
class  explicit_conf
 
class  explicit_conf< graph, state_explicit_string >
 
class  explicit_conf< graph, state_explicit_formula >
 
class  bdd_ordered
 
class  tgba_kv_complement
 Build a complemented automaton. More...
 
class  tgba_mask
 A masked TGBA (abstract). More...
 
class  state_product
 A state for spot::tgba_product. 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  tgba_proxy
 A TGBA proxy. More...
 
class  tgba_safra_complement
 Build a complemented automaton. More...
 
class  tgba_scc
 Wrap a tgba to offer information about strongly connected components. More...
 
class  tgba_sgba_proxy
 Change the labeling-mode of spot::tgba on the fly, producing a state-based generalized Büchi automaton. More...
 
class  tgba_tba_proxy
 Degeneralize a spot::tgba on the fly, producing a TBA. More...
 
class  tgba_sba_proxy
 Degeneralize a spot::tgba on the fly, producing an SBA. More...
 
class  state_union
 A state for spot::tgba_union. 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. More...
 
struct  sccs_set
 
class  enumerate_cycles
 Enumerate elementary cycles in a SCC. More...
 
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...
 
class  postprocessor
 Wrap TGBA/BA/Monitor post-processing algorithms in an easy interface. More...
 
struct  power_map
 
class  tgba_reachable_iterator
 Iterate over all reachable states of a spot::tgba. More...
 
class  tgba_reachable_iterator_breadth_first
 An implementation of spot::tgba_reachable_iterator that browses states breadth first. More...
 
class  tgba_reachable_iterator_depth_first
 Iterate over all states of an automaton using a DFS. More...
 
class  tgba_reachable_iterator_depth_first_stack
 Iterate over all states of an automaton using a DFS. More...
 
class  tgba_run_dotty_decorator
 Highlight a spot::tgba_run on a spot::tgba. 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  printable_formula
 
class  stat_printer
 prints various statistics about a TGBA More...
 
class  translator
 Translate an LTL formula into an optimized spot::tgba. More...
 
class  weight
 Manage for a given automaton a vector of counter indexed by its acceptance condition. More...
 
struct  tgba_word
 An infinite word stored as a lasso. More...
 
class  fasttgba_kripke_product
 
class  dve2product_instance
 
class  dve2product_instanciator
 
class  gspn_exception
 An exception used to forward GSPN errors. More...
 
class  gspn_interface
 
class  gspn_ssp_interface
 

Typedefs

typedef std::pair
< spot::location, std::string > 
dstar_parse_error
 A parse diagnostic with its location. More...
 
typedef std::list
< dstar_parse_error
dstar_parse_error_list
 A list of parser diagnostics, as filled by parse. More...
 
typedef int mark
 the type that represents a mark More...
 
typedef std::pair< location,
std::string > 
kripke_parse_error
 A parse diagnostic with its location. More...
 
typedef std::list
< kripke_parse_error
kripke_parse_error_list
 A list of parser diagnostics, as filled by parse. More...
 
typedef std::vector< int > sat_solution
 
typedef std::pair
< spot::location, std::string > 
neverclaim_parse_error
 A parse diagnostic with its location. More...
 
typedef std::list
< neverclaim_parse_error
neverclaim_parse_error_list
 A list of parser diagnostics, as filled by parse. More...
 
typedef boost::shared_ptr
< const saba_state
shared_saba_state
 
typedef Sgi::hash_set< const
state *, spot::state_ptr_hash,
spot::state_ptr_equal
state_set
 
typedef boost::shared_ptr
< const state
shared_state
 
typedef Sgi::hash_set
< shared_state,
state_shared_ptr_hash,
state_shared_ptr_equal
shared_state_set
 
typedef explicit_conf
< tgba_explicit
< state_explicit_string >
, state_explicit_string
tgba_explicit_string
 
typedef explicit_conf
< tgba_explicit
< state_explicit_formula >
, state_explicit_formula
tgba_explicit_formula
 
typedef explicit_conf
< tgba_explicit
< state_explicit_number >
, state_explicit_number
tgba_explicit_number
 
typedef explicit_conf
< sba_explicit
< state_explicit_string >
, state_explicit_string
sba_explicit_string
 
typedef explicit_conf
< sba_explicit
< state_explicit_formula >
, state_explicit_formula
sba_explicit_formula
 
typedef explicit_conf
< sba_explicit
< state_explicit_number >
, state_explicit_number
sba_explicit_number
 
typedef std::vector< bdd_orderedacc_list_t
 
typedef std::pair
< spot::location, std::string > 
tgba_parse_error
 A parse diagnostic with its location. More...
 
typedef std::list
< tgba_parse_error
tgba_parse_error_list
 A list of parser diagnostics, as filled by parse. More...
 
typedef Sgi::hash< std::string > string_hash
 A hash function for strings. More...
 

Enumerations

enum  dstar_type { Rabin, Streett }
 
enum  scc_strength {
  STRONG_SCC, WEAK_SCC, TERMINAL_SCC, NON_ACCEPTING_SCC,
  UNKNOWN_SCC
}
 this enum is used to provide the stregth of the SCC More...
 
enum  aut_strength { STRONG_AUT, WEAK_AUT, TERMINAL_AUT }
 
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

SPOT_API dstar_autdstar_parse (const std::string &filename, dstar_parse_error_list &error_list, bdd_dict *dict, ltl::environment &env=ltl::default_environment::instance(), bool debug=false)
 Build a spot::tgba_explicit from ltl2dstar's output. More...
 
SPOT_API bool format_dstar_parse_errors (std::ostream &os, const std::string &filename, dstar_parse_error_list &error_list)
 Format diagnostics produced by spot::dstar_parse. More...
 
SPOT_API tgbanra_to_nba (const dstar_aut *nra)
 Convert a non-deterministic Rabin automaton into a non-deterministic Büchi automaton. More...
 
SPOT_API tgbanra_to_nba (const dstar_aut *nra, const state_set *ignore)
 Convert a non-deterministic Rabin automaton into a non-deterministic Büchi automaton. More...
 
SPOT_API tgbadra_to_ba (const dstar_aut *dra, bool *dba_output=0)
 Convert a deterministic Rabin automaton into a Büchi automaton, deterministic when possible. More...
 
SPOT_API tgbansa_to_tgba (const dstar_aut *nra)
 Convert a non-deterministic Streett automaton into a non-deterministic tgba. More...
 
SPOT_API tgbadstar_to_tgba (const dstar_aut *dstar)
 Convert a Rabin or Streett automaton into a TGBA. More...
 
SPOT_API const fasttgbatgba_2_fasttgba (const spot::tgba *t, spot::ap_dict &aps, spot::acc_dict &accs)
 Perform a translation from a Tgba to a Fasttgba. More...
 
SPOT_API std::ostream & kripke_save_reachable (std::ostream &os, const kripke *k)
 Save the reachable part of Kripke structure in text format. More...
 
SPOT_API std::ostream & kripke_save_reachable_renumbered (std::ostream &os, const kripke *k)
 Save the reachable part of Kripke structure in text format. More...
 
SPOT_API kripke_explicitkripke_parse (const std::string &name, kripke_parse_error_list &error_list, bdd_dict *dict, ltl::environment &env=ltl::default_environment::instance(), bool debug=false)
 
SPOT_API 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. More...
 
SPOT_API bool is_bare_word (const char *str)
 
SPOT_API std::string quote_unless_bare_word (const std::string &str)
 Double-quote words that are not bare. More...
 
SPOT_API bdd compute_all_acceptance_conditions (bdd neg_acceptance_conditions)
 Compute all acceptance conditions from all neg acceptance conditions. More...
 
SPOT_API bdd compute_neg_acceptance_conditions (bdd all_acceptance_conditions)
 Compute neg acceptance conditions from all acceptance conditions. More...
 
SPOT_API bitvectmake_bitvect (size_t bitcount)
 Allocate a bit-vector of bitcount bits. More...
 
SPOT_API bitvect_arraymake_bitvect_array (size_t bitcount, size_t vectcount)
 Allocate vectcount bit-vectors of bitcount bits. More...
 
SPOT_API std::ostream & escape_rfc4180 (std::ostream &os, const std::string &str)
 Double characters " in strings. More...
 
SPOT_API std::ostream & escape_str (std::ostream &os, const std::string &str)
 Escape characters ", \, and \n in str. More...
 
SPOT_API std::string escape_str (const std::string &str)
 Escape characters ", \, and \n in str. More...
 
SPOT_API void trim (std::string &str)
 Remove spaces at the front and back of str. More...
 
size_t wang32_hash (size_t key)
 Thomas Wang's 32 bit hash function. More...
 
size_t knuth32_hash (size_t key)
 Knuth's Multiplicative hash function. More...
 
SPOT_API 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. More...
 
SPOT_API 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. More...
 
SPOT_API 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. More...
 
SPOT_API 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. More...
 
SPOT_API 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. More...
 
SPOT_API 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. More...
 
SPOT_API 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. More...
 
SPOT_API 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. More...
 
SPOT_API int memusage ()
 Total number of pages in use by the program. More...
 
SPOT_API void srand (unsigned int seed)
 Reset the seed of the pseudo-random number generator. More...
 
SPOT_API int rrand (int min, int max)
 Compute a pseudo-random integer value between min and max included. More...
 
SPOT_API int mrand (int max)
 Compute a pseudo-random integer value between 0 and max-1 included. More...
 
SPOT_API double drand ()
 Compute a pseudo-random double value between 0.0 and 1.0 (1.0 excluded). More...
 
SPOT_API double nrand ()
 Compute a pseudo-random double value following a standard normal distribution. (Odeh & Evans) More...
 
SPOT_API double bmrand ()
 Compute a pseudo-random double value following a standard normal distribution. (Box-Muller) More...
 
SPOT_API int prand (double p)
 Return a pseudo-random positive integer value following a Poisson distribution with parameter p. More...
 
SPOT_API int satsolver (printable *input, printable *output)
 Run a SAT solver. More...
 
SPOT_API sat_solution satsolver_get_solution (const char *filename)
 Extract the solution of a SAT solver output. More...
 
SPOT_API temporary_filethrow (std::bad_alloc, std::runtime_error)
 Create a temporary file. More...
 
SPOT_API void cleanup_tmpfiles ()
 Delete all temporary files. More...
 
template<typename T >
unique_ptr< T > make_unique (T *ptr)
 Change a pointer into a unique_ptr. More...
 
SPOT_API const char * version ()
 Return Spot's version. More...
 
SPOT_API tgba_explicit_stringneverclaim_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. More...
 
SPOT_API 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. More...
 
SPOT_API std::ostream & saba_dotty_reachable (std::ostream &os, const saba *g)
 Print reachable states in dot format. More...
 
SPOT_API std::ostream & dotty_reachable (std::ostream &os, const ta *a)
 
SPOT_API taminimize_ta (const ta *ta_)
 Construct a simplified TA by merging bisimilar states. More...
 
SPOT_API tgta_explicitminimize_tgta (const tgta_explicit *tgta_)
 Construct a simplified TGTA by merging bisimilar states. More...
 
SPOT_API std::set< const state * > get_states_set (const ta *t)
 Compute states set for an automaton. More...
 
SPOT_API ta_statistics stats_reachable (const ta *t)
 Compute statistics for an automaton. More...
 
SPOT_API ta_explicittgba_to_ta (const tgba *tgba_to_convert, bdd atomic_propositions_set, bool degeneralized=true, bool artificial_initial_state_mode=true, bool single_pass_emptiness_check=false, bool artificial_livelock_state_mode=false)
 Build a spot::ta_explicit* (TA) from an LTL formula. More...
 
SPOT_API tgta_explicittgba_to_tgta (const tgba *tgba_to_convert, bdd atomic_propositions_set)
 Build a spot::tgta_explicit* (TGTA) from an LTL formula. More...
 
SPOT_API std::ostream & bdd_print_sat (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a list of literals. More...
 
SPOT_API std::string bdd_format_sat (const bdd_dict *dict, bdd b)
 Format a BDD as a list of literals. More...
 
SPOT_API std::ostream & bdd_print_acc (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a list of acceptance conditions. More...
 
SPOT_API std::ostream & bdd_print_accset (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a set of acceptance conditions. More...
 
SPOT_API std::string bdd_format_accset (const bdd_dict *dict, bdd b)
 Format a BDD as a set of acceptance conditions. More...
 
SPOT_API std::ostream & bdd_print_set (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a set. More...
 
SPOT_API std::string bdd_format_set (const bdd_dict *dict, bdd b)
 Format a BDD as a set. More...
 
SPOT_API std::ostream & bdd_print_formula (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a formula. More...
 
SPOT_API std::string bdd_format_formula (const bdd_dict *dict, bdd b)
 Format a BDD as a formula. More...
 
SPOT_API std::ostream & bdd_print_dot (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a diagram in dotty format. More...
 
SPOT_API std::ostream & bdd_print_table (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a table. More...
 
SPOT_API void enable_utf8 ()
 Enable UTF-8 output for bdd printers. More...
 
SPOT_API std::string bdd_format_isop (const bdd_dict *dict, bdd b)
 Format a BDD as an irredundant sum of product. More...
 
SPOT_API std::ostream & bdd_print_isop (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as an irredundant sum of product. More...
 
SPOT_API bdd formula_to_bdd (const ltl::formula *f, bdd_dict *d, void *for_me)
 Convert a Boolean formula into a BDD. More...
 
SPOT_API const ltl::formulabdd_to_formula (bdd f, const bdd_dict *d)
 Convert a BDD into a formula. More...
 
void shared_state_deleter (state *s)
 
SPOT_API tgba_bdd_concreteproduct (const tgba_bdd_concrete *left, const tgba_bdd_concrete *right)
 Multiplies two spot::tgba_bdd_concrete automata. More...
 
SPOT_API const tgbabuild_tgba_mask_keep (const tgba *to_mask, const state_set &to_keep, const state *init=0)
 Mask a TGBA, keeping a given set of states. More...
 
SPOT_API const tgbabuild_tgba_mask_ignore (const tgba *to_mask, const state_set &to_ignore, const state *init=0)
 Mask a TGBA, rejecting a given set of states. More...
 
void SPOT_API display_safra (const tgba_safra_complement *a)
 Produce a dot output of the Safra automaton associated to a. More...
 
SPOT_API tgbawdba_complement (const tgba *aut)
 Complement a weak deterministic Büchi automaton. More...
 
SPOT_API tgba_explicit_numbertgba_complete (const tgba *aut)
 Complete a TGBA. More...
 
SPOT_API tgbacompsusp (const ltl::formula *f, bdd_dict *dict, bool no_wdba=false, bool no_simulation=false, bool early_susp=false, bool no_susp_product=false, bool wdba_smaller=false, bool oblig=false)
 Compositional translation algorithm with resetable suspension. More...
 
SPOT_API std::vector
< std::vector< sccs_set * > > * 
find_paths (tgba *a, const scc_map &m)
 
SPOT_API unsigned max_spanning_paths (std::vector< sccs_set * > *paths, scc_map &m)
 
SPOT_API std::list< tgba * > split_tgba (tgba *a, const scc_map &m, unsigned split_number)
 
SPOT_API sbadegeneralize (const tgba *a, bool use_z_lvl=true, bool use_cust_acc_orders=false, bool use_lvl_cache=true)
 Degeneralize a spot::tgba into an equivalent sba with only one acceptance condition. More...
 
SPOT_API std::ostream & dotty_reachable (std::ostream &os, const tgba *g, bool assume_sba=false, dotty_decorator *dd=0)
 Print reachable states in dot format. More...
 
SPOT_API tgba_explicit_numberdtba_sat_synthetize (const tgba *a, int target_state_number, bool state_based=false)
 Attempt to synthetize an equivalent deterministic TBA with a SAT solver. More...
 
SPOT_API tgba_explicit_numberdtba_sat_minimize (const tgba *a, bool state_based=false)
 Attempt to minimize a deterministic TBA with a SAT solver. More...
 
SPOT_API tgba_explicit_numberdtba_sat_minimize_dichotomy (const tgba *a, bool state_based=false)
 Attempt to minimize a deterministic TBA with a SAT solver. More...
 
SPOT_API tgba_explicit_numberdtgba_complement (const tgba *aut)
 Complement a deterministic TGBA. More...
 
SPOT_API tgba_explicit_numberdtgba_sat_synthetize (const tgba *a, unsigned target_acc_number, int target_state_number, bool state_based=false)
 Attempt to synthetize am equivalent deterministic TGBA with a SAT solver. More...
 
SPOT_API tgba_explicit_numberdtgba_sat_minimize (const tgba *a, unsigned target_acc_number, bool state_based=false)
 Attempt to minimize a deterministic TGBA with a SAT solver. More...
 
SPOT_API tgba_explicit_numberdtgba_sat_minimize_dichotomy (const tgba *a, unsigned target_acc_number, bool state_based=false)
 Attempt to minimize a deterministic TGBA with a SAT solver. More...
 
SPOT_API tgba_explicit_numbertgba_dupexp_bfs (const tgba *aut)
 Build an explicit automata from all states of aut, numbering states in bread first order as they are processed. More...
 
SPOT_API tgba_explicit_numbertgba_dupexp_dfs (const tgba *aut)
 Build an explicit automata from all states of aut, numbering states in depth first order as they are processed. More...
 
SPOT_API tgba_explicit_numbertgba_dupexp_bfs (const tgba *aut, std::map< const state *, const state *, state_ptr_less_than > &relation)
 Build an explicit automata from all states of aut, numbering states in bread first order as they are processed. More...
 
SPOT_API tgba_explicit_numbertgba_dupexp_dfs (const tgba *aut, std::map< const state *, const state *, state_ptr_less_than > &relation)
 Build an explicit automata from all states of aut, numbering states in depth first order as they are processed. More...
 
SPOT_API tgba_bdd_concreteeltl_to_tgba_lacim (const ltl::formula *f, bdd_dict *dict)
 Build a spot::tgba_bdd_concrete from an ELTL formula. More...
 
SPOT_API std::ostream & print_tgba_run (std::ostream &os, const tgba *a, const tgba_run *run)
 Display a tgba_run. More...
 
SPOT_API tgbatgba_run_to_tgba (const tgba *a, const tgba_run *run)
 Return an explicit_tgba corresponding to run (i.e. comparable states are merged). More...
 
SPOT_API emptiness_checkcouvreur99 (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. More...
 
SPOT_API emptiness_checkexplicit_gv04_check (const tgba *a, option_map o=option_map())
 Emptiness check based on Geldenhuys and Valmari's TACAS'04 paper. More...
 
SPOT_API unsigned count_nondet_states (const tgba *aut)
 Count the number of non-deterministic states in aut. More...
 
SPOT_API bool is_deterministic (const tgba *aut)
 Return true iff aut is deterministic. More...
 
SPOT_API bool is_complete (const tgba *aut)
 
SPOT_API bool is_inherently_weak_scc (scc_map &map, unsigned scc)
 Whether the SCC number scc in map is inherently weak. More...
 
SPOT_API bool is_weak_scc (scc_map &map, unsigned scc)
 Whether the SCC number scc in map is weak. More...
 
SPOT_API bool is_complete_scc (scc_map &map, unsigned scc)
 Whether the SCC number scc in map is complete. More...
 
SPOT_API bool is_syntactic_weak_scc (scc_map &map, unsigned scc)
 Whether the SCC number scc in map is syntactically weak. More...
 
SPOT_API bool is_syntactic_terminal_scc (scc_map &map, unsigned scc)
 Whether the SCC number scc in map is syntactically terminal. More...
 
SPOT_API bool is_terminal_scc (scc_map &map, unsigned scc)
 Whether the SCC number scc in map is terminal. More...
 
SPOT_API std::ostream & lbtt_reachable (std::ostream &os, const tgba *g, bool sba=false)
 Print reachable states in LBTT's format. More...
 
SPOT_API const tgbalbtt_parse (std::istream &is, std::string &error, bdd_dict *dict, ltl::environment &env=ltl::default_environment::instance(), ltl::environment &envacc=ltl::default_environment::instance())
 Read an automaton in LBTT's format. More...
 
SPOT_API taa_tgbaltl_to_taa (const ltl::formula *f, bdd_dict *dict, bool refined_rules=false)
 Build a spot::taa* from an LTL formula. More...
 
SPOT_API tgba_explicit_formulaltl_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, ltl::ltl_simplifier *simplifier=0)
 Build a spot::tgba_explicit* from an LTL formula. More...
 
SPOT_API tgba_bdd_concreteltl_to_tgba_lacim (const ltl::formula *f, bdd_dict *dict)
 Build a spot::tgba_bdd_concrete from an LTL formula. More...
 
SPOT_API emptiness_checkexplicit_magic_search (const tgba *a, option_map o=option_map())
 Returns an emptiness checker on the spot::tgba automaton a. More...
 
SPOT_API emptiness_checkbit_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. More...
 
SPOT_API emptiness_checkmagic_search (const tgba *a, option_map o=option_map())
 Wrapper for the two magic_search implementations. More...
 
SPOT_API sba_explicit_numberminimize_monitor (const tgba *a)
 Construct a minimal deterministic monitor. More...
 
SPOT_API sba_explicit_numberminimize_wdba (const tgba *a)
 Minimize a Büchi automaton in the WDBA class. More...
 
SPOT_API tgbaminimize_obligation (const tgba *aut_f, const ltl::formula *f=0, const tgba *aut_neg_f=0, bool reject_bigger=false)
 Minimize an automaton if it represents an obligation property. More...
 
SPOT_API 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. More...
 
SPOT_API tgba_explicit_numbertba_determinize (const tgba *aut, unsigned threshold_states=0, unsigned threshold_cycles=0)
 Determinize a TBA using the powerset construction. More...
 
SPOT_API tgbatba_determinize_check (const tgba *aut, unsigned threshold_states=0, unsigned threshold_cycles=0, const ltl::formula *f=0, const tgba *neg_aut=0)
 Determinize a TBA and make sure it is correct. More...
 
SPOT_API tgba_runproject_tgba_run (const tgba *a_run, const tgba *a_proj, const tgba_run *run)
 Project a tgba_run on a tgba. More...
 
SPOT_API tgbarandom_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=&ltl::default_environment::instance())
 Construct a tgba randomly. More...
 
SPOT_API tgba_runreduce_run (const tgba *a, const tgba_run *org)
 Reduce an accepting run. More...
 
SPOT_API SPOT_DEPRECATED const
tgba
reduc_tgba_sim (const tgba *a, int opt=Reduce_All)
 Simplify the automaton using a simulation relation. More...
 
SPOT_API bool replay_tgba_run (std::ostream &os, const tgba *a, const tgba_run *run, bool debug=false)
 Replay a tgba_run on a tgba. More...
 
SPOT_API bool is_guarantee_automaton (const tgba *aut, const scc_map *sm=0)
 Whether an automaton represents a guarantee property. More...
 
SPOT_API bool is_safety_mwdba (const tgba *aut)
 Whether a minimized WDBA represents a safety property. More...
 
SPOT_API std::ostream & tgba_save_reachable (std::ostream &os, const tgba *g)
 Save reachable states in text format. More...
 
SPOT_API scc_stats build_scc_stats (const tgba *a)
 
SPOT_API scc_stats build_scc_stats (const scc_map &m)
 
SPOT_API std::ostream & dump_scc_dot (const tgba *a, std::ostream &out, bool verbose=false)
 
SPOT_API std::ostream & dump_scc_dot (const scc_map &m, std::ostream &out, bool verbose=false)
 
SPOT_API tgbascc_filter (const tgba *aut, bool remove_all_useless=false, scc_map *given_sm=0, bdd susp=bddtrue, bool early_susp=false, bdd ignored=bddtrue)
 Prune unaccepting SCCs and remove superfluous acceptance conditions. More...
 
SPOT_API tgbascc_filter_states (const tgba *aut, scc_map *given_sm=0)
 Prune unaccepting SCCs. More...
 
SPOT_API emptiness_checkexplicit_se05_search (const tgba *a, option_map o=option_map())
 Returns an emptiness check on the spot::tgba automaton a. More...
 
SPOT_API emptiness_checkbit_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. More...
 
SPOT_API emptiness_checkse05 (const tgba *a, option_map o)
 Wrapper for the two se05 implementations. More...
 
SPOT_API tgbasimulation (const tgba *automaton)
 Attempt to reduce the automaton by direct simulation. More...
 
SPOT_API tgbasimulation_sba (const tgba *automaton)
 
SPOT_API tgbadont_care_simulation (const tgba *t, int limit=-1)
 
SPOT_API tgbadont_care_iterated_simulations (const tgba *t, int limit=-1)
 
SPOT_API tgba_statistics stats_reachable (const tgba *g)
 Compute statistics for an automaton. More...
 
SPOT_API tgba_sub_statistics sub_stats_reachable (const tgba *g)
 Compute subended statistics for an automaton. More...
 
SPOT_API sba_explicit_numberstrip_acceptance (const tgba *a)
 Duplicate automaton a, removing all acceptance sets. More...
 
SPOT_API emptiness_checkexplicit_tau03_search (const tgba *a, option_map o=option_map())
 Returns an emptiness checker on the spot::tgba automaton a. More...
 
SPOT_API emptiness_checkexplicit_tau03_opt_search (const tgba *a, option_map o=option_map())
 Returns an emptiness checker on the spot::tgba automaton a. More...
 
SPOT_API tgba_explicit_stringtgba_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. More...
 
SPOT_API 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. More...
 
SPOT_API kripkeload_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)
 
SPOT_API const spot::fasttgbaload_dve2fast (const std::string &file, spot::ap_dict &aps, spot::acc_dict &accs, bool verbose=true)
 
std::ostream & operator<< (std::ostream &os, const gspn_exception &e)
 
couvreur99_checkcouvreur99_check_ssp_semi (const tgba *ssp_automata)
 
couvreur99_checkcouvreur99_check_ssp_shy_semi (const tgba *ssp_automata)
 
couvreur99_checkcouvreur99_check_ssp_shy (const tgba *ssp_automata, bool stack_inclusion=true, bool double_inclusion=false, bool reversed_double_inclusion=false, bool no_decomp=false)
 
SPOT_API tgba_explicit_numbertgba_powerset (const tgba *aut, power_map &pm, bool merge=true)
 Build a deterministic automaton, ignoring acceptance conditions. More...
 
SPOT_API tgba_explicit_numbertgba_powerset (const tgba *aut)
 
SPOT_API tgbacosimulation (const tgba *automaton)
 Attempt to reduce the automaton by reverse simulation. More...
 
SPOT_API tgbacosimulation_sba (const tgba *automaton)
 
SPOT_API tgbaiterated_simulations (const tgba *automaton)
 Iterate simulation() and cosimulation(). More...
 
SPOT_API tgbaiterated_simulations_sba (const tgba *automaton)
 

Variables

std::mutex mutex_load_dve
 

Detailed Description

this class acts like a wrapper to the C code of the union find.

The Union find has been built using a C++ version of the concurent_hash_map that can be downloaded at :

Therefore this version includes many adaptation that comes from the LTSmin tool that can be download here :

Typedef Documentation

typedef std::pair<location, std::string> spot::kripke_parse_error

A parse diagnostic with its location.

A list of parser diagnostics, as filled by parse.

typedef int spot::mark

the type that represents a mark

Enumeration Type Documentation

this enum is used to provide the stregth of the SCC

Function Documentation

SPOT_API 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.

Parameters
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
Returns
The BDD formated as a string.
SPOT_API std::string spot::bdd_format_formula ( const bdd_dict *  dict,
bdd  b 
)

Format a BDD as a formula.

Parameters
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
Returns
The BDD formated as a string.
SPOT_API std::string spot::bdd_format_isop ( const bdd_dict *  dict,
bdd  b 
)

Format a BDD as an irredundant sum of product.

Parameters
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
Returns
The BDD formated as a string.
SPOT_API 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.

Parameters
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
Returns
The BDD formated as a string.
SPOT_API std::string spot::bdd_format_set ( const bdd_dict *  dict,
bdd  b 
)

Format a BDD as a set.

Parameters
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
Returns
The BDD formated as a string.
SPOT_API 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.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
Returns
The BDD formated as a string.
SPOT_API 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.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
Returns
The BDD formated as a string.
SPOT_API std::ostream& spot::bdd_print_dot ( std::ostream &  os,
const bdd_dict *  dict,
bdd  b 
)

Print a BDD as a diagram in dotty format.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
SPOT_API std::ostream& spot::bdd_print_formula ( std::ostream &  os,
const bdd_dict *  dict,
bdd  b 
)

Print a BDD as a formula.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
SPOT_API std::ostream& spot::bdd_print_isop ( std::ostream &  os,
const bdd_dict *  dict,
bdd  b 
)

Print a BDD as an irredundant sum of product.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
SPOT_API 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.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
SPOT_API std::ostream& spot::bdd_print_set ( std::ostream &  os,
const bdd_dict *  dict,
bdd  b 
)

Print a BDD as a set.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
SPOT_API std::ostream& spot::bdd_print_table ( std::ostream &  os,
const bdd_dict *  dict,
bdd  b 
)

Print a BDD as a table.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.
SPOT_API const ltl::formula* spot::bdd_to_formula ( bdd  f,
const bdd_dict *  d 
)

Convert a BDD into a formula.

Format the BDD as an irredundant sum of product (see the minato_isop class for details) and map the BDD variables back into their atomic propositions. This works only for Boolean formulas, and all the BDD variables used in f should have been registered in d. Although the result has type ltl::formula*, it obviously does not use any temporal operator.

SPOT_API tgba* spot::compsusp ( const ltl::formula *  f,
bdd_dict *  dict,
bool  no_wdba = false,
bool  no_simulation = false,
bool  early_susp = false,
bool  no_susp_product = false,
bool  wdba_smaller = false,
bool  oblig = false 
)

Compositional translation algorithm with resetable suspension.

Described in "Compositional Approach to Suspension and Other Improvements to LTL Translation", Tomáš Babiak, Thomas Badie, Alexandre Duret-Lutz, Mojmír Křetínský, Jan Strejček (SPIN'13).

If no_wdba or no_simulation is true, the corresponding operation is not performed on the skeleton automaton. If early_susp is true, then composition starts on the transition that enters the accepting SCC, not just in the SCC itself. If no_susp_product is true, then the composition is not performed and the skeleton automaton is returned for debugging. If wdba_smaller is true, then the WDBA-minimization of the skeleton is used only if it produces a smaller automaton.

Finally the oblig flag is a work in progress and should not be set to true.

This interface is subject to change, and clients aiming for long-term stability should better use the services of the spot::translator class instead.

SPOT_API bdd spot::compute_all_acceptance_conditions ( bdd  neg_acceptance_conditions)

Compute all acceptance conditions from all neg acceptance conditions.

SPOT_API bdd spot::compute_neg_acceptance_conditions ( bdd  all_acceptance_conditions)

Compute neg acceptance conditions from all acceptance conditions.

Referenced by spot::explicit_graph< State, tgba >::set_acceptance_conditions().

void SPOT_API spot::display_safra ( const tgba_safra_complement *  a)

Produce a dot output of the Safra automaton associated to a.

Parameters
aThe tgba_safra_complement with an intermediate Safra automaton to display
SPOT_API tgba_explicit_number* spot::dtba_sat_minimize ( const tgba *  a,
bool  state_based = false 
)

Attempt to minimize a deterministic TBA with a SAT solver.

This calls dtba_sat_synthetize() in a loop, with a decreasing number of states, and returns the last successfully built TBA.

If no smaller TBA exist, this returns a null pointer.

SPOT_API tgba_explicit_number* spot::dtba_sat_minimize_dichotomy ( const tgba *  a,
bool  state_based = false 
)

Attempt to minimize a deterministic TBA with a SAT solver.

This calls dtba_sat_synthetize() in a loop, but attempting to find the minimum number of states using a binary search. If no smaller TBA exist, this returns a null pointer.

SPOT_API tgba_explicit_number* spot::dtba_sat_synthetize ( const tgba *  a,
int  target_state_number,
bool  state_based = false 
)

Attempt to synthetize an equivalent deterministic TBA with a SAT solver.

Parameters
athe input TGBA. It should have only one acceptance set and be deterministic. I.e., it should be a deterministic TBA.
target_state_numberthe desired number of states wanted in the resulting automaton. The result may have less than target_state_number reachable states.
state_basedset to true to force all outgoing transitions of a state to share the same acceptance condition, effectively turning the TBA into a BA.

If no equivalent deterministic TBA with target_state_number states is found, a null pointer

SPOT_API tgba_explicit_number* spot::dtgba_complement ( const tgba *  aut)

Complement a deterministic TGBA.

The automaton aut should be deterministic. It does no need to be complete. Acceptance can be transition-based, or state-based. The resulting automaton is very unlikely to be deterministic.

SPOT_API tgba_explicit_number* spot::dtgba_sat_minimize ( const tgba *  a,
unsigned  target_acc_number,
bool  state_based = false 
)

Attempt to minimize a deterministic TGBA with a SAT solver.

This calls dtgba_sat_synthetize() in a loop, with a decreasing number of states, and returns the last successfully built TGBA.

If no smaller TGBA exist, this returns a null pointer.

SPOT_API tgba_explicit_number* spot::dtgba_sat_minimize_dichotomy ( const tgba *  a,
unsigned  target_acc_number,
bool  state_based = false 
)

Attempt to minimize a deterministic TGBA with a SAT solver.

This calls dtgba_sat_synthetize() in a loop, but attempting to find the minimum number of states using a binary search. If no smaller TBA exist, this returns a null pointer.

SPOT_API tgba_explicit_number* spot::dtgba_sat_synthetize ( const tgba *  a,
unsigned  target_acc_number,
int  target_state_number,
bool  state_based = false 
)

Attempt to synthetize am equivalent deterministic TGBA with a SAT solver.

Parameters
athe input TGBA. It should be a deterministic TGBA.
target_acc_numberis the number of acceptance sets wanted in the result.
target_state_numberis the desired number of states in the result. The output may have less than target_state_number reachable states.
state_basedset to true to force all outgoing transitions of a state to share the same acceptance conditions, effectively turning the TGBA into a TBA.

This functions attempts to find a TGBA with target_acc_number acceptance sets and target_state_number states that is equivalent to a. If no such TGBA is found, a null pointer is returned.

SPOT_API void spot::enable_utf8 ( )

Enable UTF-8 output for bdd printers.

SPOT_API 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.

Parameters
osWhere diagnostics should be output.
filenameThe filename that should appear in the diagnostics.
error_listThe error list filled by spot::ltl::parse while parsing ltl_string.
Returns
true if any diagnostic was output.
SPOT_API bdd spot::formula_to_bdd ( const ltl::formula *  f,
bdd_dict *  d,
void *  for_me 
)

Convert a Boolean formula into a BDD.

Convert the Boolean formula f into a BDD, using existing variables from d, and registering new ones as necessary. for_me, the address of the user of these BDD variables will be passed to d when registering the variables.

If you only use the BDD representation temporarily, for instance passing it right away to bdd_to_formula(), you should not forget to unregister the variables that have been registered for for_me. See bdd_dict::unregister_all_my_variables().

SPOT_API std::set<const state*> spot::get_states_set ( const ta *  t)

Compute states set for an automaton.

SPOT_API 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.

Parameters
autthe automaton to check
sman scc_map of the automaton if available (it will be built otherwise. If you supply an scc_map you should call build_map() before passing it to this function.
SPOT_API 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.

Parameters
autthe automaton to check
template<typename T >
unique_ptr<T> spot::make_unique ( T *  ptr)
inline

Change a pointer into a unique_ptr.

SPOT_API int spot::memusage ( )

Total number of pages in use by the program.

Returns
The total number of pages in use by the program if known. -1 otherwise.
SPOT_API std::ostream& spot::saba_dotty_reachable ( std::ostream &  os,
const saba *  g 
)

Print reachable states in dot format.

SPOT_API int spot::satsolver ( printable *  input,
printable *  output 
)

Run a SAT solver.

Run a SAT solver using the input in file input, and sending output in file output.

These two arguments are instance of printable, as they will be evaluated in a %-escaped string such as "satsolver %I >%O" This command can be overridden using the SPOT_SATSOLVER environment variable.

Note that temporary_file instances implement the printable interface.

SPOT_API sat_solution spot::satsolver_get_solution ( const char *  filename)

Extract the solution of a SAT solver output.

SPOT_API tgba* spot::scc_filter ( const tgba *  aut,
bool  remove_all_useless = false,
scc_map *  given_sm = 0,
bdd  susp = bddtrue,
bool  early_susp = false,
bdd  ignored = bddtrue 
)

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.

If given_sm is supplied, the function will use its result without computing a map of its own.

If susp is different from bddtrue, it should be a conjunction of (positive) variables to be removed from transitions going to non-accepting SCCs. If early_susp is false, the previous variable are also removed from transitions entering an accepting SCC. ignored is a conjunction of positive variables that should be removed everywhere.

Warning
Calling scc_filter on a TGBA that has the SBA property (i.e., transitions leaving accepting states are all marked as accepting) may destroy this property. Use scc_filter_states() instead.
SPOT_API tgba* spot::scc_filter_states ( const tgba *  aut,
scc_map *  given_sm = 0 
)

Prune unaccepting SCCs.

This is an abridged version of scc_filter(), that only remove useless states, without touching at the acceptance conditions.

Especially, if the input TGBA has the SBA property, (i.e., transitions leaving accepting states are all marked as accepting), then the output TGBA will also have that property.

SPOT_API tgba_explicit_number* spot::tba_determinize ( const tgba *  aut,
unsigned  threshold_states = 0,
unsigned  threshold_cycles = 0 
)

Determinize a TBA using the powerset construction.

The input automaton should have at most one acceptance
condition.  Beware that not all Büchi automata can be
determinized, and this procedure does not ensure that the
produced automaton is equivalent to \a aut.

The construction is adapted from Section 3.2 of:
/// @InProceedings{       dax.07.atva,
///   author      = {Christian Dax and Jochen Eisinger and Felix Klaedtke},
///   title     = {Mechanizing the Powerset Construction for Restricted
///                  Classes of {$\omega$}-Automata},
///   year      = 2007,
///   series      = {Lecture Notes in Computer Science},
///   publisher = {Springer-Verlag},
///   volume      = 4762,
///   booktitle = {Proceedings of the 5th International Symposium on
///                  Automated Technology for Verification and Analysis
///                  (ATVA'07)},
///   editor      = {Kedar S. Namjoshi and Tomohiro Yoneda and Teruo Higashino
///                  and Yoshio Okamura},
///   month     = oct
/// }
/// 

only adapted to work on TBA rather than BA.

If threshold_states is non null, abort the construction whenever it would build an automaton that is more than threshold_states time bigger (in term of states) than the original automaton.

If threshold_cycles is non null, abort the construction whenever an SCC of the constructed automaton has more than threshold_cycles cycles.

SPOT_API tgba* spot::tba_determinize_check ( const tgba *  aut,
unsigned  threshold_states = 0,
unsigned  threshold_cycles = 0,
const ltl::formula *  f = 0,
const tgba *  neg_aut = 0 
)

Determinize a TBA and make sure it is correct.

Apply tba_determinize(), then check that the result is equivalent. If it isn't, return the original automaton.

Only one of f or neg_aut needs to be supplied. If neg_aut is not given, it will be built from f.

Parameters
autthe automaton to minimize
threshold_statesif non null, abort the construction whenever it would build an automaton that is more than threshold time bigger (in term of states) than the original automaton.
threshold_cyclescan be used to abort the construction if the number of cycles in a SCC of the constructed automaton is bigger than the supplied value.
fthe formula represented by the original automaton
neg_autan automaton representing the negation of aut
Returns
a new tgba if the automaton could be determinized, aut if the automaton cannot be determinized, 0 if we do not know if the determinization is correct because neither f nor neg_aut were supplied.
SPOT_API const fasttgba* spot::tgba_2_fasttgba ( const spot::tgba t,
spot::ap_dict aps,
spot::acc_dict accs 
)

Perform a translation from a Tgba to a Fasttgba.

This method is the only method that should use old Tgba param t the source tgba param aps the dictionnary of atomic propositions param accs the dictionnary of acceptance set

SPOT_API tgba_explicit_number* spot::tgba_complete ( const tgba *  aut)

Complete a TGBA.


Please direct any question, comment, or bug report to the Spot mailing list at spot@lrde.epita.fr.
Generated on Tue Jan 21 2014 16:52:01 for spot by doxygen 1.8.5