spot  2.3.3.dev
Classes | Typedefs | Enumerations | Functions | Variables
spot Namespace Reference

Classes

class  acc_cond
 
class  acss_statistics
 Accepting Cycle Search Space statistics. More...
 
class  ars_statistics
 Accepting Run Search statistics. More...
 
struct  automaton_parser_options
 
class  automaton_stream_parser
 Parse a stream of automata. More...
 
class  barand
 Compute pseudo-random integer value between 0 and n included, following a binomial distribution with probability p. More...
 
class  bdd_dict
 Map BDD variables to formulae. More...
 
struct  bdd_hash
 Hash functor for BDDs. More...
 
struct  bdd_less_than
 Comparison functor for BDDs. More...
 
class  bfs_steps
 Make a BFS in a spot::tgba to compute a twa_run::steps. More...
 
class  bitvect
 A bit vector. More...
 
class  bitvect_array
 
struct  char_ptr_less_than
 Strict Weak Ordering for char*. More...
 
class  count_valid
 
class  couvreur99_check
 An implementation of the Couvreur99 emptiness-check algorithm. More...
 
class  couvreur99_check_result
 Compute a counter example from a spot::couvreur99_check_status. More...
 
class  couvreur99_check_shy
 A version of spot::couvreur99_check that tries to visit known states first. More...
 
class  couvreur99_check_status
 The status of the emptiness-check on success. More...
 
class  cspins_iterator
 
struct  cspins_state_equal
 This class provides the ability to compare two states. More...
 
struct  cspins_state_hash
 This class provides the ability to hash a state. More...
 
struct  cspins_state_hasher
 This class provides a hasher as required by the bricks classes. More...
 
class  cspins_state_manager
 The management of states (i.e. allocation/deallocation) can be painless since every time we have to consider wether the state will be compressed or not. This class aims to simplify this management. More...
 
class  cstate
 
class  cubeset
 
class  declarative_environment
 A declarative environment. More...
 
class  default_environment
 A laxist environment. More...
 
class  digraph
 A directed graph. More...
 
class  ec_renault13lpar
 This class implements the sequential emptiness check as presented in "Three SCC-based Emptiness Checks for Generalized B\¨uchi Automata" (Renault et al, LPAR 2013). Among the three emptiness check that has been proposed we opted to implement the Gabow's one. More...
 
class  ec_statistics
 Emptiness-check statistics. More...
 
class  emptiness_check
 Common interface to emptiness check algorithms. More...
 
class  emptiness_check_instantiator
 Dynamically create emptiness checks. Given their name and options. More...
 
class  emptiness_check_result
 The result of an emptiness check. More...
 
class  enumerate_cycles
 Enumerate elementary cycles in a SCC. More...
 
class  environment
 An environment that describes atomic propositions. More...
 
class  exclusive_ap
 
class  fair_kripke
 Interface for a Fair Kripke structure. More...
 
class  fair_kripke_succ_iterator
 Iterator code for a Fair Kripke structure. More...
 
class  fixed_size_pool
 A fixed-size memory pool implementation. More...
 
class  fnode
 Actual storage for formula nodes. More...
 
class  formater
 
class  formula
 Main class for temporal logic formula. More...
 
struct  formula_ptr_less_than_bool_first
 
struct  hoa_abort
 
struct  identity_hash
 A hash function that returns identity. More...
 
struct  inner_callback_parameters
 
class  int_unionfind
 This Union-Find data structure is a particular union-find, dedicated for emptiness checks below, see ec.hh. The key of this union-find is int. Moreover, we suppose that only consecutive int are inserted. This union-find includes most of the classical optimisations (IPC, LR, PC, MS). More...
 
class  interpolate
 
class  intersect
 This class explores (with a DFS) a product between a system and a twa. This exploration is performed on-the-fly. Since this exploration aims to be a generic we need to define hooks to the various emptiness checks. Actually, we use "mixins templates" in order to efficiently call emptiness check procedure. This means that we add a template EmptinessCheck that will be called though four functions: More...
 
class  isomorphism_checker
 Check if two automata are isomorphic. More...
 
struct  istats
 Wrapper to accumulate results from intersection and emptiness checks. More...
 
class  kripke
 Interface for a Kripke structure. More...
 
class  kripke_graph
 Kripke Structure. More...
 
struct  kripke_graph_state
 Concrete class for kripke_graph states. More...
 
class  kripke_graph_succ_iterator
 
class  kripke_succ_iterator
 Iterator code for Kripke structure. More...
 
class  kripke_to_twa
 
class  kripkecube
 This class is a template representation of a Kripke structure. It is composed of two template parameters: State represents a state of the Kripke structure, SuccIterator is an iterator over the (possible) successors of a state. More...
 
class  kripkecube< cspins_state, cspins_iterator >
 
class  language_containment_checker
 Check containment between LTL formulae. More...
 
class  ltsmin_model
 
class  mark_tools
 
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  named_graph
 
class  open_temporary_file
 Open temporary file. More...
 
class  option_map
 Manage a map of options. More...
 
class  outedge_combiner
 Helper class combine outgoing edges in alternating automata. More...
 
struct  pair_hash
 
struct  parse_error
 
struct  parsed_aut
 Result of the automaton parser. More...
 
struct  parsed_formula
 The result of a formula parser. More...
 
class  postprocessor
 Wrap TGBA/BA/Monitor post-processing algorithms in an easy interface. More...
 
struct  power_map
 
class  printable
 
class  printable_formula
 
class  printable_id
 The default callback simply writes "%c". More...
 
class  printable_percent
 Called by default for "%%" and "%\0". More...
 
class  printable_scc_info
 
class  printable_value
 
class  product_to_twa
 
struct  ptr_hash
 A hash function for pointers. More...
 
class  randltlgenerator
 
class  random_boolean
 Generate random Boolean formulae. More...
 
class  random_formula
 Base class for random formula generators. More...
 
class  random_ltl
 Generate random LTL formulae. More...
 
class  random_psl
 Generate random PSL formulae. More...
 
class  random_sere
 Generate random SERE. More...
 
class  remove_ap
 
class  satsolver
 Interface with a SAT solver. More...
 
class  satsolver_command
 Interface with a given sat solver. More...
 
class  scc_info
 Compute an SCC map and gather assorted information. More...
 
class  scc_info_node
 Storage for SCC related information. More...
 
class  scc_stack
 
class  scc_stack_ta
 
class  seq_reach_kripke
 This template class provide a sequential reachability of a kripkecube. The algorithm uses a single DFS since it is the most efficient in a sequential setting. More...
 
class  set_state
 Set of states deriving from spot::state. More...
 
struct  spins_interface
 
class  stat_printer
 prints various statistics about a TGBA More...
 
class  state
 Abstract class for states. More...
 
class  state_product
 A state for spot::twa_product. More...
 
struct  state_ptr_equal
 An Equivalence Relation for state*. More...
 
struct  state_ptr_hash
 Hash Function for state*. More...
 
struct  state_ptr_less_than
 Strict Weak Ordering for 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...
 
struct  state_shared_ptr_less_than
 Strict Weak Ordering for shared_state (shared_ptr<const state*>). More...
 
class  state_ta_explicit
 
class  state_ta_product
 A state for spot::ta_product. More...
 
class  state_unicity_table
 Render state pointers unique via a hash table. More...
 
struct  stopwatch
 A simple stopwatch. More...
 
class  swarmed_dfs
 
class  swarmed_gp
 
class  ta
 A Testing Automaton. More...
 
class  ta_check
 An implementation of the emptiness-check algorithm for a product between a TA and a Kripke structure. More...
 
class  ta_explicit
 
class  ta_explicit_succ_iterator
 Successor iterators used by spot::ta_explicit. More...
 
class  ta_product
 A lazy product between a Testing automaton and a Kripke structure. (States are computed on the fly.) More...
 
class  ta_reachable_iterator
 Iterate over all reachable states of a spot::ta. More...
 
class  ta_reachable_iterator_breadth_first
 An implementation of spot::ta_reachable_iterator that browses states breadth first. More...
 
class  ta_reachable_iterator_depth_first
 An implementation of spot::ta_reachable_iterator that browses states depth first. More...
 
struct  ta_statistics
 
class  ta_succ_iterator
 Iterate over the successors of a state. More...
 
class  ta_succ_iterator_product
 Iterate over the successors of a product computed on the fly. More...
 
class  ta_succ_iterator_product_by_changeset
 
class  taa_succ_iterator
 
class  taa_tgba
 A self-loop Transition-based Alternating Automaton (TAA) which is seen as a TGBA (abstract class, see below). More...
 
class  taa_tgba_formula
 
class  taa_tgba_labelled
 
class  taa_tgba_string
 
class  temporary_file
 Temporary file name. More...
 
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...
 
struct  time_info
 A structure to record elapsed time in clock ticks. More...
 
class  timer
 
class  timer_map
 A map of timer, where each timer has a name. More...
 
class  tl_simplifier
 Rewrite or simplify f in various ways. More...
 
class  tl_simplifier_options
 
class  trans_index
 
class  transition
 
struct  transition_info
 
class  translator
 Translate an LTL formula into an optimized spot::tgba. More...
 
class  trival
 A class implementing Kleene's three-valued logic. More...
 
class  twa
 A Transition-based ω-Automaton. More...
 
class  twa_graph
 
struct  twa_graph_edge_data
 
struct  twa_graph_state
 
class  twa_graph_succ_iterator
 
class  twa_product
 A lazy product. (States are computed on the fly.) More...
 
class  twa_product_init
 A lazy product with different initial states. More...
 
class  twa_reachable_iterator
 Iterate over all reachable states of a spot::tgba. More...
 
class  twa_reachable_iterator_breadth_first
 An implementation of spot::twa_reachable_iterator that browses states breadth first. More...
 
class  twa_reachable_iterator_depth_first
 Iterate over all states of an automaton using a DFS. More...
 
class  twa_reachable_iterator_depth_first_stack
 Iterate over all states of an automaton using a DFS. More...
 
struct  twa_run
 An accepted run, for a twa. More...
 
struct  twa_statistics
 
struct  twa_sub_statistics
 
class  twa_succ_iterator
 Iterate over the successors of a state. More...
 
struct  twa_word
 An infinite word stored as a lasso. More...
 
class  twacube
 
class  unabbreviator
 Clone and rewrite a formula to remove specified operators logical operators. More...
 
struct  unsigned_statistics
 

Typedefs

typedef std::shared_ptr< fair_kripkefair_kripke_ptr
 
typedef std::shared_ptr< const fair_kripkeconst_fair_kripke_ptr
 
typedef std::shared_ptr< kripkekripke_ptr
 
typedef std::shared_ptr< const kripkeconst_kripke_ptr
 
typedef std::shared_ptr< const kripke_explicit > const_kripke_explicit_ptr
 
typedef std::shared_ptr< kripke_explicit > kripke_explicit_ptr
 
typedef std::shared_ptr< kripke_graphkripke_graph_ptr
 
typedef struct spot::transition_info transition_info_t
 
typedef void(* TransitionCB) (void *ctx, transition_info_t *transition_info, int *dst)
 
using spins_interface_ptr = std::shared_ptr< const spins_interface >
 
typedef int * cspins_state
 A Spins state is represented as an array of integer Note that this array has two reserved slots (position 0 an 1). More...
 
typedef brick::hashset::FastConcurrent< cspins_state, cspins_state_hashercspins_state_map
 Shortcut to avoid long names... More...
 
typedef std::shared_ptr< spot::kripkecube< spot::cspins_state, spot::cspins_iterator > > ltsmin_kripkecube_ptr
 shortcut to manipulate the kripke below More...
 
typedef std::hash< std::string > string_hash
 A hash function for strings. More...
 
typedef std::pair< spot::location, std::string > parse_aut_error
 A parse diagnostic with its location. More...
 
typedef std::list< parse_aut_errorparse_aut_error_list
 A list of parser diagnostics, as filled by parse. More...
 
typedef std::shared_ptr< parsed_autparsed_aut_ptr
 
typedef std::shared_ptr< const parsed_autconst_parsed_aut_ptr
 
