Main Page | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members

spot Namespace Reference


Classes

class  spot::bdd_allocator
 Manage ranges of variables. More...

struct  spot::bdd_less_than
 Comparison functor for BDDs. More...

class  spot::free_list
 Manage list of free integers. More...

struct  spot::ptr_hash< T >
 A hash function for pointers. More...

struct  spot::string_hash
 A hash function for strings. More...

class  spot::minato_isop
 Generate an irredundant sum-of-products (ISOP) form of a BDD function. More...

struct  spot::minato_isop::local_vars
 Internal variables for minato_isop. More...

class  spot::bdd_dict
 Map BDD variables to formulae. More...

class  spot::bdd_dict::annon_free_list
class  spot::state
 Abstract class for states. More...

struct  spot::state_ptr_less_than
 Strict Weak Ordering for state*. More...

struct  spot::state_ptr_equal
 An Equivalence Relation for state*. More...

struct  spot::state_ptr_hash
 Hash Function for state*. More...

class  spot::state_bdd
 A state whose representation is a BDD. More...

class  spot::tgba_succ_iterator
 Iterate over the successors of a state. More...

class  spot::tgba_succ_iterator_concrete
 A concrete iterator over successors of a TGBA state. More...

class  spot::tgba
 A Transition-based Generalized Büchi Automaton. More...

class  spot::tgba_bdd_concrete
 A concrete spot::tgba implemented using BDDs. More...

class  spot::tgba_bdd_concrete_factory
 Helper class to build a spot::tgba_bdd_concrete object. More...

struct  spot::tgba_bdd_core_data
 Core data for a TGBA encoded using BDDs. More...

class  spot::tgba_bdd_factory
 Abstract class for spot::tgba_bdd_concrete factories. More...

class  spot::tgba_explicit
 Explicit representation of a spot::tgba. More...

struct  spot::tgba_explicit::transition
 Explicit transitions (used by spot::tgba_explicit). More...

class  spot::state_explicit
 States used by spot::tgba_explicit. More...

class  spot::tgba_explicit_succ_iterator
 Successor iterators used by spot::tgba_explicit. More...

class  spot::state_product
 A state for spot::tgba_product. More...

class  spot::tgba_succ_iterator_product
 Iterate over the successors of a product computed on the fly. More...

class  spot::tgba_product
 A lazy product. (States are computed on the fly.). More...

class  spot::tgba_reduc
class  spot::tgba_tba_proxy
 Degeneralize a spot::tgba on the fly. More...

class  spot::counter_example
 Compute a counter example from a spot::emptiness_check_status. More...

class  spot::explicit_connected_component
 An SCC storing all its states explicitly. More...

class  spot::connected_component_hash_set
class  spot::explicit_connected_component_factory
 Abstract factory for explicit_connected_component. More...

class  spot::connected_component_hash_set_factory
 Factory for connected_component_hash_set. More...

class  spot::emptiness_check
 Check whether the language of an automate is empty. More...

class  spot::emptiness_check_shy
 A version of spot::emptiness_check try to visit known states first. More...

struct  spot::emptiness_check_shy::successor
class  spot::numbered_state_heap_const_iterator
 Iterator on numbered_state_heap objects. More...

class  spot::numbered_state_heap
 Keep track of a large quantity of indexed states. More...

class  spot::numbered_state_heap_factory
 Abstract factory for numbered_state_heap. More...

class  spot::numbered_state_heap_hash_map
 A straightforward implementation of numbered_state_heap with a hash map. More...

class  spot::numbered_state_heap_hash_map_factory
 Factory for numbered_state_heap_hash_map. More...

class  spot::scc_stack
struct  spot::scc_stack::connected_component
class  spot::emptiness_check_status
 The status of the emptiness-check on success. More...

struct  spot::magic_search
 Emptiness check on spot::tgba_tba_proxy automata using the Magic Search algorithm. More...

struct  spot::magic_search::magic
 Records whether a state has be seen with the magic bit on or off. More...

struct  spot::magic_search::magic_state
 A state for the spot::magic_search algorithm. More...

class  spot::tgba_reachable_iterator
 Iterate over all reachable states of a spot::tgba. More...

class  spot::tgba_reachable_iterator_depth_first
 An implementation of spot::tgba_reachable_iterator that browses states depth first. More...

class  spot::tgba_reachable_iterator_breadth_first
 An implementation of spot::tgba_reachable_iterator that browses states breadth first. More...

class  spot::parity_game_graph
 Parity game graph which compute a simulation relation. More...

