spot
0.8.2
|
Classes | |
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 |
Typedefs | |
typedef std::vector < spoiler_node * > | spot::sn_v |
typedef std::vector < duplicator_node * > | spot::dn_v |
typedef std::vector< const state * > | spot::s_v |
Enumerations | |
enum | spot::reduce_tgba_options { spot::Reduce_None = 0, spot::Reduce_quotient_Dir_Sim = 1, spot::Reduce_transition_Dir_Sim = 2, spot::Reduce_quotient_Del_Sim = 4, spot::Reduce_transition_Del_Sim = 8, spot::Reduce_Scc = 16, spot::Reduce_All = -1U } |
Options for reduce. More... | |
Functions | |
tgba_explicit_number * | spot::minimize_monitor (const tgba *a) |
Construct a minimal deterministic monitor. | |
tgba_explicit_number * | spot::minimize_wdba (const tgba *a) |
Minimize a Büchi automaton in the WDBA class. | |
const tgba * | spot::minimize_obligation (const tgba *aut_f, const ltl::formula *f=0, const tgba *aut_neg_f=0) |
Minimize an automaton if it represents an obligation property. | |
const tgba * | spot::reduc_tgba_sim (const tgba *a, int opt=Reduce_All) |
Remove some node of the automata using a simulation relation. | |
direct_simulation_relation * | spot::get_direct_relation_simulation (const tgba *a, std::ostream &os, int opt=-1) |
Compute a direct simulation relation on state of tgba f. | |
delayed_simulation_relation * | spot::get_delayed_relation_simulation (const tgba *a, std::ostream &os, int opt=-1) |
void | spot::free_relation_simulation (direct_simulation_relation *rel) |
To free a simulation relation. | |
void | spot::free_relation_simulation (delayed_simulation_relation *rel) |
To free a simulation relation. |
typedef std::vector<duplicator_node*> spot::dn_v |
typedef std::vector<const state*> spot::s_v |
typedef std::vector<spoiler_node*> spot::sn_v |
Options for reduce.
void spot::free_relation_simulation | ( | direct_simulation_relation * | rel | ) |
To free a simulation relation.
void spot::free_relation_simulation | ( | delayed_simulation_relation * | rel | ) |
To free a simulation relation.
delayed_simulation_relation* spot::get_delayed_relation_simulation | ( | const tgba * | a, |
std::ostream & | os, | ||
int | opt = -1 |
||
) |
Compute a delayed simulation relation on state of tgba f.
direct_simulation_relation* spot::get_direct_relation_simulation | ( | const tgba * | a, |
std::ostream & | os, | ||
int | opt = -1 |
||
) |
Compute a direct simulation relation on state of tgba f.
tgba_explicit_number* spot::minimize_monitor | ( | const tgba * | a | ) |
Construct a minimal deterministic monitor.
The automaton will be converted into minimal deterministic monitor. All useless SCCs should have been previously removed (using scc_filter() for instance). Then the automaton will be determinized and minimized using the standard DFA construction as if all states where accepting states.
For more detail about monitors, see the following paper:
/// @InProceedings{ tabakov.10.rv, /// author = {Deian Tabakov and Moshe Y. Vardi}, /// title = {Optimized Temporal Monitors for SystemC{$^*$}}, /// booktitle = {Proceedings of the 10th International Conferance /// on Runtime Verification}, /// pages = {436--451}, /// year = 2010, /// volume = {6418}, /// series = {Lecture Notes in Computer Science}, /// month = nov, /// publisher = {Spring-Verlag} /// } ///
(Note: although the above paper uses Spot, this function did not exist in Spot at that time.)
a | the automaton to convert into a minimal deterministic monitor |
const tgba* spot::minimize_obligation | ( | const tgba * | aut_f, |
const ltl::formula * | f = 0 , |
||
const tgba * | aut_neg_f = 0 |
||
) |
Minimize an automaton if it represents an obligation property.
This function attempts to minimize the automaton aut_f using the algorithm implemented in the minimize_wdba() function, and presented by the following paper:
/// @InProceedings{ dax.07.atva, /// author = {Christian Dax and Jochen Eisinger and Felix Klaedtke}, /// title = {Mechanizing the Powerset Construction for Restricted /// Classes of {$\omega$}-Automata}, /// year = 2007, /// series = {Lecture Notes in Computer Science}, /// publisher = {Springer-Verlag}, /// volume = 4762, /// booktitle = {Proceedings of the 5th International Symposium on /// Automated Technology for Verification and Analysis /// (ATVA'07)}, /// editor = {Kedar S. Namjoshi and Tomohiro Yoneda and Teruo Higashino /// and Yoshio Okamura}, /// month = oct /// } ///
Because it is hard to determine if an automaton corresponds to an obligation property, you should supply either the formula f expressed by the automaton aut_f, or aut_neg_f the negation of the automaton aut_neg_f.
aut_f | the automaton to minimize |
f | the LTL formula represented by the automaton aut_f |
aut_neg_f | an automaton representing the negation of aut_f |
The function proceeds as follows. If the formula f or the automaton aut can easily be proved to represent an obligation formula, then the result of minimize(aut)
is returned. Otherwise, if aut_neg_f was not supplied but f was, aut_neg_f is built from the negation of f. Then we check that product(aut,!minimize(aut_f))
and product(aut_neg_f,minize(aut))
are both empty. If they are, the the minimization was sound. (See the paper for full details.)
tgba_explicit_number* spot::minimize_wdba | ( | const tgba * | a | ) |
Minimize a Büchi automaton in the WDBA class.
This takes a TGBA whose language is representable by a Weak Deterministic Büchi Automaton, and construct a minimal WDBA for this language.
If the input automaton does not represent a WDBA language, the resulting automaton is still a WDBA, but it will not be equivalent to the original automaton. Use the minimize_obligation() function if you are not sure whether it is safe to call this function.
Please see the following paper for a discussion of this technique.
/// @InProceedings{ dax.07.atva, /// author = {Christian Dax and Jochen Eisinger and Felix Klaedtke}, /// title = {Mechanizing the Powerset Construction for Restricted /// Classes of {$\omega$}-Automata}, /// year = 2007, /// series = {Lecture Notes in Computer Science}, /// publisher = {Springer-Verlag}, /// volume = 4762, /// booktitle = {Proceedings of the 5th International Symposium on /// Automated Technology for Verification and Analysis /// (ATVA'07)}, /// editor = {Kedar S. Namjoshi and Tomohiro Yoneda and Teruo Higashino /// and Yoshio Okamura}, /// month = oct /// } ///
const tgba* spot::reduc_tgba_sim | ( | const tgba * | a, |
int | opt = Reduce_All |
||
) |
Remove some node of the automata using a simulation relation.
a | the automata to reduce. |
opt | a conjonction of spot::reduce_tgba_options specifying which optimizations to apply. |