spot  1.2.6
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
Classes | Functions
Translating LTL formulae into TGBA

Classes

class  spot::translator
 Translate an LTL formula into an optimized spot::tgba. More...
 

Functions

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

Detailed Description

Function Documentation

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

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

@techreport{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}
}
Parameters
fThe formula to translate into an automaton.
dictThe spot::bdd_dict the constructed automata should use.
refined_rulesIf this parameter is set, refined rules are used.
Returns
A spot::taa that recognizes the language of f.
SPOT_API 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.

@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
fThe formula to translate into an automaton.
dictThe spot::bdd_dict the constructed automata should use.
expropWhen 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_mergeWhen false, states with the same symbolic representation (these are equivalent formulae) will not be merged.
branching_postponementWhen 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_approxWhen set, a really simple characterization of unstable state is used to suppress all acceptance conditions from incoming transitions.
unobsWhen 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 unobs can be filled with additional unobservable events.
simplifierIf this parameter is set, the LTL formulae representing each state of the automaton will be simplified before computing the successor. simpl should be configured for the type of reduction you want, see spot::ltl::ltl_simplifier. This idea is taken from the following paper.
@InProceedings{   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}
}
Returns
A spot::tgba_explicit that recognizes the language of f.
SPOT_API 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.

@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
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 direct any question, comment, or bug report to the Spot mailing list at spot@lrde.epita.fr.
Generated on Sat Dec 6 2014 12:28:44 for spot by doxygen 1.8.4