spot  0.8.1
Namespaces | Classes | Typedefs | Enumerations | Functions
spot::ltl Namespace Reference

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_errorparse_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

formulaparse (const std::string &ltl_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 &ltl_string, parse_error_list &error_list)
 Format diagnostics produced by spot::ltl::parse.
atomic_prop_setatomic_prop_collect (const formula *f, atomic_prop_set *s=0)
 Return the set of atomic propositions occurring in a formula.
formulabasic_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.
formulaclone (const formula *f)
 Clone a formula.
formulareduce_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).
formulaunabbreviate_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.
formulanegative_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.
formulareduce (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.
formulasimplify_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.
formulaunabbreviate_ltl (const formula *f)
 Clone and rewrite a formula to remove most of the abbreviated LTL and logical operators.

Function Documentation

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)

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.

This will also rewrite unary operators such as unop::F, and unop::G, using only binop::U, and binop::R.


Please comment this page and report errors about it on the RefDocComments page.
Generated on Sun Dec 18 2011 12:57:16 for spot by doxygen 1.7.6.1