spot 2.3.3

- Main Page
- Related Pages
- Modules
- Classes
- Files

All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
Classes | Functions
Translating LTL formulas into TωA
TωA (Transition-based ω-Automata) » TωA algorithms

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

## Functions
taa_tgba_formula_ptr | spot::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 | spot::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...

## Detailed Description

## Function Documentation

taa_tgba_formula_ptr spot::ltl_to_taa | ( | formula | f,
|  | const bdd_dict_ptr & | dict,
|  | bool | refined_rules = `false`
| ) |  |

`#include <spot/twaalgos/ltl2taa.hh>`

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

  f | The formula to translate into an automaton.
  dict | The spot::bdd_dict the constructed automata should use.
  refined_rules | If this parameter is set, refined rules are used.

Returns
  A spot::taa that recognizes the language of f.

twa_graph_ptr spot::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`
| ) |  |

`#include <spot/twaalgos/ltl2tgba_fm.hh>`

Build a spot::twa_graph_ptr 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 automaton.
  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.
  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 `unobs` can be filled with additional unobservable events.
  simplifier | If 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::tl_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}
      }
  unambiguous | When true, unambigous TGBA will be produced using the trick described in the following paper.
      @InProceedings{          benedikt.13.tacas,
        author    = {Michael Benedikt and Rastislav Lenhardt and James
                       Worrell},
        title     = {{LTL} Model Checking of Interval Markov Chains},
        booktitle = {19th International Conference on Tools and Algorithms for
                           the Construction and Analysis of Systems (TACAS'13)},
        year      = {2013},
        pages     = {32--46},
        series    = {Lecture Notes in Computer Science},
        volume    = {7795},
        editor    = {Nir Piterman and Scott A. Smolka},
        publisher = {Springer}
      }

Returns
  A spot::twa_graph that recognizes the language of f.

Please direct any question, comment, or bug report to the Spot mailing list at spot@lrde.epita.fr.