class  spot::spoiler_node
 Spoiler node of parity game graph. More...

class  spot::duplicator_node
 Duplicator node of parity game graph. More...

class  spot::parity_game_graph_direct
 Parity game graph which compute the direct simulation relation. More...

class  spot::spoiler_node_delayed
 Spoiler node of parity game graph for delayed simulation. More...

class  spot::duplicator_node_delayed
 Duplicator node of parity game graph for delayed simulation. More...

class  spot::parity_game_graph_delayed
struct  spot::tgba_statistics
class  spot::gspn_exeption
 An exeption used to forward GSPN errors. More...

class  spot::gspn_interface
class  spot::gspn_ssp_interface

Typedefs

typedef Sgi::pair< const spot::state *,
const spot::state * > 
state_couple
typedef Sgi::vector< state_couple * > simulation_relation
typedef Sgi::vector< spoiler_node * > sn_v
typedef Sgi::vector< duplicator_node * > dn_v
typedef Sgi::vector< const
state * > 
s_v
typedef std::pair< yy::Location,
std::string > 
tgba_parse_error
 A parse diagnostic with its location.

typedef std::list< tgba_parse_errortgba_parse_error_list
 A list of parser diagnostics, as filled by parse.


Enumerations

enum  reduce_tgba_options {
  Reduce_None = 0, Reduce_Dir_Sim = 1, Reduce_Del_Sim = 2, Reduce_Scc = 4,
  Reduce_All = -1U
}
 Options for reduce. More...


Functions

std::ostream & escape_str (std::ostream &os, const std::string &str)
 Escape " and \ characters in str.

std::string escape_str (const std::string &str)
 Escape " and \ characters in str.

const char * version ()
 Return Spot's version.

