spot  1.0
Functions
Transforming TGBA into TA
TA algorithms

Functions

ta_explicit * spot::tgba_to_ta (const tgba *tgba_to_convert, bdd atomic_propositions_set, bool degeneralized=true, bool artificial_initial_state_mode=true, bool single_pass_emptiness_check=false, bool artificial_livelock_state_mode=false)
 Build a spot::ta_explicit* (TA) from an LTL formula.This is based on the following paper.
tgta_explicit * spot::tgba_to_tgta (const tgba *tgba_to_convert, bdd atomic_propositions_set)
 Build a spot::tgta_explicit* (TGTA) from an LTL formula.

Detailed Description

Function Documentation

ta_explicit* spot::tgba_to_ta ( const tgba *  tgba_to_convert,
bdd  atomic_propositions_set,
bool  degeneralized = true,
bool  artificial_initial_state_mode = true,
bool  single_pass_emptiness_check = false,
bool  artificial_livelock_state_mode = false 
)

Build a spot::ta_explicit* (TA) from an LTL formula.This is based on the following paper.

@verbatim 

/// { geldenhuys.06.spin, /// author = {Jaco Geldenhuys and Henri Hansen}, /// title = {Larger Automata and Less Work for {LTL} Model Checking}, /// booktitle = {Proceedings of the 13th International SPIN Workshop /// (SPIN'06)}, /// year = {2006}, /// pages = {53–70}, /// series = {Lecture Notes in Computer Science}, /// volume = {3925}, /// publisher = {Springer} /// } ///

\param tgba_to_convert The TGBA automaton to convert into a TA automaton

\param atomic_propositions_set The set of atomic propositions used in the
input TGBA \a tgba_to_convert

\param degeneralized When false, the returned automaton is a generalized
form of TA, called GTA (Generalized Testing Automaton).
Like TGBA, GTA use Generalized Büchi acceptance
conditions intead of Buchi-accepting states: there are several acceptance
sets (of transitions), and a path is accepted if it traverses
at least one transition of each set infinitely often or if it contains a
livelock-accepting cycle (like a TA). The spot emptiness check algorithm
for TA (spot::ta_check::check) can also be used to check GTA.

\param artificial_initial_state_mode When set, the algorithm will build
a TA automaton with an unique initial state.  This
artificial initial state have one transition to each real initial state,
and this transition is labeled by the corresponding initial condition.
(see spot::ta::get_artificial_initial_state())

\param single_pass_emptiness_check When set, the product between the
returned automaton and a kripke structure requires only the fist pass of
the emptiness check algorithm (see the parameter \c disable_second_pass
of the method spot::ta_check::check)

\param artificial_livelock_state_mode When set, the returned TA automaton
 is a STA (Single-pass Testing Automata): a STA automaton is a TA
where: for every livelock-accepting state s, if s is not also a
Buchi-accepting state, then s has no successors. A STA product requires
only one-pass emptiness check algorithm (see spot::ta_check::check)

\return A spot::ta_explicit that recognizes the same language as the
TGBA \a tgba_to_convert.  
tgta_explicit* spot::tgba_to_tgta ( const tgba *  tgba_to_convert,
bdd  atomic_propositions_set 
)

Build a spot::tgta_explicit* (TGTA) from an LTL formula.

Parameters
tgba_to_convertThe TGBA automaton to convert into a TGTA automaton
atomic_propositions_setThe set of atomic propositions used in the input TGBA tgba_to_convert
Returns
A spot::tgta_explicit (spot::tgta) that recognizes the same language as the TGBA tgba_to_convert.

Please comment this page and report errors about it on the RefDocComments page.
Generated on Sat Oct 27 2012 09:34:33 for spot by doxygen 1.8.1.2