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


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 that tries 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.
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)
 Remove some node of the automata using a simulation relation.
simulation_relationget_direct_relation_simulation (const tgba *a, std::ostream &os, int opt=-1)
 Compute a direct simulation relation on state of tgba f.
simulation_relationget_delayed_relation_simulation (const tgba *a, std::ostream &os, int opt=-1)
 Compute a delayed simulation relation on state of tgba f.
void free_relation_simulation (simulation_relation *rel)
 To free a simulation relation.
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 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,
std::ostream &  os,
int  opt = -1
 

Compute a delayed simulation relation on state of tgba f.

simulation_relation* get_direct_relation_simulation const tgba *  a,
std::ostream &  os,
int  opt = -1
 

Compute a direct simulation relation on state of tgba f.

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

Print reachable states in LBTT format.

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}
      }
      

Parameters:
f The formula to translate into an automata.
dict The spot::bdd_dict the constructed automata should use.
exprop When 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).
symb_merge When false, states with the same symbolic representation (these are equivalent formulae) will not be merged.
branching_postponement When 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}
      }
      
fair_loop_approx When set, a really simple characterization of unstable state is used to suppress all acceptance conditions from incoming transitions.
Returns:
A spot::tgba_explicit that recognizes the language of f.

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}
      }
      
Parameters:
f The formula to translate into an automata.
dict The spot::bdd_dict the constructed automata should use.
Returns:
A spot::tgba_bdd_concrete that recognizes the language of f.

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& 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
 

Remove some node of the automata using a simulation relation.

Parameters:
a the automata to reduce.
opt a conjonction of spot::reduce_tgba_options specifying which optimizations to apply.
Returns:
the reduced automata.

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.


Please comment this page and report errors about it on the RefDocComments page.
Generated on Fri Aug 13 14:43:16 2004 for spot by doxygen 1.3.8