std::ostream & bdd_print_sat (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a list of literals.

std::string bdd_format_sat (const bdd_dict *dict, bdd b)
 Format a BDD as a list of literals.

std::ostream & bdd_print_acc (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a list of acceptance conditions.

std::ostream & bdd_print_accset (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a set of acceptance conditions.

std::string bdd_format_accset (const bdd_dict *dict, bdd b)
 Format a BDD as a set of acceptance conditions.

std::ostream & bdd_print_set (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a set.

std::string bdd_format_set (const bdd_dict *dict, bdd b)
 Format a BDD as a set.

std::ostream & bdd_print_formula (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a formula.

std::string bdd_format_formula (const bdd_dict *dict, bdd b)
 Format a BDD as a formula.

std::ostream & bdd_print_dot (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a diagram in dotty format.

std::ostream & bdd_print_table (std::ostream &os, const bdd_dict *dict, bdd b)
 Print a BDD as a table.

bdd formula_to_bdd (const ltl::formula *f, bdd_dict *d, void *for_me)
const ltl::formulabdd_to_formula (bdd f, const bdd_dict *d)
tgba_bdd_concreteproduct (const tgba_bdd_concrete *left, const tgba_bdd_concrete *right)
 Multiplies two tgba::tgba_bdd_concrete automata.

std::ostream & dotty_reachable (std::ostream &os, const tgba *g)
 Print reachable states in dot format.

tgba_explicittgba_dupexp_bfs (const tgba *aut)
tgba_explicittgba_dupexp_dfs (const tgba *aut)
std::ostream & lbtt_reachable (std::ostream &os, const tgba *g)
 Print reachable states in LBTT format.

std::ostream & nonacceptant_lbtt_reachable (std::ostream &os, const tgba *g)
 Print an LBTT automaton for statistics.

tgba_explicitltl_to_tgba_fm (const ltl::formula *f, bdd_dict *dict, bool exprop=false, bool symb_merge=true, bool branching_postponement=false, bool fair_loop_approx=false)
 Build a spot::tgba_explicit* from an LTL formula.

tgba_bdd_concreteltl_to_tgba_lacim (const ltl::formula *f, bdd_dict *dict)
std::ostream & never_claim_reachable (std::ostream &os, const tgba_tba_proxy *g, const ltl::formula *f=0)
 Print reachable states in Spin never claim format.

tgba_explicittgba_powerset (const tgba *aut)
 Build a deterministic automaton, ignoring acceptance conditions.

tgbareduc_tgba_sim (const tgba *a, int opt=Reduce_All)
 the reduced automata.

simulation_relationget_direct_relation_simulation (const tgba *a, int opt=-1)
 Compute a direct simulation relation on state of tgba f.

simulation_relationget_delayed_relation_simulation (const tgba *a, int opt=-1)
void free_relation_simulation (simulation_relation *rel)
 To free a simulation relation.

bool is_include (const tgba *a1, const tgba *a2)
std::ostream & tgba_save_reachable (std::ostream &os, const tgba *g)
 Save reachable states in text format.

tgba_statistics stats_reachable (const tgba *g)
 Compute statistics for an automata.

tgba_explicittgba_parse (const std::string &filename, tgba_parse_error_list &error_list, bdd_dict *dict, ltl::environment &env=ltl::default_environment::instance(), bool debug=false)
 Build a spot::tgba_explicit from a text file.

bool format_tgba_parse_errors (std::ostream &os, tgba_parse_error_list &error_list)
 Format diagnostics produced by spot::tgba_parse.

std::ostream & operator<< (std::ostream &os, const gspn_exeption &e)
emptiness_checkemptiness_check_ssp_semi (const tgba *ssp_automata)
emptiness_checkemptiness_check_ssp_shy_semi (const tgba *ssp_automata)
emptiness_checkemptiness_check_ssp_shy (const tgba *ssp_automata)
counter_examplecounter_example_ssp (const emptiness_check_status *status)


Typedef Documentation

typedef Sgi::vector<duplicator_node*> spot::dn_v
 

typedef Sgi::vector<const state*> spot::s_v
 

typedef Sgi::vector<state_couple*> spot::simulation_relation
 

typedef Sgi::vector<spoiler_node*> spot::sn_v
 

typedef Sgi::pair<const spot::state*, const spot::state*> spot::state_couple
 

typedef std::pair<yy::Location, std::string> spot::tgba_parse_error
 

A parse diagnostic with its location.

typedef std::list<tgba_parse_error> spot::tgba_parse_error_list
 

A list of parser diagnostics, as filled by parse.


Enumeration Type Documentation

enum spot::reduce_tgba_options
 

Options for reduce.

Enumeration values:
Reduce_None  No reduction.
Reduce_Dir_Sim  Reduction using direct simulation relation.
Reduce_Del_Sim  Reduction using delayed simulation relation.
Reduce_Scc  Reduction using SCC.
Reduce_All  All reductions.


Function Documentation

std::string bdd_format_accset const bdd_dict *  dict,
bdd  b
 

Format a BDD as a set of acceptance conditions.

This is used when saving a TGBA.

Parameters:
dict The dictionary to use, to lookup variables.
b The BDD to print.
Returns:
The BDD formated as a string.

std::string bdd_format_formula const bdd_dict *  dict,
bdd  b
 

Format a BDD as a formula.

Parameters:
dict The dictionary to use, to lookup variables.
b The BDD to print.
Returns:
The BDD formated as a string.

std::string bdd_format_sat const bdd_dict *  dict,
bdd  b
 

Format a BDD as a list of literals.

This assumes that b is a conjunction of literals.

Parameters:
dict The dictionary to use, to lookup variables.
b The BDD to print.
Returns:
The BDD formated as a string.

std::string bdd_format_set const bdd_dict *  dict,
bdd  b
 

Format a BDD as a set.

Parameters:
dict The dictionary to use, to lookup variables.
b The BDD to print.
Returns:
The BDD formated as a string.

std::ostream& bdd_print_acc std::ostream &  os,
const bdd_dict *  dict,
bdd  b
 

Print a BDD as a list of acceptance conditions.

This is used when saving a TGBA.

Parameters:
os The output stream.
dict The dictionary to use, to lookup variables.
b The BDD to print.
Returns:
The BDD formated as a string.

std::ostream& bdd_print_accset std::ostream &  os,
const bdd_dict *  dict,
bdd  b
 

Print a BDD as a set of acceptance conditions.

This is used when saving a TGBA.

Parameters:
os The output stream.
dict The dictionary to use, to lookup variables.
b The BDD to print.
Returns:
The BDD formated as a string.

std::ostream& bdd_print_dot std::ostream &  os,
const bdd_dict *  dict,
bdd  b
 

Print a BDD as a diagram in dotty format.

Parameters:
os The output stream.
dict The dictionary to use, to lookup variables.
b The BDD to print.

std::ostream& bdd_print_formula std::ostream &  os,
const bdd_dict *  dict,
bdd  b
 

Print a BDD as a formula.

Parameters:
os The output stream.
dict The dictionary to use, to lookup variables.
b The BDD to print.

std::ostream& bdd_print_sat std::ostream &  os,
const bdd_dict *  dict,
bdd  b
 

Print a BDD as a list of literals.

This assumes that b is a conjunction of literals.

Parameters:
os The output stream.
dict The dictionary to use, to lookup variables.
b The BDD to print.

std::ostream& bdd_print_set std::ostream &  os,
const bdd_dict *  dict,
bdd  b
 

Print a BDD as a set.

Parameters:
os The output stream.
dict The dictionary to use, to lookup variables.
b The BDD to print.

std::ostream& bdd_print_table std::ostream &  os,
const bdd_dict *  dict,
bdd  b
 

Print a BDD as a table.

Parameters:
os The output stream.
dict The dictionary to use, to lookup variables.
b The BDD to print.

const ltl::formula* bdd_to_formula bdd  f,
const bdd_dict *  d
 

counter_example* counter_example_ssp const emptiness_check_status *  status  ) 
 

std::ostream& dotty_reachable std::ostream &  os,
const tgba *  g
 

Print reachable states in dot format.

emptiness_check* emptiness_check_ssp_semi const tgba *  ssp_automata  ) 
 

emptiness_check* emptiness_check_ssp_shy const tgba *  ssp_automata  ) 
 

emptiness_check* emptiness_check_ssp_shy_semi const tgba *  ssp_automata  ) 
 

std::string escape_str const std::string &  str  ) 
 

Escape " and \ characters in str.

std::ostream& escape_str std::ostream &  os,
const std::string &  str
 

Escape " and \ characters in str.

bool format_tgba_parse_errors std::ostream &  os,
tgba_parse_error_list &  error_list
 

Format diagnostics produced by spot::tgba_parse.

Parameters:
os Where diagnostics should be output.
error_list The error list filled by spot::ltl::parse while parsing ltl_string.
Returns:
true iff any diagnostic was output.

bdd formula_to_bdd const ltl::formula *  f,
bdd_dict *  d,
void *  for_me
 

void free_relation_simulation simulation_relation *  rel  ) 
 