typedef std::shared_ptr< tata_ptr
 
typedef std::shared_ptr< const taconst_ta_ptr
 
typedef std::shared_ptr< ta_explicitta_explicit_ptr
 
typedef std::shared_ptr< const ta_explicitconst_ta_explicit_ptr
 
typedef std::shared_ptr< ta_productta_product_ptr
 
typedef std::shared_ptr< const ta_productconst_ta_product_ptr
 
typedef std::shared_ptr< tgtatgta_ptr
 
typedef std::shared_ptr< const tgtaconst_tgta_ptr
 
typedef std::shared_ptr< tgta_explicittgta_explicit_ptr
 
typedef std::shared_ptr< const tgta_explicitconst_tgta_explicit_ptr
 
typedef std::set< formulaatomic_prop_set
 Set of atomic propositions. More...
 
typedef std::pair< location, std::string > one_parse_error
 A parse diagnostic with its location. More...
 
typedef std::list< one_parse_errorparse_error_list
 A list of parser diagnostics, as filled by parse. More...
 
typedef std::map< formula, formularelabeling_map
 
typedef std::unordered_map< formula, formulasnf_cache
 
typedef std::shared_ptr< bdd_dictbdd_dict_ptr
 
typedef std::shared_ptr< twatwa_ptr
 
typedef std::shared_ptr< const twaconst_twa_ptr
 
typedef std::shared_ptr< const twa_graphconst_twa_graph_ptr
 
typedef std::shared_ptr< twa_graphtwa_graph_ptr
 
typedef std::shared_ptr< const twa_productconst_twa_product_ptr
 
typedef std::shared_ptr< twa_producttwa_product_ptr
 
typedef std::shared_ptr< taa_tgba_stringtaa_tgba_string_ptr
 
typedef std::shared_ptr< const taa_tgba_stringconst_taa_tgba_string_ptr
 
typedef std::shared_ptr< taa_tgba_formulataa_tgba_formula_ptr
 
typedef std::shared_ptr< const taa_tgba_formulaconst_taa_tgba_formula_ptr
 
typedef std::shared_ptr< twa_runtwa_run_ptr
 
typedef std::shared_ptr< twa_wordtwa_word_ptr
 
typedef std::unordered_set< const state *, state_ptr_hash, state_ptr_equalstate_set
 Unordered set of abstract states. More...
 
template<class val >
using state_map = std::unordered_map< const state *, val, state_ptr_hash, state_ptr_equal >
 Unordered map of abstract states. More...
 
typedef std::shared_ptr< const stateshared_state
 
typedef std::unordered_set< shared_state, state_shared_ptr_hash, state_shared_ptr_equalshared_state_set
 Unordered set of shared states. More...
 
typedef std::shared_ptr< const twa_runconst_twa_run_ptr
 
typedef std::shared_ptr< emptiness_check_resultemptiness_check_result_ptr
 
typedef std::shared_ptr< emptiness_checkemptiness_check_ptr
 
typedef std::shared_ptr< emptiness_check_instantiatoremptiness_check_instantiator_ptr
 
typedef std::vector< std::pair< unsigned, unsigned > > product_states
 
using cube = unsigned *
 A cube is only a set of bits in memory. More...
 
typedef std::shared_ptr< twacubetwacube_ptr
 
typedef std::shared_ptr< const twacubeconst_twacube_ptr
 

Enumerations

enum  parsed_aut_type {
  HOA, NeverClaim, LBTT, DRA,
  DSA, Unknown
}
 
enum  op : uint8_t {
  op::ff, op::tt, op::eword, op::ap,
  op::Not, op::X, op::F, op::G,
  op::Closure, op::NegClosure, op::NegClosureMarked, op::Xor,
  op::Implies, op::Equiv, op::U, op::R,
  op::W, op::M, op::EConcat, op::EConcatMarked,
  op::UConcat, op::Or, op::OrRat, op::And,
  op::AndRat, op::AndNLM, op::Concat, op::Fusion,
  op::Star, op::FStar
}
 Operator types. More...
 
enum  mut_opts {
  Mut_Ap2Const = 1U<<0, Mut_Simplify_Bounds = 1U<<1, Mut_Remove_Multop_Operands = 1U<<2, Mut_Remove_Ops = 1U<<3,
  Mut_Split_Ops = 1U<<4, Mut_Rewrite_Ops = 1U<<5, Mut_Remove_One_Ap = 1U<<6, Mut_All = -1U
}
 
enum  relabeling_style { Abc, Pnn }
 

Functions

template<typename State , typename SuccIter >
bool is_a_kripkecube (kripkecube< State, SuccIter > &)
 This method allows to ensure (at compile time) if a given parameter is of type kripkecube. It also check if the iterator has the good interface. More...
 
kripke_graph_ptr make_kripke_graph (const bdd_dict_ptr &d)
 
int memusage ()
 Total number of pages in use by the program. More...
 
std::vector< int > satsolver_get_solution (const char *filename)
 Extract the solution of a SAT solver output. More...
 
const char * version ()
 Return Spot's version. More...
 
void hoayyreset ()
 
int hoayyopen (const std::string &name)
 
int hoayyopen (int fd)
 
int hoayystring (const char *data)
 
void hoayyclose ()
 
parsed_aut_ptr parse_aut (const std::string &filename, const bdd_dict_ptr &dict, environment &env=default_environment::instance(), automaton_parser_options opts={})
 Read the first spot::twa_graph from a file. More...
 
ta_explicit_ptr make_ta_explicit (const const_twa_ptr &tgba, unsigned n_acc, state_ta_explicit *artificial_initial_state=nullptr)
 
ta_product_ptr product (const const_ta_ptr &testing_automaton, const const_kripke_ptr &kripke_structure)
 
tgta_explicit_ptr make_tgta_explicit (const const_twa_ptr &tgba, unsigned n_acc, state_ta_explicit *artificial_initial_state=nullptr)
 
twa_ptr product (const const_kripke_ptr &left, const const_tgta_ptr &right)
 
std::ostream & print_dot (std::ostream &os, const const_ta_ptr &a, const char *opt=nullptr)
 
ta_explicit_ptr minimize_ta (const const_ta_ptr &ta_)
 Construct a simplified TA by merging bisimilar states. More...
 
tgta_explicit_ptr minimize_tgta (const const_tgta_explicit_ptr &tgta_)
 Construct a simplified TGTA by merging bisimilar states. More...
 
std::set< const state * > get_states_set (const const_ta_ptr &t)
 Compute states set for an automaton. More...
 
ta_statistics stats_reachable (const const_ta_ptr &t)
 Compute statistics for an automaton. More...
 
ta_explicit_ptr tgba_to_ta (const const_twa_ptr &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, bool no_livelock=false)
 Build a spot::ta_explicit* (TA) from an LTL formula. More...
 
tgta_explicit_ptr tgba_to_tgta (const const_twa_ptr &tgba_to_convert, bdd atomic_propositions_set)
 Build a spot::tgta_explicit* (TGTA) from an LTL formula. More...
 
atomic_prop_set create_atomic_prop_set (unsigned n)
 construct an atomic_prop_set with n propositions More...
 
atomic_prop_setatomic_prop_collect (formula f, atomic_prop_set *s=nullptr)
 Return the set of atomic propositions occurring in a formula. More...
 
bdd atomic_prop_collect_as_bdd (formula f, const twa_ptr &a)
 Return the set of atomic propositions occurring in a formula, as a BDD. More...
 
std::ostream & print_dot_psl (std::ostream &os, formula f)
 Write a formula tree using dot's syntax. More...
 
int atomic_prop_cmp (const fnode *f, const fnode *g)
 Order two atomic propositions. More...
 
std::ostream & print_formula_props (std::ostream &out, const formula &f, bool abbreviated=false)
 Print the properties of formula f on stream out. More...
 
std::list< std::string > list_formula_props (const formula &f)
 List the properties of formula f. More...
 
std::ostream & operator<< (std::ostream &os, const formula &f)
 Print a formula. More...
 
