spot  1.0.2
Functions
Translating LTL formulae into TGBA
TGBA algorithms

Functions

tgba_bdd_concrete * spot::eltl_to_tgba_lacim (const ltl::formula *f, bdd_dict *dict)
 Build a spot::tgba_bdd_concrete from an ELTL formula.This is based on the following paper.
taa_tgba * spot::ltl_to_taa (const ltl::formula *f, bdd_dict *dict, bool refined_rules=false)
 Build a spot::taa* from an LTL formula.This is based on the following.
tgba_explicit_formula * spot::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, const ltl::atomic_prop_set *unobs=0, ltl::ltl_simplifier *simplifier=0)
 Build a spot::tgba_explicit* from an LTL formula.This is based on the following paper.
tgba_bdd_concrete * spot::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.

Detailed Description

Function Documentation

tgba_bdd_concrete* spot::eltl_to_tgba_lacim ( const ltl::formula *  f,
bdd_dict *  dict 
)

Build a spot::tgba_bdd_concrete from an ELTL formula.This is based on the following paper.

@verbatim 

/// { 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
fThe formula to translate into an automaton.
dictThe spot::bdd_dict the constructed automata should use.
Returns
A spot::tgba_bdd_concrete that recognizes the language of f.
taa_tgba* spot::ltl_to_taa ( const ltl::formula *  f,
bdd_dict *  dict,
bool  refined_rules = false 
)

Build a spot::taa* from an LTL formula.This is based on the following.

@verbatim 

/// {HUT-TCS-A104, /// address = {Espoo, Finland}, /// author = {Heikki Tauriainen}, /// month = {September}, /// note = {Doctoral dissertation}, /// number = {A104}, /// pages = {xii+229}, /// title = {Automata and Linear Temporal Logic: Translations /// with Transition-Based Acceptance}, /// type = {Research Report}, /// year = {2006} /// } ///

\param f The formula to translate into an automaton.
\param dict The spot::bdd_dict the constructed automata should use.
\param refined_rules If this parameter is set, refined rules are used.
\return A spot::taa that recognizes the language of \a f.  
tgba_explicit_formula* spot::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,
const ltl::atomic_prop_set *  unobs = 0,
ltl::ltl_simplifier *  simplifier = 0 
)

Build a spot::tgba_explicit* from an LTL formula.This is based on the following paper.

@verbatim 

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

\param f The formula to translate into an automaton.

\param dict The spot::bdd_dict the constructed automata should use.

\param 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).

\param symb_merge When false, states with the same symbolic
representation (these are equivalent formulae) will not be
merged.

\param 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.
@verbatim 

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

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

\param unobs When non-zero, the atomic propositions in the LTL formula
are interpreted as events that exclude each other.  The events in the
formula are observable events, and \c unobs can be filled with
additional unobservable events.

\param simplifier If this parameter is set, the LTL formulae
representing each state of the automaton will be simplified
before computing the successor.  \a simpl should be configured
for the type of reduction you want, see
spot::ltl::ltl_simplifier.  This idea is taken from the
following paper.
@verbatim 

/// { thirioux.02.fmics, /// author = {Xavier Thirioux}, /// title = {Simple and Efficient Translation from {LTL} Formulas to /// {B"u}chi Automata}, /// booktitle = {Proceedings of the 7th International ERCIM Workshop in /// Formal Methods for Industrial Critical Systems (FMICS'02)}, /// series = {Electronic Notes in Theoretical Computer Science}, /// volume = {66(2)}, /// publisher = {Elsevier}, /// editor = {Rance Cleaveland and Hubert Garavel}, /// year = {2002}, /// month = jul, /// address = {M{\'a}laga, Spain} /// } ///

\return A spot::tgba_explicit that recognizes the language of \a f.  
tgba_bdd_concrete* spot::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.

@verbatim 

/// { 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
fThe formula to translate into an automaton.
dictThe spot::bdd_dict the constructed automata should use.
Returns
A spot::tgba_bdd_concrete that recognizes the language of f.

Please comment this page and report errors about it on the RefDocComments page.
Generated on Wed Mar 6 2013 09:25:15 for spot by doxygen 1.8.1.2