To free a simulation relation.

simulation_relation* get_delayed_relation_simulation const tgba *  a,
int  opt = -1
 

Compute a delayed simulation relation on state of tgba f. FIXME : this method is incorrect !! Don't use it !!

simulation_relation* get_direct_relation_simulation const tgba *  a,
int  opt = -1
 

Compute a direct simulation relation on state of tgba f.

bool is_include const tgba *  a1,
const tgba *  a2
 

Test if the initial state of a2 fair simulate this of a1. Not implemented.

std::ostream& lbtt_reachable std::ostream &  os,
const tgba *  g
 

Print reachable states in LBTT format.

Note that LBTT expects an automaton with transition labeled by propositional formulae, and generalized Büchi acceptance conditions on states. This is unlike our spot::tgba automata which put both generalized acceptance conditions (and propositional formulae) on transitions.

This algorithm will therefore produce an automata where acceptance conditions have been moved from each transition to the previous state. In the worst case, doing so will multiply the number of states and transitions of the automata by 2^|Acc|. where |Acc| is the number of acceptance conditions used by the automata. (It can be a bit more because LBTT allows only for one initial state: lbtt_reachable() may also have to create an additional state in case the source initial state had to be split.) You have been warned.

Parameters:
g The automata to print.
os Where to print.

tgba_explicit* ltl_to_tgba_fm const ltl::formula *  f,
bdd_dict *  dict,
bool  exprop = false,
bool  symb_merge = true,
bool  branching_postponement = false,
bool  fair_loop_approx = false
 

Build a spot::tgba_explicit* from an LTL formula.

This is based on the following paper.