char mp_class (formula f)
 Return the class of f in the temporal hierarchy of Manna and Pnueli (PODC'90). More...
 
std::string mp_class (formula f, const char *opt)
 Return the class of f in the temporal hierarchy of Manna and Pnueli (PODC'90). More...
 
std::string mp_class (char mpc, const char *opt)
 Expand a class in the temporal hierarchy of Manna and Pnueli (PODC'90). More...
 
int length (formula f)
 Compute the length of a formula. More...
 
int length_boolone (formula f)
 Compute the length of a formula, squashing Boolean formulae. More...
 
formula from_ltlf (formula f, const char *alive="alive")
 Convert an LTLf into an LTL formula. More...
 
std::vector< formulamutate (formula f, unsigned opts=Mut_All, unsigned max_output=-1U, unsigned mutation_count=1, bool sort=true)
 
formula negative_normal_form (formula f, bool negated=false)
 Build the negative normal form of f. More...
 
parsed_formula parse_infix_psl (const std::string &ltl_string, environment &env=default_environment::instance(), bool debug=false, bool lenient=false)
 Build a formula from an LTL string. More...
 
parsed_formula parse_infix_boolean (const std::string &ltl_string, environment &env=default_environment::instance(), bool debug=false, bool lenient=false)
 Build a Boolean formula from a string. More...
 
parsed_formula parse_prefix_ltl (const std::string &ltl_string, environment &env=default_environment::instance(), bool debug=false)
 Build a formula from an LTL string in LBT's format. More...
 
formula parse_formula (const std::string &ltl_string, environment &env=default_environment::instance())
 A simple wrapper to parse_infix_psl() and parse_prefix_ltl(). More...
 
parsed_formula parse_infix_sere (const std::string &sere_string, environment &env=default_environment::instance(), bool debug=false, bool lenient=false)
 Build a formula from a string representing a SERE. More...
 
void fix_utf8_locations (const std::string &input_string, parse_error_list &error_list)
 Fix location of diagnostics assuming the input is utf8. More...
 
std::ostream & print_psl (std::ostream &os, formula f, bool full_parent=false)
 Output a PSL formula as a string which is parsable. More...
 
std::string str_psl (formula f, bool full_parent=false)
 Convert a PSL formula into a string which is parsable. More...
 
std::ostream & print_utf8_psl (std::ostream &os, formula f, bool full_parent=false)
 Output a PSL formula as an utf-8 string which is parsable. More...
 
std::string str_utf8_psl (formula f, bool full_parent=false)
 Convert a PSL formula into a utf-8 string which is parsable. More...
 
std::ostream & print_sere (std::ostream &os, formula f, bool full_parent=false)
 Output a SERE formula as a string which is parsable. More...
 
std::string str_sere (formula f, bool full_parent=false)
 Convert a SERE formula into a string which is parsable. More...
 
std::ostream & print_utf8_sere (std::ostream &os, formula f, bool full_parent=false)
 Output a SERE formula as a utf-8 string which is parsable. More...
 
std::string str_utf8_sere (formula f, bool full_parent=false)
 Convert a SERE formula into a string which is parsable. More...
 
std::ostream & print_spin_ltl (std::ostream &os, formula f, bool full_parent=false)
 Output an LTL formula as a string parsable by Spin. More...
 
std::string str_spin_ltl (formula f, bool full_parent=false)
 Convert an LTL formula into a string parsable by Spin. More...
 
std::ostream & print_wring_ltl (std::ostream &os, formula f)
 Output an LTL formula as a string parsable by Wring. More...
 
std::string str_wring_ltl (formula f)
 Convert a formula into a string parsable by Wring. More...
 
std::ostream & print_latex_psl (std::ostream &os, formula f, bool full_parent=false)
 Output a PSL formula as a LaTeX string. More...
 
std::string str_latex_psl (formula f, bool full_parent=false)
 Output a formula as a LaTeX string which is parsable. unless the formula contains automaton operators (used in ELTL formulae). More...
 
std::ostream & print_latex_sere (std::ostream &os, formula f, bool full_parent=false)
 Output a SERE formula as a LaTeX string. More...
 
std::string str_latex_sere (formula f, bool full_parent=false)
 Output a SERE formula as a LaTeX string which is parsable. unless the formula contains automaton operators (used in ELTL formulae). More...
 
std::ostream & print_sclatex_psl (std::ostream &os, formula f, bool full_parent=false)
 Output a PSL formula as a self-contained LaTeX string. More...
 
std::string str_sclatex_psl (formula f, bool full_parent=false)
 Output a PSL formula as a self-contained LaTeX string. More...
 
std::ostream & print_sclatex_sere (std::ostream &os, formula f, bool full_parent=false)
 Output a SERE formula as a self-contained LaTeX string. More...
 
std::string str_sclatex_sere (formula f, bool full_parent=false)
 Output a SERE formula as a self-contained LaTeX string. More...
 
std::ostream & print_lbt_ltl (std::ostream &os, formula f)
 Output an LTL formula as a string in LBT's format. More...
 
std::string str_lbt_ltl (formula f)
 Output an LTL formula as a string in LBT's format. More...
 
formula relabel (formula f, relabeling_style style, relabeling_map *m=nullptr)
 Relabel the atomic propositions in a formula. More...
 
formula relabel_bse (formula f, relabeling_style style, relabeling_map *m=nullptr)
 Relabel Boolean subexpressions in a formula using atomic propositions. More...
 
formula remove_x (formula f)
 Rewrite a stutter-insensitive formula f without using the X operator. More...
 
formula star_normal_form (formula sere, snf_cache *cache=nullptr)
 
formula star_normal_form_bounded (formula sere, snf_cache *cache=nullptr)
 A variant of star_normal_form() for r[*0..j] where j < ω. More...
 
formula unabbreviate (formula in, const char *opt=default_unabbrev_string)
 Clone and rewrite a formula to remove specified operators logical operators. More...
 
std::ostream & operator<< (std::ostream &os, const acc_cond &acc)
 
bdd_dict_ptr make_bdd_dict ()
 
std::ostream & bdd_print_sat (std::ostream &os, const bdd_dict_ptr &dict, bdd b)
 Print a BDD as a list of literals. More...
 
std::string bdd_format_sat (const bdd_dict_ptr &dict, bdd b)
 Format a BDD as a list of literals. More...
 
std::ostream & bdd_print_accset (std::ostream &os, const bdd_dict_ptr &dict, bdd b)
 Print a BDD as a set of acceptance conditions. More...
 
std::string bdd_format_accset (const bdd_dict_ptr &dict, bdd b)
 Format a BDD as a set of acceptance conditions. More...
 
std::ostream & bdd_print_set (std::ostream &os, const bdd_dict_ptr &dict, bdd b)
 Print a BDD as a set. More...
 
std::string bdd_format_set (const bdd_dict_ptr &dict, bdd b)
 Format a BDD as a set. More...
 
std::ostream & bdd_print_formula (std::ostream &os, const bdd_dict_ptr &dict, bdd b)
 Print a BDD as a formula. More...
 
std::string bdd_format_formula (const bdd_dict_ptr &dict, bdd b)
 Format a BDD as a formula. More...
 
void enable_utf8 ()
 Enable UTF-8 output for bdd printers. More...
 
std::string bdd_format_isop (const bdd_dict_ptr &dict, bdd b)
 Format a BDD as an irredundant sum of product. More...
 
std::ostream & bdd_print_isop (std::ostream &os, const bdd_dict_ptr &dict, bdd b)
 Print a BDD as an irredundant sum of product. More...
 
formula bdd_to_formula (bdd f, const bdd_dict_ptr d)
 Convert a BDD into a formula. More...
 
taa_tgba_string_ptr make_taa_tgba_string (const bdd_dict_ptr &dict)
 
taa_tgba_formula_ptr make_taa_tgba_formula (const bdd_dict_ptr &dict)
 
void shared_state_deleter (state *s)
 
void prop_copy (const const_twa_ptr &other, prop_set p)
 Copy the properties of another automaton. More...
 
void prop_keep (prop_set p)
 Keep only a subset of properties of the current automaton. More...
 
twa_graph_ptr make_twa_graph (const bdd_dict_ptr &dict)
 
twa_graph_ptr make_twa_graph (const twa_graph_ptr &aut, twa::prop_set p)
 
twa_graph_ptr make_twa_graph (const const_twa_graph_ptr &aut, twa::prop_set p)
 
twa_graph_ptr make_twa_graph (const const_twa_ptr &aut, twa::prop_set p)
 
twa_product_ptr otf_product (const const_twa_ptr &left, const const_twa_ptr &right)
 on-the-fly TGBA product More...
 
twa_product_ptr otf_product_at (const const_twa_ptr &left, const const_twa_ptr &right, const state *left_init, const state *right_init)
 on-the-fly TGBA product with forced initial states More...
 
twa_graph_ptr remove_alternation (const const_twa_graph_ptr &aut, bool named_states=false)
 Remove universal edges from an automaton. More...
 
twa_graph_ptr canonicalize (twa_graph_ptr aut)
 Reorder the states and transitions of aut in a way that will be the same for every isomorphic automata. More...
 
twa_graph_ptr dtwa_complement (const const_twa_graph_ptr &aut)
 Complement a deterministic TωA. More...
 
void complete_here (twa_graph_ptr aut)
 Complete a twa_graph in place. More...
 
twa_graph_ptr complete (const const_twa_ptr &aut)
 Clone a twa and complete it. More...
 
twa_graph_ptr compsusp (formula f, const bdd_dict_ptr &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...
 
twa_graph_ptr copy (const const_twa_ptr &aut, twa::prop_set p, bool preserve_names=false, unsigned max_states=-1U)
 Build an explicit automaton from all states of aut,. More...
 
emptiness_check_ptr get_couvreur99_new (const const_twa_ptr &a, option_map o)
 A rewritten version of the Couvreur emptiness check. More...
 
emptiness_check_ptr get_couvreur99_new_abstract (const const_twa_ptr &a, option_map o)
 Same as above, but always uses the abstract interface. More...
 
emptiness_check_result_ptr couvreur99_new_check (const const_twa_ptr &a)
 A shortcut to run the optimized emptiness check directly. More...
 
twa_graph_ptr degeneralize (const const_twa_graph_ptr &a, bool use_z_lvl=true, bool use_cust_acc_orders=false, int use_lvl_cache=1, bool skip_levels=true, bool ignaccsl=false)
 Degeneralize a spot::tgba into an equivalent sba with only one acceptance condition. More...
 
twa_graph_ptr degeneralize_tba (const const_twa_graph_ptr &a, bool use_z_lvl=true, bool use_cust_acc_orders=false, int use_lvl_cache=1, bool skip_levels=true, bool ignaccsl=false)
 
twa_graph_ptr tgba_determinize (const const_twa_graph_ptr &aut, bool pretty_print=false, bool use_scc=true, bool use_simulation=true, bool use_stutter=true)
 Determinize a TGBA. More...
 
std::ostream & print_dot (std::ostream &os, const const_twa_ptr &g, const char *options=nullptr)
 Print reachable states in dot format. More...
 
twa_graph_ptr dtba_sat_synthetize (const const_twa_graph_ptr &a, int target_state_number, bool state_based=false)
 Attempt to synthetize an equivalent deterministic TBA with a SAT solver. More...
 
twa_graph_ptr dtba_sat_minimize (const const_twa_graph_ptr &a, bool state_based=false, int max_states=-1)
 Attempt to minimize a deterministic TBA with a SAT solver. More...
 
twa_graph_ptr dtba_sat_minimize_dichotomy (const const_twa_graph_ptr &a, bool state_based=false, bool langmap=false, int max_states=-1)
 Attempt to minimize a deterministic TBA with a SAT solver. More...
 
twa_graph_ptr dtba_sat_minimize_incr (const const_twa_graph_ptr &a, bool state_based=false, int max_states=-1, int param=2)
 Attempt to minimize a det. TBA with a SAT solver. More...
 
twa_graph_ptr dtba_sat_minimize_assume (const const_twa_graph_ptr &a, bool state_based=false, int max_states=-1, int param=6)
 Attempt to minimize a deterministic TBA incrementally with a SAT solver. More...
 
twa_graph_ptr dtwa_sat_synthetize (const const_twa_graph_ptr &a, unsigned target_acc_number, const acc_cond::acc_code &target_acc, int target_state_number, bool state_based=false, bool colored=false)
 Attempt to synthetize an equivalent deterministic TωA with a SAT solver. More...
 
twa_graph_ptr dtwa_sat_minimize (const const_twa_graph_ptr &a, unsigned target_acc_number, const acc_cond::acc_code &target_acc, bool state_based=false, int max_states=-1, bool colored=false)
 Attempt to minimize a deterministic TωA with a SAT solver. More...
 
twa_graph_ptr dtwa_sat_minimize_dichotomy (const const_twa_graph_ptr &a, unsigned target_acc_number, const acc_cond::acc_code &target_acc, bool state_based=false, bool langmap=false, int max_states=-1, bool colored=false)
 Attempt to minimize a deterministic TωA with a SAT solver. More...
 
twa_graph_ptr dtwa_sat_minimize_incr (const const_twa_graph_ptr &a, unsigned target_acc_number, const acc_cond::acc_code &target_acc, bool state_based=false, int max_states=-1, bool colored=false, int param=2)
 Attempt to minimize a deterministic TωA with a SAT solver. More...
 
twa_graph_ptr dtwa_sat_minimize_assume (const const_twa_graph_ptr &a, unsigned target_acc_number, const acc_cond::acc_code &target_acc, bool state_based=false, int max_states=-1, bool colored=false, int param=6)
 Attempt to minimize a deterministic TωA with a SAT solver. More...
 
twa_graph_ptr dualize (const const_twa_graph_ptr &aut)
 Complement an automaton by dualizing it. More...
 
emptiness_check_instantiator_ptr make_emptiness_check_instantiator (const char *name, const char **err)
 Create an emptiness-check instantiator, given the name of an emptiness check. More...
 
emptiness_check_ptr couvreur99 (const const_twa_ptr &a, option_map options=option_map())
 Check whether the language of an automate is empty. More...
 
emptiness_check_ptr explicit_gv04_check (const const_twa_ptr &a, option_map o=option_map())
 Emptiness check based on Geldenhuys and Valmari's TACAS'04 paper. More...
 
std::ostream & print_hoa (std::ostream &os, const const_twa_ptr &g, const char *opt=nullptr)
 Print reachable states in Hanoi Omega Automata format. More...
 
unsigned count_nondet_states (const const_twa_graph_ptr &aut)
 Count the number of states with non-deterministic branching in aut. More...
 
bool is_universal (const const_twa_graph_ptr &aut)
 Return true iff aut is universal. More...
 
bool is_deterministic (const const_twa_graph_ptr &aut)
 Return true iff aut is deterministic. More...
 
void highlight_nondet_states (twa_graph_ptr &aut, unsigned color)
 Highlight nondeterministic states. More...
 
void highlight_nondet_edges (twa_graph_ptr &aut, unsigned color)
 Highlight nondeterministic edges. More...
 
bool is_complete (const const_twa_graph_ptr &aut)
 Return true iff aut is complete. More...
 
bool is_semi_deterministic (const const_twa_graph_ptr &aut)
 Return true iff aut is semi-deterministic. More...
 
bool is_unambiguous (const const_twa_graph_ptr &aut)
 Whether the automaton aut is unambiguous. More...
 
bool check_unambiguous (const twa_graph_ptr &aut)
 Like is_unambiguous(), but also sets the property in the twa. More...
 
bool scc_has_rejecting_cycle (scc_info &map, unsigned scc)
 Whether the SCC number scc in map has a rejecting cycle. More...
 
bool is_inherently_weak_scc (scc_info &map, unsigned scc)
 Whether the SCC number scc in map is inherently weak. More...
 
bool is_weak_scc (scc_info &map, unsigned scc)
 Whether the SCC number scc in map is weak. More...
 
bool is_complete_scc (scc_info &map, unsigned scc)
 Whether the SCC number scc in map is complete. More...
 
bool is_terminal_scc (scc_info &map, unsigned scc)
 Whether the SCC number scc in map is terminal. More...
 
std::vector< unsigned > language_map (const const_twa_graph_ptr &aut)
 Identify states that recognize the same language. More...
 
void highlight_languages (twa_graph_ptr &aut)
 Color state that recognize identical language. More...
 
std::ostream & print_lbtt (std::ostream &os, const const_twa_ptr &g, const char *opt=nullptr)
 Print reachable states in LBTT's format. More...
 
taa_tgba_formula_ptr ltl_to_taa (formula f, const bdd_dict_ptr &dict, bool refined_rules=false)
 Build a spot::taa* from an LTL formula. More...
 
twa_graph_ptr ltl_to_tgba_fm (formula f, const bdd_dict_ptr &dict, bool exprop=false, bool symb_merge=true, bool branching_postponement=false, bool fair_loop_approx=false, const atomic_prop_set *unobs=nullptr, tl_simplifier *simplifier=nullptr, bool unambiguous=false)
 Build a spot::twa_graph_ptr from an LTL formula. More...
 
emptiness_check_ptr explicit_magic_search (const const_twa_ptr &a, option_map o=option_map())
 Returns an emptiness checker on the spot::tgba automaton a. More...
 
emptiness_check_ptr bit_state_hashing_magic_search (const const_twa_ptr &a, size_t size, option_map o=option_map())
 Returns an emptiness checker on the spot::tgba automaton a. More...
 
emptiness_check_ptr magic_search (const const_twa_ptr &a, option_map o=option_map())
 Wrapper for the two magic_search implementations. More...
 
template<typename Trans >
void transform_accessible (const const_twa_graph_ptr &old, twa_graph_ptr &cpy, Trans trans, unsigned int init)
 Clone and mask an automaton. More...
 
template<typename Trans >
void transform_copy (const const_twa_graph_ptr &old, twa_graph_ptr &cpy, Trans trans, unsigned int init)
 Copy an automaton and update each edge. More...
 
template<typename Trans >
void transform_accessible (const const_twa_graph_ptr &old, twa_graph_ptr &cpy, Trans trans)
 
template<typename Trans >
void transform_copy (const const_twa_graph_ptr &old, twa_graph_ptr &cpy, Trans trans)
 
twa_graph_ptr mask_acc_sets (const const_twa_graph_ptr &in, acc_cond::mark_t to_remove)
 Remove all edges that belong to some given acceptance sets. More...
 
twa_graph_ptr mask_keep_states (const const_twa_graph_ptr &in, std::vector< bool > &to_keep, unsigned int init)
 Keep only the states as specified by to_keep. More...
 
twa_graph_ptr mask_keep_accessible_states (const const_twa_graph_ptr &in, std::vector< bool > &to_keep, unsigned int init)
 Keep only the states specified by to_keep that are accessible. More...
 
twa_graph_ptr minimize_monitor (const const_twa_graph_ptr &a)
 Construct a minimal deterministic monitor. More...
 
twa_graph_ptr minimize_wdba (const const_twa_graph_ptr &a)
 Minimize a Büchi automaton in the WDBA class. More...
 
twa_graph_ptr minimize_obligation (const const_twa_graph_ptr &aut_f, formula f=nullptr, const_twa_graph_ptr aut_neg_f=nullptr, bool reject_bigger=false)
 Minimize an automaton if it represents an obligation property. More...
 
std::ostream & print_never_claim (std::ostream &os, const const_twa_ptr &g, const char *opt=nullptr)
 Print reachable states in Spin never claim format. More...
 
twa_graph_ptr tba_determinize (const const_twa_graph_ptr &aut, unsigned threshold_states=0, unsigned threshold_cycles=0)
 Determinize a TBA using the powerset construction. More...
 
twa_graph_ptr tba_determinize_check (const twa_graph_ptr &aut, unsigned threshold_states=0, unsigned threshold_cycles=0, formula f=nullptr, const_twa_graph_ptr neg_aut=nullptr)
 Determinize a TBA and make sure it is correct. More...
 
twa_graph_ptr product (const const_twa_graph_ptr &left, const const_twa_graph_ptr &right)
 
twa_graph_ptr product (const const_twa_graph_ptr &left, const const_twa_graph_ptr &right, unsigned left_state, unsigned right_state)
 
twa_graph_ptr product_or (const const_twa_graph_ptr &left, const const_twa_graph_ptr &right)
 
twa_graph_ptr product_or (const const_twa_graph_ptr &left, const const_twa_graph_ptr &right, unsigned left_state, unsigned right_state)
 
twa_graph_ptr random_graph (int n, float d, const atomic_prop_set *ap, const bdd_dict_ptr &dict, unsigned n_accs=0, float a=0.1, float t=0.5, bool deterministic=false, bool state_acc=false, bool colored=false)
 Construct a twa randomly. More...
 
acc_cond::acc_code random_acceptance (unsigned n_accs)
 Build a random acceptance where each acceptance sets is used once. More...
 
void randomize (twa_graph_ptr &aut, bool randomize_states=true, bool randomize_edges=true)
 Randomize a TGBA. More...
 
void relabel_here (twa_graph_ptr &aut, relabeling_map *relmap)
 replace atomic propositions in an automaton More...
 
twa_graph_ptr rabin_to_buchi_maybe (const const_twa_graph_ptr &aut)
 Convert a state-based Rabin automaton to Büchi automaton, preserving determinism when possible. More...
 
twa_graph_ptr remove_fin (const const_twa_graph_ptr &aut)
 Rewrite an automaton without Fin acceptance. More...
 
twa_graph_ptr sbacc (twa_graph_ptr aut)
 Transform an automaton to use state-based acceptance. More...
 
twa_graph_ptr scc_filter (const const_twa_graph_ptr &aut, bool remove_all_useless=false, scc_info *given_si=nullptr)
 Prune unaccepting SCCs and remove superfluous acceptance conditions. More...
 
twa_graph_ptr scc_filter_states (const const_twa_graph_ptr &aut, bool remove_all_useless=false, scc_info *given_si=nullptr)
 Prune unaccepting SCCs. More...
 
twa_graph_ptr scc_filter_susp (const const_twa_graph_ptr &aut, bool remove_all_useless, bdd suspvars, bdd ignoredvars, bool early_susp, scc_info *given_si=nullptr)
 Prune unaccepting SCCs, superfluous acceptance sets, and suspension variables. More...
 
std::ostream & dump_scc_info_dot (std::ostream &out, const_twa_graph_ptr aut, scc_info *sccinfo=nullptr)
 Dump the SCC graph of aut on out. More...
 
emptiness_check_ptr explicit_se05_search (const const_twa_ptr &a, option_map o=option_map())
 Returns an emptiness check on the spot::tgba automaton a. More...
 
emptiness_check_ptr bit_state_hashing_se05_search (const const_twa_ptr &a, size_t size, option_map o=option_map())
 Returns an emptiness checker on the spot::tgba automaton a. More...
 
emptiness_check_ptr se05 (const const_twa_ptr &a, option_map o)
 Wrapper for the two se05 implementations. More...
 
bool has_separate_sets (const const_twa_graph_ptr &aut)
 Whether the Inf and Fin numbers are disjoints. More...
 
twa_graph_ptr separate_sets_here (const twa_graph_ptr &aut)
 Separate the Fin and Inf sets used by an automaton. More...
 
twa_graph_ptr simulation (const const_twa_graph_ptr &automaton)
 Attempt to reduce the automaton by direct simulation. More...
 
twa_graph_ptr simulation (const const_twa_graph_ptr &automaton, std::vector< bdd > *implications)
 
twa_graph_ptr simulation_sba (const const_twa_graph_ptr &automaton)
 
twa_statistics stats_reachable (const const_twa_ptr &g)
 Compute statistics for an automaton. More...
 
twa_sub_statistics sub_stats_reachable (const const_twa_ptr &g)
 Compute sub statistics for an automaton. More...
 
bool is_terminal_automaton (const const_twa_graph_ptr &aut, scc_info *sm=nullptr, bool ignore_trivial_scc=false)
 Check whether an automaton is terminal. More...
 
bool is_weak_automaton (const const_twa_graph_ptr &aut, scc_info *sm=nullptr)
 Check whether an automaton is weak. More...
 
bool is_very_weak_automaton (const const_twa_graph_ptr &aut, scc_info *sm=nullptr)
 Check whether an automaton is very-weak. More...
 
bool is_inherently_weak_automaton (const const_twa_graph_ptr &aut, scc_info *sm=nullptr)
 Check whether an automaton is inherently weak. More...
 
bool is_safety_automaton (const const_twa_graph_ptr &aut, scc_info *sm=nullptr)
 Check whether an automaton is a safety automaton. More...
 
void check_strength (const twa_graph_ptr &aut, scc_info *sm=nullptr)
 Check whether an automaton is weak or terminal. More...
 
twa_graph_ptr decompose_strength (const const_twa_graph_ptr &aut, const char *keep)
 Extract a sub-automaton of a given strength. More...
 
twa_graph_ptr decompose_scc (scc_info &sm, unsigned scc_num)
 Extract a sub-automaton of a SCC. More...
 
twa_graph_ptr decompose_acc_scc (const const_twa_graph_ptr &aut, int scc_index)
 Extract a sub-automaton of an accepting SCC. More...
 
void strip_acceptance_here (twa_graph_ptr a)
 Remove all acceptance sets from a twa_graph. More...
 
twa_graph_ptr sl (const twa_graph_ptr &)
 
twa_graph_ptr sl (const const_twa_graph_ptr &, bdd)
 
twa_graph_ptr sl2 (const twa_graph_ptr &)
 
twa_graph_ptr sl2 (const const_twa_graph_ptr &, bdd)
 
twa_graph_ptr sl2 (twa_graph_ptr &&, bdd=bddfalse)
 
twa_graph_ptr closure (const const_twa_graph_ptr &)
 
twa_graph_ptr closure (twa_graph_ptr &&)
 
bool is_stutter_invariant (formula f)
 Check if a formula has the stutter invariance property. More...
 
bool is_stutter_invariant (twa_graph_ptr &&aut_f, twa_graph_ptr &&aut_nf, bdd aps, int algo=0)
 
trival check_stutter_invariance (const twa_graph_ptr &aut, formula f=nullptr, bool do_not_determinize=false)
 Check whether aut is stutter-invariant. More...
 
twa_graph_ptr sum (const const_twa_graph_ptr &left, const const_twa_graph_ptr &right)
 Sum two twa into a new twa, performing the union of the two input automatons. More...
 
twa_graph_ptr sum (const const_twa_graph_ptr &left, const const_twa_graph_ptr &right, unsigned left_state, unsigned right_state)
 Sum two twa into a new twa, performing the union of the two input automatons. More...
 
twa_graph_ptr sum_and (const const_twa_graph_ptr &left, const const_twa_graph_ptr &right)
 Sum two twa into a new twa, using a universal initial transition, performing the intersection of the two languages of the input automatons. More...
 
twa_graph_ptr sum_and (const const_twa_graph_ptr &left, const const_twa_graph_ptr &right, unsigned left_state, unsigned right_state)
 Sum two twa into a new twa, using a universal initial transition, performing the intersection of the two languages of the input automatons. More...
 
emptiness_check_ptr explicit_tau03_search (const const_twa_ptr &a, option_map o=option_map())
 Returns an emptiness checker on the spot::tgba automaton a. More...
 
emptiness_check_ptr explicit_tau03_opt_search (const const_twa_ptr &a, option_map o=option_map())
 Returns an emptiness checker on the spot::tgba automaton a. More...
 
twa_graph_ptr to_generalized_buchi (const const_twa_graph_ptr &aut)
 Take an automaton with any acceptance condition and return an equivalent Generalized Büchi automaton. More...
 
twa_graph_ptr streett_to_generalized_buchi (const const_twa_graph_ptr &in)
 Convert Streett acceptance into generalized Büchi acceptance. More...
 
twa_graph_ptr streett_to_generalized_buchi_maybe (const const_twa_graph_ptr &in)
 Convert Streett acceptance into generalized Büchi only if SPOT_STREET_CONF_MIN is set to a number of pairs less than the number of pairs used by IN. More...
 
twa_graph_ptr to_generalized_rabin (const const_twa_graph_ptr &aut, bool share_inf=false)
 Take an automaton with any acceptance condition and return an equivalent Generalized Rabin automaton. More...
 
twa_graph_ptr to_generalized_streett (const const_twa_graph_ptr &aut, bool share_fin=false)
 Take an automaton with any acceptance condition and return an equivalent Generalized Streett automaton. More...
 
twa_word_ptr make_twa_word (const bdd_dict_ptr &dict)
 Create an empty twa_word. More...
 
twa_word_ptr make_twa_word (const twa_run_ptr &run)
 Create a twa_word from a twa_run. More...
 
twa_word_ptr parse_word (const std::string &word, const bdd_dict_ptr &dict)
 Parse a twa_word. More...
 
twacube_ptr make_twacube (const std::vector< std::string > aps)
 
spot::cube satone_to_cube (bdd one, cubeset &cubeset, std::unordered_map< int, int > &binder)
 Transform one truth assignment represented as a BDD into a cube cube passed in parameter. The parameter binder map bdd indexes to cube indexes. More...
 
bdd cube_to_bdd (spot::cube cube, const cubeset &cubeset, std::unordered_map< int, int > &reverse_binder)
 Transform a cube cube into bdd using the map that bind cube indexes to bdd indexes. More...
 
std::vector< std::string > * extract_aps (spot::const_twa_graph_ptr aut, std::unordered_map< int, int > &ap_binder)
 Extract the atomic propositions from the automaton. This method also fill the binder, i.e. the mapping between BDD indexes to cube indexes. More...
 
twacube_ptr twa_to_twacube (spot::const_twa_graph_ptr aut)
 Convert a twa into a twacube. More...
 
spot::twa_graph_ptr twacube_to_twa (spot::twacube_ptr twacube)
 Convert a twacube into a twa. More...
 
bool is_bare_word (const char *str)
 Whether a word is bare. More...
 
std::string quote_unless_bare_word (const std::string &str)
 Double-quote words that are not bare. More...
 
bool is_spin_ap (const char *str)
 Whether a word can be used as an atomic proposition for Spin 5. More...
 
bitvectmake_bitvect (size_t bitcount)
 Allocate a bit-vector of bitcount bits. More...
 
bitvect_arraymake_bitvect_array (size_t bitcount, size_t vectcount)
 Allocate vectcount bit-vectors of bitcount bits. More...
 
std::ostream & escape_rfc4180 (std::ostream &os, const std::string &str)
 Double characters " in strings. More...
 
std::ostream & escape_latex (std::ostream &os, const std::string &str)
 Escape special LaTeX characters. More...
 
std::ostream & escape_html (std::ostream &os, const std::string &str)
 Escape special HTML characters. More...
 
std::ostream & escape_str (std::ostream &os, const std::string &str)
 Escape characters ", \, and \n in str. More...
 
std::string escape_str (const std::string &str)
 Escape characters ", \, and \n in str. More...
 
std::ostream & quote_shell_string (std::ostream &os, const char *str)
 Output str between simple quote or double quotes. More...
 
std::ostream & operator<< (std::ostream &os, const timer &dt)
 
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...
 
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...
 
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...
 
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...
 
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...
 
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...
 
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...
 
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...
 
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...
 
void srand (unsigned int seed)
 Reset the seed of the pseudo-random number generator. More...
 
int rrand (int min, int max)
 Compute a pseudo-random integer value between min and max included. More...
 
int mrand (int max)
 Compute a pseudo-random integer value between 0 and max-1 included. More...
 
double drand ()
 Compute a pseudo-random double value between 0.0 and 1.0 (1.0 excluded). More...
 
double nrand ()
 Compute a pseudo-random double value following a standard normal distribution. (Odeh & Evans) More...
 
double bmrand ()
 Compute a pseudo-random double value following a standard normal distribution. (Box-Muller) More...
 
int prand (double p)
 Return a pseudo-random positive integer value following a Poisson distribution with parameter p. More...
 
template<class iterator_type >
void mrandom_shuffle (iterator_type &&first, iterator_type &&last)
 Shuffle the container using mrand function above. This allows to get rid off shuffle or random_shuffle that use uniform_distribution and RandomIterator that are not portables. More...
 
temporary_filecreate_tmpfile (const char *prefix, const char *suffix=nullptr)
 Create a temporary file. More...
 
open_temporary_filecreate_open_tmpfile (const char *prefix, const char *suffix=nullptr)
 Create a temporary file and leave it open for writing. More...
 
void cleanup_tmpfiles ()
 Delete all temporary files. More...
 
constexpr bool operator== (bool a, trival b)
 
constexpr bool operator!= (bool a, trival b)
 
constexpr trival operator && (trival a, trival b)
 
constexpr trival operator && (bool a, trival b)
 
constexpr trival operator && (trival a, bool b)
 
constexpr trival operator|| (trival a, trival b)
 
constexpr trival operator|| (bool a, trival b)
 
constexpr trival operator|| (trival a, bool b)
 
std::ostream & operator<< (std::ostream &os, trival v)
 
bdd formula_to_bdd (formula f, const bdd_dict_ptr &d, void *for_me)
 Convert a Boolean formula into a BDD. More...
 
template<typename T >
bdd formula_to_bdd (formula f, const bdd_dict_ptr &d, const std::shared_ptr< T > &for_me)
 Convert a Boolean formula into a BDD. More...
 
template<class I >
unsigned states_and (const twa_graph_ptr &aut, I begin, I end)
 Combine two states in a conjunction. More...
 
template<class T >
unsigned states_and (const twa_graph_ptr &aut, const std::initializer_list< T > &il)
 Combine two states in a conjunction. More...
 
twa_graph_ptr cleanup_acceptance_here (twa_graph_ptr aut)
 Remove useless acceptance sets. More...
 
twa_graph_ptr cleanup_acceptance (const_twa_graph_ptr aut)
 Remove useless acceptance sets. More...
 
twa_graph_ptr tgba_powerset (const const_twa_graph_ptr &aut, power_map &pm, bool merge=true)
 Build a deterministic automaton, ignoring acceptance conditions. More...
 
twa_graph_ptr tgba_powerset (const const_twa_graph_ptr &aut)
 Build a deterministic automaton, ignoring acceptance conditions. More...
 
twa_graph_ptr cosimulation (const const_twa_graph_ptr &automaton)
 Attempt to reduce the automaton by reverse simulation. More...
 
twa_graph_ptr cosimulation_sba (const const_twa_graph_ptr &automaton)
 Attempt to reduce the automaton by reverse simulation. More...
 
twa_graph_ptr iterated_simulations (const const_twa_graph_ptr &automaton)
 Iterate simulation() and cosimulation(). More...
 
twa_graph_ptr iterated_simulations_sba (const const_twa_graph_ptr &automaton)
 Iterate simulation() and cosimulation(). More...
 

Variables

constexpr const char * default_unabbrev_string = "eFGiMW^"
 
dichotomy
 High-level interface to SAT-based minimization. More...
 

Detailed Description

This file aggregates all classes and typedefs necessary to build a kripke that is thread safe

Typedef Documentation

◆ cspins_state

typedef int* spot::cspins_state

A Spins state is represented as an array of integer Note that this array has two reserved slots (position 0 an 1).

At position 0 we store the hash associated to the state to avoid multiple computations.

At position 1 we store the size of the state: keeping this information allows to compress the state

◆ cspins_state_map

typedef brick::hashset::FastConcurrent<cspins_state, cspins_state_hasher> spot::cspins_state_map

Shortcut to avoid long names...

◆ cube

using spot::cube = typedef unsigned*

A cube is only a set of bits in memory.

This set can be seen as two bitsets

  • true_var : a bitset representing variables that are set to true
  • false_var : a bitset representing variables that are set to false

In the two vectors a bit set to 1 represent a variable set to true (resp. false) for the true_var (resp. false_var)

Warning : a variable cannot be set in both bitset at the same time (consistency! cannot be true and false)

The cube for (a & !b) will be repensented by :

  • true_var = 1 0
  • false_var = 0 1

To represent free variables such as in (a & !b) | (a & b) (wich is equivalent to (a) with b free)

  • true_var : 1 0
  • false_var : 0 0 This exemple shows that the representation of free variables is done by unsetting variable in both vector

To be memory efficient, these two bitsets are contigous in memory i.e. if we want to represent 35 variables, a cube will be represented by 4 unsigned int contiguous in memory. The 35 first bits represent truth values. The 29 bits following are useless. Then, the 35 bits represents false value and the rest is useless.

Note that useless bits are only to perform some action efficiently, i.e. only by ignoring them. The manipulation of cubes must be done using the cubeset class

◆ ltsmin_kripkecube_ptr

shortcut to manipulate the kripke below

◆ shared_state_set

typedef std::unordered_set<shared_state, state_shared_ptr_hash, state_shared_ptr_equal> spot::shared_state_set

Unordered set of shared states.

◆ state_map

template<class val >
using spot::state_map = typedef std::unordered_map<const state*, val, state_ptr_hash, state_ptr_equal>

Unordered map of abstract states.

Destroying each state if needed is the user's responsibility.

◆ state_set

typedef std::unordered_set<const state*, state_ptr_hash, state_ptr_equal> spot::state_set

Unordered set of abstract states.

Destroying each state if needed is the user's responsibility.

See also
state_unicity_table

Function Documentation

◆ atomic_prop_cmp()

int spot::atomic_prop_cmp ( const fnode f,
const fnode g 
)

Order two atomic propositions.

Referenced by spot::fnode::has_spin_atomic_props().

◆ bdd_format_accset()

std::string spot::bdd_format_accset ( const bdd_dict_ptr &  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.

◆ bdd_format_formula()

std::string spot::bdd_format_formula ( const bdd_dict_ptr &  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.

◆ bdd_format_isop()

std::string spot::bdd_format_isop ( const bdd_dict_ptr &  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.

◆ bdd_format_sat()

std::string spot::bdd_format_sat ( const bdd_dict_ptr &  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.

◆ bdd_format_set()

std::string spot::bdd_format_set ( const bdd_dict_ptr &  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.

◆ bdd_print_accset()

std::ostream& spot::bdd_print_accset ( std::ostream &  os,
const bdd_dict_ptr &  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.

◆ bdd_print_formula()

std::ostream& spot::bdd_print_formula ( std::ostream &  os,
const bdd_dict_ptr &  dict,
bdd  b 
)

Print a BDD as a formula.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.

◆ bdd_print_isop()

std::ostream& spot::bdd_print_isop ( std::ostream &  os,
const bdd_dict_ptr &  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.

◆ bdd_print_sat()

std::ostream& spot::bdd_print_sat ( std::ostream &  os,
const bdd_dict_ptr &  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.

◆ bdd_print_set()

std::ostream& spot::bdd_print_set ( std::ostream &  os,
const bdd_dict_ptr &  dict,
bdd  b 
)

Print a BDD as a set.

Parameters
osThe output stream.
dictThe dictionary to use, to lookup variables.
bThe BDD to print.

◆ bdd_to_formula()

formula spot::bdd_to_formula ( bdd  f,
const bdd_dict_ptr  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 formula, it obviously does not use any temporal operator.

Referenced by formula_to_bdd().

◆ check_strength()

void spot::check_strength ( const twa_graph_ptr &  aut,
scc_info sm = nullptr 
)

Check whether an automaton is weak or terminal.

This sets the "inherently weak", "weak", "very-weak" and "terminal" properties as appropriate.

Parameters
autthe automaton to check
sman scc_info object for the automaton if available (it will be built otherwise).

◆ check_stutter_invariance()

trival spot::check_stutter_invariance ( const twa_graph_ptr &  aut,
formula  f = nullptr,
bool  do_not_determinize = false 
)

Check whether aut is stutter-invariant.

This procedure requires the negation of aut to be computed. This is easily done of aut is deterministic or if a formula represented by aut is known. Otherwise aut will be complemented by determinization, which can be expansive. The determinization can be forbidden using the do_not_determinize flag.

If no complemented automaton could be constructed, the the result will be returned as trival::maybe().

◆ cleanup_acceptance()

twa_graph_ptr spot::cleanup_acceptance ( const_twa_graph_ptr  aut)

Remove useless acceptance sets.

◆ cleanup_acceptance_here()

twa_graph_ptr spot::cleanup_acceptance_here ( twa_graph_ptr  aut)

Remove useless acceptance sets.

◆ cleanup_tmpfiles()

void spot::cleanup_tmpfiles ( )

Delete all temporary files.

Delete all temporary files that have been created but haven't been deleted so far. The verb "delete" should be understood as both the C++ delete operator (all temporary_file and open_temporary_file instance are destroyed) and as the file system operation (the actual files are removed).

Even in programs where temporary_file instance are consciously destroyed when they are not needed, cleanup_tmpfiles() could still be useful in signal handlers, for instance to clean all temporary files upon SIGINT.

◆ complete()

twa_graph_ptr spot::complete ( const const_twa_ptr &  aut)

Clone a twa and complete it.

If the twa has no acceptance set, one will be added.

Referenced by spot::twa::prop_stutter_invariant(), and spot::twa::set_buchi().

◆ complete_here()

void spot::complete_here ( twa_graph_ptr  aut)

Complete a twa_graph in place.

If the TωA has an acceptance condition that is a tautology, it will be changed into a Büchi automaton.

◆ compsusp()

twa_graph_ptr spot::compsusp ( formula  f,
const bdd_dict_ptr &  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.

◆ couvreur99_new_check()

emptiness_check_result_ptr spot::couvreur99_new_check ( const const_twa_ptr &  a)

A shortcut to run the optimized emptiness check directly.

This is the same as get_couvreur99_new(a, {})->check().

◆ create_open_tmpfile()

open_temporary_file* spot::create_open_tmpfile ( const char *  prefix,
const char *  suffix = nullptr 
)

Create a temporary file and leave it open for writing.

Same as create_tmpfile, be leave the file open for writing. The open_temporary_file::fd() method returns the file descriptor.

◆ create_tmpfile()

temporary_file* spot::create_tmpfile ( const char *  prefix,
const char *  suffix = nullptr 
)

Create a temporary file.

The file name will start with prefix, be followed by 6 randomish characters and will end in suffix. Usually suffix is used to set an extension (you should include the dot).

The temporary file is created and left empty. If you need to fill it, consider using create_open_tmpfile() instead.

◆ cube_to_bdd()

bdd spot::cube_to_bdd ( spot::cube  cube,
const cubeset cubeset,
std::unordered_map< int, int > &  reverse_binder 
)

Transform a cube cube into bdd using the map that bind cube indexes to bdd indexes.

◆ decompose_acc_scc()

twa_graph_ptr spot::decompose_acc_scc ( const const_twa_graph_ptr &  aut,
int  scc_index 
)

Extract a sub-automaton of an accepting SCC.

This algorithm returns a subautomaton that contains the `scc_index'th accepting SCC, plus any upstream SCC (but adjusted not to be accepting).

Parameters
autthe automaton to decompose
scc_indexthe ID of the accepting SCC to keep

◆ decompose_scc()

twa_graph_ptr spot::decompose_scc ( scc_info sm,
unsigned  scc_num 
)

Extract a sub-automaton of a SCC.

This algorithm returns a subautomaton that contains the requested SCC, plus any upstream SCC (but adjusted not to be accepting).

Parameters
smthe SCC info map of the automaton
scc_numthe index in the map of the SCC to keep

◆ decompose_strength()

twa_graph_ptr spot::decompose_strength ( const const_twa_graph_ptr &  aut,
const char *  keep 
)

Extract a sub-automaton of a given strength.

The string keep should be a non-empty combination of the following letters:

  • 'w': keep only inherently weak SCCs (i.e., SCCs in which all transitions belong to the same acceptance sets) that are not terminal.
  • 't': keep terminal SCCs (i.e., inherently weak SCCs that are complete)
  • 's': keep strong SCCs (i.e., SCCs that are not inherently weak).

This algorithm returns a subautomaton that contains all SCCs of the requested strength, plus any upstream SCC (but adjusted not to be accepting).

The definition are basically those used in the following paper, except that we extra the "inherently weak" part instead of the weak part because we can now test for inherent weakness efficiently enough (not enumerating all cycles as suggested in the paper).

@inproceedings{renault.13.tacas,
  author = {Etienne Renault and Alexandre Duret-Lutz and Fabrice
            Kordon and Denis Poitrenaud},
  title = {Strength-Based Decomposition of the Property {B\"u}chi
            Automaton for Faster Model Checking},
  booktitle = {Proceedings of the 19th International Conference on Tools
            and Algorithms for the Construction and Analysis of Systems
            (TACAS'13)},
  editor = {Nir Piterman and Scott A. Smolka},
  year = {2013},
  month = mar,
  pages = {580--593},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science},
  volume = {7795},
  doi = {10.1007/978-3-642-36742-7_42}
}
Parameters
autthe automaton to decompose
keepa string specifying the strengths to keep: it should

◆ dtba_sat_minimize()

twa_graph_ptr spot::dtba_sat_minimize ( const const_twa_graph_ptr &  a,
bool  state_based = false,
int  max_states = -1 
)

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.

◆ dtba_sat_minimize_assume()

twa_graph_ptr spot::dtba_sat_minimize_assume ( const const_twa_graph_ptr &  a,
bool  state_based = false,
int  max_states = -1,
int  param = 6 
)

Attempt to minimize a deterministic TBA incrementally with a SAT solver.

This acts like dtba_sat_synthetize() and obtains a first minimized automaton. Then, it adds assumptions, such that each assumption removes a new state and implies the previous assumptions. A first resolution is attempted assuming the last assumption (thus involving all the previous ones). If the problem is SAT several stages have just been won and all this process is restarted. Otherwise, we know that the minimal automaton can be obtained with fewer assumption. This automaton is found dichotomously.

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

◆ dtba_sat_minimize_dichotomy()

twa_graph_ptr spot::dtba_sat_minimize_dichotomy ( const const_twa_graph_ptr &  a,
bool  state_based = false,
bool  langmap = false,
int  max_states = -1 
)

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.

◆ dtba_sat_minimize_incr()

twa_graph_ptr spot::dtba_sat_minimize_incr ( const const_twa_graph_ptr &  a,
bool  state_based = false,
int  max_states = -1,
int  param = 2 
)

Attempt to minimize a det. TBA with a SAT solver.

This acts like dtba_sat_synthetize() and obtains a first minimized automaton. Then, incrementally, it encodes the deletion of one state and solves it as many time as param value. If param >= 0, this process is fully repeated until the minimal automaton is found. Otherwise, it continues to delete states one by one incrementally until the minimal automaton is found.

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

◆ dtba_sat_synthetize()

twa_graph_ptr spot::dtba_sat_synthetize ( const const_twa_graph_ptr &  a,
int  target_state_number,
bool  state_based = false 
)

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

Parameters
athe input TGA. 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

◆ dtwa_complement()

twa_graph_ptr spot::dtwa_complement ( const const_twa_graph_ptr &  aut)

Complement a deterministic TωA.

The automaton aut should be deterministic. It will be completed if it isn't already. In these conditions, complementing the automaton can be done by just complementing the acceptance condition.

In particular, this implies that an input that use generalized Büchi will be output as generalized co-Büchi.

Functions like to_generalized_buchi() or remove_fin() are frequently called after dtwa_complement() to obtain an easier acceptance condition (maybe at the cost of losing determinism.)

This function was deprecated in spot 2.4. Call the function spot::dualize() instead, that is able to complement any input automaton, not only deterministic ones.

◆ dtwa_sat_minimize()

twa_graph_ptr spot::dtwa_sat_minimize ( const const_twa_graph_ptr &  a,
unsigned  target_acc_number,
const acc_cond::acc_code target_acc,
bool  state_based = false,
int  max_states = -1,
bool  colored = false 
)

Attempt to minimize a deterministic TωA with a SAT solver.

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

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

◆ dtwa_sat_minimize_assume()

twa_graph_ptr spot::dtwa_sat_minimize_assume ( const const_twa_graph_ptr &  a,
unsigned  target_acc_number,
const acc_cond::acc_code target_acc,
bool  state_based = false,
int  max_states = -1,
bool  colored = false,
int  param = 6 
)

Attempt to minimize a deterministic TωA with a SAT solver.

This acts like dtba_sat_synthetize() and obtains a first minimized automaton. Then, it adds assumptions, such that each assumption removes a new state and implies the previous assumptions. A first resolution is attempted assuming the last assumption (thus involving all the previous ones). If the problem is SAT several stages have just been won and all this process is restarted. Otherwise, it is known that the minimal automaton can be obtained with fewer assumption. This automaton is found dichotomously.

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

◆ dtwa_sat_minimize_dichotomy()

twa_graph_ptr spot::dtwa_sat_minimize_dichotomy ( const const_twa_graph_ptr &  a,
unsigned  target_acc_number,
const acc_cond::acc_code target_acc,
bool  state_based = false,
bool  langmap = false,
int  max_states = -1,
bool  colored = false 
)

Attempt to minimize a deterministic TωA with a SAT solver.

This calls dtwa_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.

◆ dtwa_sat_minimize_incr()

twa_graph_ptr spot::dtwa_sat_minimize_incr ( const const_twa_graph_ptr &  a,
unsigned  target_acc_number,
const acc_cond::acc_code target_acc,
bool  state_based = false,
int  max_states = -1,
bool  colored = false,
int  param = 2 
)

Attempt to minimize a deterministic TωA with a SAT solver.

It acts like dtwa_sat_synthetisze() and obtains a first minimized automaton. Then, incrementally, it encodes and solves the deletion of one state as many time as param value. If param >= 0, this process is fully repeated until the minimal automaton is found. Otherwise, it continues to delete states one by one incrementally until the minimal automaton is found.

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

◆ dtwa_sat_synthetize()

twa_graph_ptr spot::dtwa_sat_synthetize ( const const_twa_graph_ptr &  a,
unsigned  target_acc_number,
const acc_cond::acc_code target_acc,
int  target_state_number,
bool  state_based = false,
bool  colored = false 
)

Attempt to synthetize an equivalent deterministic TωA with a SAT solver.

Parameters
athe input TωA. It should be a deterministic TωA.
target_acc_numberis the number of acceptance sets wanted in the result.
target_accthe target acceptance condition
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.
coloredif true, force all transitions to belong to exactly one acceptance set.

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

◆ dualize()

twa_graph_ptr spot::dualize ( const const_twa_graph_ptr &  aut)

Complement an automaton by dualizing it.

Given an automaton aut of any type, produces the dual as output. The automaton will be completed if it isn't already. If it is deterministic and complete, complementing the automaton can be done by just complementing the acceptance condition.

In particular, this implies that an input that use generalized Büchi will be output as generalized co-Büchi.

Functions like to_generalized_buchi() or remove_fin() are frequently called on existential automatons after dualize() to obtain an easier acceptance condition, but maybe at the cost of losing determinism.

If the input automaton is deterministic, the output will be deterministic. If the input automaton is existential, the output will be universal. If the input automaton is universal, the output will be existential. Finally, if the input automaton is alternating, the result is alternating. More can be found on page 22 (Definition 1.6) of:

@mastersthesis{loding.98.methodsfor
  author = {Christof Löding}
  title  = {Methods for the Transformation of ω-Automata: Complexity
           and Connection to Second Order Logic}
  school = {Institute of Computer Science and Applied Mathematics
            Christian-Albrechts-University of Kiel}
  year   = {1998}
}

◆ dump_scc_info_dot()

std::ostream& spot::dump_scc_info_dot ( std::ostream &  out,
const_twa_graph_ptr  aut,
scc_info sccinfo = nullptr 
)

Dump the SCC graph of aut on out.

If sccinfo is not given, it will be computed.

Referenced by spot::scc_info::initial().

◆ enable_utf8()

void spot::enable_utf8 ( )

Enable UTF-8 output for bdd printers.

◆ extract_aps()

std::vector<std::string>* spot::extract_aps ( spot::const_twa_graph_ptr  aut,
std::unordered_map< int, int > &  ap_binder 
)

Extract the atomic propositions from the automaton. This method also fill the binder, i.e. the mapping between BDD indexes to cube indexes.

◆ formula_to_bdd() [1/2]

bdd spot::formula_to_bdd ( formula  f,
const bdd_dict_ptr &  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().

Referenced by formula_to_bdd().

◆ formula_to_bdd() [2/2]

template<typename T >
bdd spot::formula_to_bdd ( formula  f,
const bdd_dict_ptr &  d,
const std::shared_ptr< T > &  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().

References bdd_to_formula(), and formula_to_bdd().

◆ get_couvreur99_new()

emptiness_check_ptr spot::get_couvreur99_new ( const const_twa_ptr &  a,
option_map  o 
)

A rewritten version of the Couvreur emptiness check.

It is optimized to run on explicit automata (avoiding the memory allocations of the virtual, abstract interface. It also has specializations for weak and terminal automata.

◆ get_couvreur99_new_abstract()

emptiness_check_ptr spot::get_couvreur99_new_abstract ( const const_twa_ptr &  a,
option_map  o 
)

Same as above, but always uses the abstract interface.

This function is provided to test the efficiency of specializing our algorithms for explicit automata. It uses the same optimizations for weak and terminal automata as the one above.

◆ get_states_set()

std::set<const state*> spot::get_states_set ( const const_ta_ptr &  t)

Compute states set for an automaton.

Referenced by spot::ta_explicit::get_artificial_initial_state().

◆ has_separate_sets()

bool spot::has_separate_sets ( const const_twa_graph_ptr &  aut)

Whether the Inf and Fin numbers are disjoints.

◆ highlight_languages()

void spot::highlight_languages ( twa_graph_ptr &  aut)

Color state that recognize identical language.

State that recognize a unique language will not be colored.

◆ is_a_kripkecube()

template<typename State , typename SuccIter >
bool spot::is_a_kripkecube ( kripkecube< State, SuccIter > &  )

This method allows to ensure (at compile time) if a given parameter is of type kripkecube. It also check if the iterator has the good interface.

◆ is_complete()

bool spot::is_complete ( const const_twa_graph_ptr &  aut)

Return true iff aut is complete.

An automaton is complete if its translation relation is total, i.e., each state as a successor for any possible configuration.

◆ is_inherently_weak_automaton()

bool spot::is_inherently_weak_automaton ( const const_twa_graph_ptr &  aut,
scc_info sm = nullptr 
)

Check whether an automaton is inherently weak.

An automaton is inherently weak if in any given SCC, there are only accepting cycles, or only rejecting cycles.

Parameters
autthe automaton to check
sman scc_info object for the automaton if available (it will be built otherwise).

In addition to returning the result as a Boolean, this will set the prop_inherently_weak() property of the automaton as a side-effect, so further calls will return in constant-time.

◆ is_safety_automaton()

bool spot::is_safety_automaton ( const const_twa_graph_ptr &  aut,
scc_info sm = nullptr 
)

Check whether an automaton is a safety automaton.

A safety automaton has only accepting SCCs (or trivial SCCs).

A minimized WDBA (as returned by a successful run of minimize_obligation()) represent safety property if it is a safety automaton.

Parameters
autthe automaton to check
sman scc_info object for the automaton if available (it will be built otherwise).

◆ is_semi_deterministic()

bool spot::is_semi_deterministic ( const const_twa_graph_ptr &  aut)

Return true iff aut is semi-deterministic.

An automaton is semi-deterministic if the sub-automaton reachable from any accepting SCC is deterministic.

◆ is_stutter_invariant()

bool spot::is_stutter_invariant ( formula  f)

Check if a formula has the stutter invariance property.

◆ is_terminal_automaton()

bool spot::is_terminal_automaton ( const const_twa_graph_ptr &  aut,
scc_info sm = nullptr,
bool  ignore_trivial_scc = false 
)

Check whether an automaton is terminal.

An automaton is terminal if it is weak, all its accepting SCCs are complete, and no accepting transitions lead to a non-accepting SCC.

If ignore_trivial_scc is set, accepting transitions from trivial SCCs are ignored.

This property guarantees that a word is accepted if it has some prefix that reaches an accepting transition.

Parameters
autthe automaton to check
sman scc_info object for the automaton if available (it will be built otherwise).

In addition to returning the result as a Boolean, this will set the prop_terminal() property of the automaton as a side-effect, so further calls will return in constant-time.

◆ is_very_weak_automaton()

bool spot::is_very_weak_automaton ( const const_twa_graph_ptr &  aut,
scc_info sm = nullptr 
)

Check whether an automaton is very-weak.

An automaton is very-weak if in any given SCC, all transitions belong to the same acceptance sets, and the SCC has only one state.

Parameters
autthe automaton to check
sman scc_info object for the automaton if available (it will be built otherwise).

In addition to returning the result as a Boolean, this will set the prop_very_weak() and prop_weak() properties of the automaton as a side-effect, so further calls will return in constant-time.

◆ is_weak_automaton()

bool spot::is_weak_automaton ( const const_twa_graph_ptr &  aut,
scc_info sm = nullptr 
)

Check whether an automaton is weak.

An automaton is weak if in any given SCC, all transitions belong to the same acceptance sets.

Parameters
autthe automaton to check
sman scc_info object for the automaton if available (it will be built otherwise).

In addition to returning the result as a Boolean, this will set the prop_weak() property of the automaton as a side-effect, so further calls will return in constant-time.

◆ language_map()

std::vector<unsigned> spot::language_map ( const const_twa_graph_ptr &  aut)

Identify states that recognize the same language.

The returned vector is the same size as the automaton's number of state. The number of different values (ignoring occurences) in the vector is the total number of recognized languages, states recognizing the same language have the same value.

The given automaton must be deterministic.

◆ list_formula_props()

std::list<std::string> spot::list_formula_props ( const formula f)

List the properties of formula f.

Referenced by spot::formula::traverse().

◆ make_bitvect()

bitvect* spot::make_bitvect ( size_t  bitcount)

Allocate a bit-vector of bitcount bits.

The resulting object should be released with delete.

Referenced by spot::bitvect::reserve_blocks().

◆ make_bitvect_array()

bitvect_array* spot::make_bitvect_array ( size_t  bitcount,
size_t  vectcount 
)

Allocate vectcount bit-vectors of bitcount bits.

The resulting bitvect_array should be released with delete.

Referenced by spot::bitvect_array::at(), and spot::bitvect::reserve_blocks().

◆ make_twa_word() [1/2]

twa_word_ptr spot::make_twa_word ( const bdd_dict_ptr &  dict)
inline

Create an empty twa_word.

Note that empty twa_word are invalid and cannot be printed. After creating an empty twa_word, you should at least populate the cycle.

◆ make_twa_word() [2/2]

twa_word_ptr spot::make_twa_word ( const twa_run_ptr &  run)
inline

Create a twa_word from a twa_run.

References parse_word().

◆ mask_acc_sets()

twa_graph_ptr spot::mask_acc_sets ( const const_twa_graph_ptr &  in,
acc_cond::mark_t  to_remove 
)

Remove all edges that belong to some given acceptance sets.

Referenced by transform_copy().

◆ mask_keep_accessible_states()

twa_graph_ptr spot::mask_keep_accessible_states ( const const_twa_graph_ptr &  in,
std::vector< bool > &  to_keep,
unsigned int  init 
)

Keep only the states specified by to_keep that are accessible.

Each index in the vector to_keep specifies wether or not to keep the transition that exit this state. The initial state will be set to init. Only states that are accessible from init via states in to_keep will be preserved.

See also
mask_keep_states

Referenced by transform_copy().

◆ mask_keep_states()

twa_graph_ptr spot::mask_keep_states ( const const_twa_graph_ptr &  in,
std::vector< bool > &  to_keep,
unsigned int  init 
)

Keep only the states as specified by to_keep.

Each index in the vector to_keep specifies wether or not to keep the transition that exit this state. The initial state will be set to init.

Note that the number of states in the result automaton is the same as in the input: only transitions have been removed.

See also
mask_keep_accessible_states

Referenced by transform_copy().

◆ memusage()

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.

◆ mp_class() [1/3]

char spot::mp_class ( formula  f)

Return the class of f in the temporal hierarchy of Manna and Pnueli (PODC'90).

The class is indicated using a character among:

  • 'B' (bottom) safety properties that are also guarantee properties
  • 'G' guarantee properties that are not also safety properties
  • 'S' safety properties that are not also guarantee properties
  • 'O' obligation properties that are not safety or guarantee properties
  • 'P' persistence properties that are not obligations
  • 'R' recurrence properties that are not obligations
  • 'T' (top) properties that are not persistence or recurrence properties

◆ mp_class() [2/3]

std::string spot::mp_class ( formula  f,
const char *  opt 
)

Return the class of f in the temporal hierarchy of Manna and Pnueli (PODC'90).

The opt parameter should be a string specifying options for expressing the class. If opt is empty, the result is one character among B, G, S, O, P, R, T, specifying the most precise class to which the formula belongs. If opt contains 'w', then the string contains all the characters corresponding to the classes that contain f. If opt contains 'v', then the characters are replaced by the name of each class. Space and commas are ignored. Any ']' ends the processing of the options.

◆ mp_class() [3/3]

std::string spot::mp_class ( char  mpc,
const char *  opt 
)

Expand a class in the temporal hierarchy of Manna and Pnueli (PODC'90).

mpc should be a character among B, G, S, O, P, R, T specifying a class in the hierarchy.

The opt parameter should be a string specifying options for expressing the class. If opt is empty, the result is mpc. If opt contains 'w', then the string contains all the characters corresponding to the super-classes of mpc. If opt contains 'v', then the characters are replaced by the name of each class. Space and commas are ignored. Any ']' ends the processing of the options.

◆ operator<<()

std::ostream& spot::operator<< ( std::ostream &  os,
const formula f 
)

Print a formula.

Referenced by spot::timer::walltime().

◆ otf_product()

twa_product_ptr spot::otf_product ( const const_twa_ptr &  left,
const const_twa_ptr &  right 
)
inline

on-the-fly TGBA product

◆ otf_product_at()

twa_product_ptr spot::otf_product_at ( const const_twa_ptr &  left,
const const_twa_ptr &  right,
const state left_init,
const state right_init 
)
inline

on-the-fly TGBA product with forced initial states

◆ parse_word()

twa_word_ptr spot::parse_word ( const std::string &  word,
const bdd_dict_ptr &  dict 
)

Parse a twa_word.

The input should have the form

BF;BF;...;BF;cycle{BF;BF;...;BF}

where BF can be any Boolean formula, and the prefix sequence (before cycle{...}) may be empty.

Parameters
wordthe string to parse
dictthe bdd_dict where atomic propositions should be registered

Referenced by make_twa_word().

◆ print_formula_props()

std::ostream& spot::print_formula_props ( std::ostream &  out,
const formula f,
bool  abbreviated = false 
)

Print the properties of formula f on stream out.

Referenced by spot::formula::traverse().

◆ prop_copy()

void spot::prop_copy ( const const_twa_ptr &  other,
prop_set  p 
)

Copy the properties of another automaton.

Copy the property speciefied with p from other to the current automaton.

There is no default value for p on purpose. This way any time we add a new property we have to update every call to prop_copy().

See also
prop_set

◆ prop_keep()

void spot::prop_keep ( prop_set  p)

Keep only a subset of properties of the current automaton.

All properties part of a group set to false in p are reset to their default value of trival::maybe().

◆ rabin_to_buchi_maybe()

twa_graph_ptr spot::rabin_to_buchi_maybe ( const const_twa_graph_ptr &  aut)

Convert a state-based Rabin automaton to Büchi automaton, preserving determinism when possible.

Return nullptr if the input is not a Rabin automaton, or is not state-based.

This essentially applies the algorithm from "Deterministic ω-automata vis-a-vis Deterministic Büchi Automata", S. Krishnan, A. Puri, and R. Brayton (ISAAC'94), but SCC-wise.

Unless you know what you are doing, you are probably better off calling remove_fin() instead, as this will call more specialized algorithms (e.g., for weak automata) when appropriate.

◆ random_acceptance()

acc_cond::acc_code spot::random_acceptance ( unsigned  n_accs)

Build a random acceptance where each acceptance sets is used once.

◆ randomize()

void spot::randomize ( twa_graph_ptr &  aut,
bool  randomize_states = true,
bool  randomize_edges = true 
)

Randomize a TGBA.

Make a random permutation of the state, and of the edges leaving this state.

This function preserves state names, and highlighted states, but it does not preserve highlighted edges.

◆ relabel_here()

void spot::relabel_here ( twa_graph_ptr &  aut,
relabeling_map *  relmap 
)

replace atomic propositions in an automaton

◆ remove_alternation()

twa_graph_ptr spot::remove_alternation ( const const_twa_graph_ptr &  aut,
bool  named_states = false 
)

Remove universal edges from an automaton.

This procedure is restricted to weak alternating automata as input, and produces TGBAs as output. (Generalized Büchi acceptance is only used in presence of size-1 rejecting-SCCs.)

Parameters
named_statesname each state for easier debugging

Referenced by states_and().

◆ remove_fin()

twa_graph_ptr spot::remove_fin ( const const_twa_graph_ptr &  aut)

Rewrite an automaton without Fin acceptance.

◆ remove_x()

formula spot::remove_x ( formula  f)

Rewrite a stutter-insensitive formula f without using the X operator.

This function may also be applied to stutter-sensitive formulas, but in that case the resulting formula is not equivalent.

@Article{         etessami.00.ipl,
author        = {Kousha Etessami},
title         = {A note on a question of {P}eled and {W}ilke regarding
stutter-invariant {LTL}},
journal       = {Information Processing Letters},
volume        = {75},
number        = {6},
year          = {2000},
pages         = {261--263}
}

◆ satone_to_cube()

spot::cube spot::satone_to_cube ( bdd  one,
cubeset cubeset,
std::unordered_map< int, int > &  binder 
)

Transform one truth assignment represented as a BDD into a cube cube passed in parameter. The parameter binder map bdd indexes to cube indexes.

◆ satsolver_get_solution()

std::vector<int> spot::satsolver_get_solution ( const char *  filename)

Extract the solution of a SAT solver output.

◆ sbacc()

twa_graph_ptr spot::sbacc ( twa_graph_ptr  aut)

Transform an automaton to use state-based acceptance.

This is independent on the acceptance condition used.

◆ scc_filter()

twa_graph_ptr spot::scc_filter ( const const_twa_graph_ptr &  aut,
bool  remove_all_useless = false,
scc_info given_si = nullptr 
)

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, for Generalized Büchi acceptance, 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 rejecting SCCs 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.

Warning
Calling scc_filter on a TωA 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.

◆ scc_filter_states()

twa_graph_ptr spot::scc_filter_states ( const const_twa_graph_ptr &  aut,
bool  remove_all_useless = false,
scc_info given_si = nullptr 
)

Prune unaccepting SCCs.

This is an abridged version of scc_filter(), that preserves state-based acceptance. I.e., if the input TωA has the SBA property, (i.e., transitions leaving accepting states are all marked as accepting), then the output TωA will also have that property.

◆ scc_filter_susp()

twa_graph_ptr spot::scc_filter_susp ( const const_twa_graph_ptr &  aut,
bool  remove_all_useless,
bdd  suspvars,
bdd  ignoredvars,
bool  early_susp,
scc_info given_si = nullptr 
)

Prune unaccepting SCCs, superfluous acceptance sets, and suspension variables.

In addition to removing useless states, and acceptance sets, this remove all ignoredvars occurring in conditions, and all suspvars in conditions leadings to non-accepting SCC (as well as the conditions between two SCCs if early_susp is false).

This is used by compsusp(), and is probably useless for any other use.

◆ separate_sets_here()

twa_graph_ptr spot::separate_sets_here ( const twa_graph_ptr &  aut)

Separate the Fin and Inf sets used by an automaton.

This makes sure that the numbers used a Fin and Inf are disjoints.

◆ star_normal_form()

formula spot::star_normal_form ( formula  sere,
snf_cache *  cache = nullptr 
)

Helper to rewrite a sere in Star Normal Form.

This should only be called on children of a Star operator. It corresponds to the E° operation defined in the following paper.

@Article{          bruggeman.96.tcs,
author        = {Anne Br{\"u}ggemann-Klein},
title                = {Regular Expressions into Finite Automata},
journal        = {Theoretical Computer Science},
year                = {1996},
volume        = {120},
pages                = {87--98}
}
Parameters
serethe SERE to rewrite
cachean optional cache

◆ star_normal_form_bounded()

formula spot::star_normal_form_bounded ( formula  sere,
snf_cache *  cache = nullptr 
)

A variant of star_normal_form() for r[*0..j] where j < ω.

◆ states_and() [1/2]

template<class I >
unsigned spot::states_and ( const twa_graph_ptr &  aut,
begin,
end 
)

Combine two states in a conjunction.

This creates a new state whose outgoing transitions are the conjunctions of the compatible transitions of s1 and s2.

Acceptance marks are dropped.

The results is very likely to be alternating.

Referenced by states_and().

◆ states_and() [2/2]

template<class T >
unsigned spot::states_and ( const twa_graph_ptr &  aut,
const std::initializer_list< T > &  il 
)

Combine two states in a conjunction.

This creates a new state whose outgoing transitions are the conjunctions of the compatible transitions of s1 and s2.

Acceptance marks are dropped.

The results is very likely to be alternating.

References remove_alternation(), and states_and().

◆ streett_to_generalized_buchi()

twa_graph_ptr spot::streett_to_generalized_buchi ( const const_twa_graph_ptr &  in)

Convert Streett acceptance into generalized Büchi acceptance.

◆ streett_to_generalized_buchi_maybe()

twa_graph_ptr spot::streett_to_generalized_buchi_maybe ( const const_twa_graph_ptr &  in)

Convert Streett acceptance into generalized Büchi only if SPOT_STREET_CONF_MIN is set to a number of pairs less than the number of pairs used by IN.

◆ sum() [1/2]

twa_graph_ptr spot::sum ( const const_twa_graph_ptr &  left,
const const_twa_graph_ptr &  right 
)

Sum two twa into a new twa, performing the union of the two input automatons.

Parameters
leftLeft term of the sum.
rightRight term of the sum.
Returns
A spot::twa_graph containing the sum of left and right

◆ sum() [2/2]

twa_graph_ptr spot::sum ( const const_twa_graph_ptr &  left,
const const_twa_graph_ptr &  right,
unsigned  left_state,
unsigned  right_state 
)

Sum two twa into a new twa, performing the union of the two input automatons.

Parameters
leftLeft term of the sum.
rightRight term of the sum.
left_stateInitial state of the left term of the sum.
right_stateInitial state of the right term of the sum.
Returns
A spot::twa_graph containing the sum of left and right

◆ sum_and() [1/2]

twa_graph_ptr spot::sum_and ( const const_twa_graph_ptr &  left,
const const_twa_graph_ptr &  right 
)

Sum two twa into a new twa, using a universal initial transition, performing the intersection of the two languages of the input automatons.

Parameters
leftLeft term of the sum.
rightRight term of the sum.
Returns
A spot::twa_graph containing the sum of left and right

◆ sum_and() [2/2]

twa_graph_ptr spot::sum_and ( const const_twa_graph_ptr &  left,
const const_twa_graph_ptr &  right,
unsigned  left_state,
unsigned  right_state 
)

Sum two twa into a new twa, using a universal initial transition, performing the intersection of the two languages of the input automatons.

Parameters
leftLeft term of the sum.
rightRight term of the sum.
left_stateInitial state of the left term of the sum.
right_stateInitial state of the right term of the sum.
Returns
A spot::twa_graph containing the sum of left and right

◆ tba_determinize()

twa_graph_ptr spot::tba_determinize ( const const_twa_graph_ptr &  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 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.

◆ tba_determinize_check()

twa_graph_ptr spot::tba_determinize_check ( const twa_graph_ptr &  aut,
unsigned  threshold_states = 0,
unsigned  threshold_cycles = 0,
formula  f = nullptr,
const_twa_graph_ptr  neg_aut = nullptr 
)

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.

◆ to_generalized_buchi()

twa_graph_ptr spot::to_generalized_buchi ( const const_twa_graph_ptr &  aut)

Take an automaton with any acceptance condition and return an equivalent Generalized Büchi automaton.

◆ to_generalized_rabin()

twa_graph_ptr spot::to_generalized_rabin ( const const_twa_graph_ptr &  aut,
bool  share_inf = false 
)

Take an automaton with any acceptance condition and return an equivalent Generalized Rabin automaton.

This works by putting the acceptance condition in disjunctive normal form, and then merging all the Fin(x1)&Fin(x2)&...&Fin(xn) that may occur in clauses into a single Fin(X).

The acceptance-set numbers used by Inf may appear in multiple clauses if share_inf is set.

◆ to_generalized_streett()

twa_graph_ptr spot::to_generalized_streett ( const const_twa_graph_ptr &  aut,
bool  share_fin = false 
)

Take an automaton with any acceptance condition and return an equivalent Generalized Streett automaton.

This works by putting the acceptance condition in cunjunctive normal form, and then merging all the Inf(x1)|Inf(x2)|...|Inf(xn) that may occur in clauses into a single Inf(X).

The acceptance-set numbers used by Fin may appear in multiple clauses if share_fin is set.

◆ transform_accessible()

template<typename Trans >
void spot::transform_accessible ( const const_twa_graph_ptr &  old,
twa_graph_ptr &  cpy,
Trans  trans,
unsigned int  init 
)

Clone and mask an automaton.

Copy the edges of automaton old, into automaton cpy, creating new states at the same time. The argument trans should behave as a function with the following prototype: void (*trans) (unsigned src, bdd& cond, acc_cond::mark_t& acc, unsigned dst) It can modify either the condition or the acceptance sets of the edges. Set the condition to bddfalse to remove the edge (this will also remove the destination state and its descendants if they are not reachable by another edge).

Parameters
initThe optional new initial state.

References U.

Referenced by transform_copy().

◆ transform_copy()

template<typename Trans >
void spot::transform_copy ( const const_twa_graph_ptr &  old,
twa_graph_ptr &  cpy,
Trans  trans,
unsigned int  init 
)

Copy an automaton and update each edge.

Copy the states of automaton old, into automaton cpy. Each state in cpy will have the same id as the ones in old. The argument trans should behave as a function with the following prototype: void (*trans) (unsigned srcbdd& cond, acc_cond::mark_t& acc, unsigned dst) It can modify either the condition or the acceptance sets of the edges. Set the condition to bddfalse to remove it. Note that all transtions will be processed.

Parameters
initThe optional new initial state.

References mask_acc_sets(), mask_keep_accessible_states(), mask_keep_states(), and transform_accessible().

◆ twa_to_twacube()

twacube_ptr spot::twa_to_twacube ( spot::const_twa_graph_ptr  aut)

Convert a twa into a twacube.

◆ twacube_to_twa()

spot::twa_graph_ptr spot::twacube_to_twa ( spot::twacube_ptr  twacube)

Convert a twacube into a twa.

Variable Documentation

◆ dichotomy

* spot::dichotomy
Initial value:
= 1
* incr = 1
* fixed number of states before starting from scratch
* incr < 0
* colored = 1
* */
twa_graph_ptr
sat_minimize(twa_graph_ptr aut, const char* opt, bool state_based = false)

High-level interface to SAT-based minimization.

Minimize the automaton aut, using options opt. These options are given as a comma-separated list of assignments of the form:

states = 10 // synthetize automaton with fixed number of states max-states = 20 // minimize starting from this upper bound acc = "generalized-Buchi 2" acc = "Rabin 3" acc = "same" /* default


Please direct any question, comment, or bug report to the Spot mailing list at spot@lrde.epita.fr.
Generated on Tue Apr 18 2017 14:42:57 for spot by doxygen 1.8.13