Namespaces | |
namespace | formula_tree |
Trees representing formulae where atomic propositions are unknown. | |
Classes | |
class | atomic_prop |
Atomic propositions. More... | |
class | automatop |
Automaton operators. More... | |
class | binop |
Binary operator. More... | |
class | constant |
A constant (True or False). More... | |
class | formula |
An LTL formula.The only way you can work with a formula is to build a spot::ltl::visitor or spot::ltl::const_visitor. More... | |
struct | formula_ptr_less_than |
Strict Weak Ordering for const formula* .This is meant to be used as a comparison functor for STL map whose key are of type const formula* . More... | |
struct | formula_ptr_hash |
Hash Function for const formula* .This is meant to be used as a hash functor for Sgi's hash_map whose key are of type const formula* . More... | |
class | multop |
Multi-operand operators.These operators are considered commutative and associative. More... | |
class | nfa |
Nondeterministic Finite Automata used by automata operators. More... | |
class | succ_iterator |
class | ref_formula |
A reference-counted LTL formula. More... | |
class | unop |
Unary operators. More... | |
struct | visitor |
Formula visitor that can modify the formula.Writing visitors is the prefered way to traverse a formula, since it doesn't involve any cast. More... | |
struct | const_visitor |
Formula visitor that cannot modify the formula. More... | |
class | declarative_environment |
A declarative environment.This environment recognizes all atomic propositions that have been previously declared. It will reject other. More... | |
class | default_environment |
A laxist environment.This environment recognizes all atomic propositions. More... | |
class | environment |
An environment that describes atomic propositions. More... | |
class | ltl_file |
Read LTL formulae from a file, one by one. More... | |
class | clone_visitor |
Clone a formula.This visitor is public, because it's convenient to derive from it and override part of its methods. But if you just want the functionality, consider using spot::ltl::formula::clone instead, it is way faster. More... | |
class | language_containment_checker |
class | unabbreviate_logic_visitor |
Clone and rewrite a formula to remove most of the abbreviated logical operators.This will rewrite binary operators such as binop::Implies, binop::Equals, and binop::Xor, using only unop::Not, multop::Or, and multop::And. More... | |
class | postfix_visitor |
Apply an algorithm on each node of an AST, during a postfix traversal.Override one or more of the postifix_visitor::doit methods with the algorithm to apply. More... | |
class | random_ltl |
Generate random LTL formulae.This class recursively construct LTL formulae of a given size. The formulae will use the use atomic propositions from the set of proposition passed to the constructor, in addition to the constant and all LTL operators supported by Spot. More... | |
class | simplify_f_g_visitor |
Replace true U f and false R g by F f and G g . More... | |
class | unabbreviate_ltl_visitor |
Clone and rewrite a formula to remove most of the abbreviated LTL and logical operators.The rewriting performed on logical operator is the same as the one done by spot::ltl::unabbreviate_logic_visitor. More... | |
Typedefs | |
typedef std::pair < ltlyy::location, std::string > | parse_error |
A parse diagnostic with its location. | |
typedef std::list< parse_error > | parse_error_list |
A list of parser diagnostics, as filled by parse. | |
typedef std::set< atomic_prop *, formula_ptr_less_than > | atomic_prop_set |
Set of atomic propositions. | |
Enumerations | |
enum | reduce_options { Reduce_None = 0, Reduce_Basics = 1, Reduce_Syntactic_Implications = 2, Reduce_Eventuality_And_Universality = 4, Reduce_Containment_Checks = 8, Reduce_Containment_Checks_Stronger = 16, Reduce_All = -1U } |
Options for spot::ltl::reduce. More... | |
Functions | |
formula * | parse (const std::string <l_string, parse_error_list &error_list, environment &env=default_environment::instance(), bool debug=false) |
Build a formula from an LTL string. | |
bool | format_parse_errors (std::ostream &os, const std::string <l_string, parse_error_list &error_list) |
Format diagnostics produced by spot::ltl::parse. | |
atomic_prop_set * | atomic_prop_collect (const formula *f, atomic_prop_set *s=0) |
Return the set of atomic propositions occurring in a formula. | |
formula * | basic_reduce (const formula *f) |
Basic rewritings. | |
bool | is_GF (const formula *f) |
Whether a formula starts with GF. | |
bool | is_FG (const formula *f) |
Whether a formula starts with FG. | |
formula * | clone (const formula *f) |
Clone a formula. | |
formula * | reduce_tau03 (const formula *f, bool stronger=true) |
Reduce a formula using language containment relationships. | |
void | destroy (const formula *f) |
Destroys a formula. | |
std::ostream & | dotty (std::ostream &os, const formula *f) |
Write a formula tree using dot's syntax. | |
std::ostream & | dump (std::ostream &os, const formula *f) |
Dump a formula tree. | |
int | length (const formula *f) |
Compute the length of a formula.The length of a formula is the number of atomic properties, constants, and operators (logical and temporal) occurring in the formula. spot::ltl::multops count only for 1, even if they have more than two operands (e.g. a | b | c has length 4, because | is represented once internally). | |
formula * | unabbreviate_logic (const formula *f) |
Clone and rewrite a formula to remove most of the abbreviated logical operators.This will rewrite binary operators such as binop::Implies, binop::Equals, and binop::Xor, using only unop::Not, multop::Or, and multop::And. | |
formula * | negative_normal_form (const formula *f, bool negated=false) |
Build the negative normal form of f.All negations of the formula are pushed in front of the atomic propositions. | |
formula * | reduce (const formula *f, int opt=Reduce_All) |
Reduce a formula f. | |
bool | is_eventual (const formula *f) |
Check whether a formula is a pure eventuality.Pure eventuality formulae are defined in. | |
bool | is_universal (const formula *f) |
Check whether a formula is purely universal.Purely universal formulae are defined in. | |
formula * | simplify_f_g (const formula *f) |
Replace true U f and false R g by F f and G g . | |
bool | syntactic_implication (const formula *f1, const formula *f2) |
Syntactic implication.This comes from. | |
bool | syntactic_implication_neg (const formula *f1, const formula *f2, bool right) |
Syntactic implication.If right==false, true if !f1 < f2, false otherwise. If right==true, true if f1 < !f2, false otherwise. | |
std::ostream & | to_string (const formula *f, std::ostream &os, bool full_parent=false) |
Output a formula as a string which is parsable unless the formula contains automaton operators (used in ELTL formulae). | |
std::string | to_string (const formula *f, bool full_parent=false) |
Output a formula as a string which is parsable unless the formula contains automaton operators (used in ELTL formulae). | |
std::ostream & | to_spin_string (const formula *f, std::ostream &os, bool full_parent=false) |
Output a formula as a (parsable by Spin) string. | |
std::string | to_spin_string (const formula *f, bool full_parent=false) |
Convert a formula into a (parsable by Spin) string. | |
formula * | unabbreviate_ltl (const formula *f) |
Clone and rewrite a formula to remove most of the abbreviated LTL and logical operators. |
formula* spot::ltl::reduce_tau03 | ( | const formula * | f, | |
bool | stronger = true | |||
) |
Reduce a formula using language containment relationships.
The method is taken from table 4.1 in
///@TechReport{ tauriainen.03.a83, /// author = {Heikki Tauriainen}, /// title = {On Translating Linear Temporal Logic into Alternating and /// Nondeterministic Automata}, /// institution = {Helsinki University of Technology, Laboratory for /// Theoretical Computer Science}, /// address = {Espoo, Finland}, /// month = dec, /// number = {A83}, /// pages = {132}, /// type = {Research Report}, /// year = {2003}, /// note = {Reprint of Licentiate's thesis} ///} /// /// (The "dagged" cells in the tables are not handled here.) /// /// If \a stronger is set, additional rules are used to further /// reduce some U, R, and X usages. ///
formula* spot::ltl::unabbreviate_ltl | ( | const formula * | f | ) |