@InProceedings{couvreur.99.fm, author = {Jean-Michel Couvreur}, title = {On-the-fly Verification of Temporal Logic}, pages = {253--271}, editor = {Jeannette M. Wing and Jim Woodcock and Jim Davies}, booktitle = {Proceedings of the World Congress on Formal Methods in the Development of Computing Systems (FM'99)}, publisher = {Springer-Verlag}, series = {Lecture Notes in Computer Science}, volume = {1708}, year = {1999}, address = {Toulouse, France}, month = {September}, isbn = {3-540-66587-0} }

If exprop is set, the algorithm will consider all properties combinations possible on each state, in an attempt to reduce the non-determinism. The automaton will have the same size as without this option, but because the transition will be more deterministic, the product automaton will be smaller (or, at worse, equal).

If symb_merge is set to false, states with the same symbolic representation (these are equivalent formulae) will not be merged.

If branching_postponement is set, several transitions leaving from the same state with the same label (i.e., condition + acceptance conditions) will be merged. This correspond to an optimization described in the following paper.

@InProceedings{ sebastiani.03.charme, author = {Roberto Sebastiani and Stefano Tonetta}, title = {"More Deterministic" vs. "Smaller" B{\"u}chi Automata for Efficient LTL Model Checking}, booktitle = {Proceedings for the 12th Advanced Research Working Conference on Correct Hardware Design and Verification Methods (CHARME'03)}, pages = {126--140}, year = {2003}, editor = {G. Goos and J. Hartmanis and J. van Leeuwen}, volume = {2860}, series = {Lectures Notes in Computer Science}, month = {October}, publisher = {Springer-Verlag} }

If fair_loop_approx is set, a really simple characterization of unstable state is used to suppress all acceptance conditions from incoming transitions.

tgba_bdd_concrete* ltl_to_tgba_lacim const ltl::formula *  f,
bdd_dict *  dict
 

Build a spot::tgba_bdd_concrete from an LTL formula.

This is based on the following paper.

@InProceedings{ couvreur.00.lacim, author = {Jean-Michel Couvreur}, title = {Un point de vue symbolique sur la logique temporelle lin{\'e}aire}, booktitle = {Actes du Colloque LaCIM 2000}, month = {August}, year = {2000}, pages = {131--140}, volume = {27}, series = {Publications du LaCIM}, publisher = {Universit{\'e} du Qu{\'e}bec {\`a} Montr{\'e}al}, editor = {Pierre Leroux} }

std::ostream& never_claim_reachable std::ostream &  os,
const tgba_tba_proxy *  g,
const ltl::formula *  f = 0
 

Print reachable states in Spin never claim format.

Parameters:
os The output stream to print on.
g The degeneralized automaton to output.
f The (optional) formula associated to the automaton. If given it will be output as a comment.

std::ostream& nonacceptant_lbtt_reachable std::ostream &  os,
const tgba *  g
 

Print an LBTT automaton for statistics.

Output g in LBTT's format but ignoring the acceptance conditions, of all its transitions. This produces an automaton that has the same size as g, and whose synchronized product with another automaton also has the same size. This will also declare as much acceptance conditions has there is in g (they will just be never used).

The produced automaton will not recognize any word (unless g has no acceptance condition, in which case this function is a no-op).

The produced automaton is useful to obtain accurate statistics from LBTT, without any size blow up of the automata.

std::ostream& operator<< std::ostream &  os,
const gspn_exeption &  e
 

tgba_bdd_concrete* product const tgba_bdd_concrete *  left,
const tgba_bdd_concrete *  right
 

Multiplies two tgba::tgba_bdd_concrete automata.

This function build the resulting product, as another tgba::tgba_bdd_concrete automaton.

tgba* reduc_tgba_sim const tgba *  a,
int  opt = Reduce_All
 

the reduced automata.

Parameters:
a the automata to reduce.
opt a conjonction of spot::reduce_tgba_options specifying

tgba_statistics stats_reachable const tgba *  g  ) 
 

Compute statistics for an automata.

tgba_explicit* tgba_dupexp_bfs const tgba *  aut  ) 
 

Build an explicit automata from all states of aut, numbering states in bread first order as they are processed.

tgba_explicit* tgba_dupexp_dfs const tgba *  aut  ) 
 

Build an explicit automata from all states of aut, numbering states in depth first order as they are processed.

tgba_explicit* tgba_parse const std::string &  filename,
tgba_parse_error_list &  error_list,
bdd_dict *  dict,
ltl::environment &  env = ltl::default_environment::instance(),
bool  debug = false
 

Build a spot::tgba_explicit from a text file.

Parameters:
filename The name of the file to parse.
error_list A list that will be filled with parse errors that occured during parsing.
dict The BDD dictionary where to use.
env The environment into which parsing should take place.
debug When true, causes the parser to trace its execution.
Returns:
A pointer to the tgba built from filename, or 0 if the file could not be opened.
Note that the parser usually tries to recover from errors. It can return an non zero value even if it encountered error during the parsing of filename. If you want to make sure filename was parsed succesfully, check error_list for emptiness.

Warning:
This function is not reentrant.

tgba_explicit* tgba_powerset const tgba *  aut  ) 
 

Build a deterministic automaton, ignoring acceptance conditions.

This create a deterministic automaton that recognize the same language as aut would if its acceptance conditions were ignored. This is the classical powerset algorithm.

std::ostream& tgba_save_reachable std::ostream &  os,
const tgba *  g
 

Save reachable states in text format.

const char* version  ) 
 

Return Spot's version.


Generated on Tue Jun 29 17:01:34 2004 for spot by doxygen 1.3.7