Main Page | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members

spot::ltl Namespace Reference


Classes

class  spot::ltl::atomic_prop
 Atomic propositions. More...

class  spot::ltl::binop
 Binary operator. More...

class  spot::ltl::constant
 A constant (True or False). More...

class  spot::ltl::formula
 An LTL formula. More...

class  spot::ltl::multop
 Multi-operand operators. More...

struct  spot::ltl::multop::paircmp
 Comparison functor used internally by ltl::multop. More...

class  spot::ltl::ref_formula
 A reference-counted LTL formula. More...

class  spot::ltl::unop
 Unary operator. More...

struct  spot::ltl::visitor
 Formula visitor that can modify the formula. More...

struct  spot::ltl::const_visitor
 Formula visitor that cannot modify the formula. More...

class  spot::ltl::declarative_environment
 A declarative environment. More...

class  spot::ltl::default_environment
 A laxist environment. More...

class  spot::ltl::environment
 An environment that describes atomic propositions. More...

class  spot::ltl::clone_visitor
 Clone a formula. More...

class  spot::ltl::unabbreviate_logic_visitor
 Clone and rewrite a formula to remove most of the abbreviated logical operators. More...

class  spot::ltl::postfix_visitor
 Apply an algorithm on each node of an AST, during a postfix traversal. More...

class  spot::ltl::simplify_f_g_visitor
 Replace true U f and false R g by F f and G g. More...

class  spot::ltl::unabbreviate_ltl_visitor
 Clone and rewrite a formula to remove most of the abbreviated LTL and logical operators. More...


Typedefs

typedef std::pair< yy::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.


Enumerations

enum  reduce_options {
  Reduce_None = 0, Reduce_Basics = 1, Reduce_Syntactic_Implications = 2, Reduce_Eventuality_And_Universality = 4,
  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.

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.

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.

formulaunabbreviate_logic (const formula *f)
 Clone and rewrite a formula to remove most of the abbreviated logical operators.

formulanegative_normal_form (const formula *f, bool negated=false)
 Build the negative normal form of f.

formulareduce (const formula *f, int opt=Reduce_All)
 the reduced formula

bool is_eventual (const formula *f)
 Check whether a formula is eventual.

bool is_universal (const formula *f)
 Check whether a formula is universal.

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.

bool syntactic_implication_neg (const formula *f1, const formula *f2, bool right)
 Syntactic implication.

std::ostream & to_string (const formula *f, std::ostream &os)
 Output a formula as a (parsable) string.

std::string to_string (const formula *f)
 Convert a formula into a (parsable) string.

std::ostream & to_spin_string (const formula *f, std::ostream &os)
 Output a formula as a (parsable by Spin) string.

std::string to_spin_string (const formula *f)
 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.


Typedef Documentation

typedef std::pair<yy::Location, std::string> spot::ltl::parse_error
 

A parse diagnostic with its location.

typedef std::list<parse_error> spot::ltl::parse_error_list
 

A list of parser diagnostics, as filled by parse.


Enumeration Type Documentation

enum spot::ltl::reduce_options
 

Options for spot::ltl::reduce.

Enumeration values:
Reduce_None  No reduction.
Reduce_Basics  Basic reductions.
Reduce_Syntactic_Implications  Somenzi & Bloem syntactic implication.
Reduce_Eventuality_And_Universality  Etessami & Holzmann eventuality and universality reductions.
Reduce_All  All reductions.


Function Documentation

formula* basic_reduce const formula *  f  ) 
 

Basic rewritings.

formula* clone const formula *  f  ) 
 

Clone a formula.

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.

Parameters:
os The stream where it should be output.
f The formula to translate.
dot is part of the GraphViz package http://www.research.att.com/sw/tools/graphviz/

std::ostream& dump std::ostream &  os,
const formula *  f
 

Dump a formula tree.

Parameters:
os The stream where it should be output.
f The formula to dump.
This is useful to display a formula when debugging.

bool format_parse_errors std::ostream &  os,
const std::string &  ltl_string,
parse_error_list &  error_list
 

Format diagnostics produced by spot::ltl::parse.

Parameters:
os Where diagnostics should be output.
ltl_string The string that were parsed.
error_list The error list filled by spot::ltl::parse while parsing ltl_string.
Returns:
true iff any diagnostic was output.

bool is_eventual const formula *  f  ) 
 

Check whether a formula is eventual.

This comes from

@InProceedings{ etessami.00.concur, author = {Kousha Etessami and Gerard J. Holzmann}, title = {Optimizing {B\"u}chi Automata}, booktitle = {Proceedings of the 11th International Conference on Concurrency Theory (Concur'2000)}, pages = {153--167}, year = {2000}, editor = {C. Palamidessi}, volume = {1877}, series = {Lecture Notes in Computer Science}, publisher = {Springer-Verlag} }
FIXME: Describe what eventual formulae are.

bool is_FG const formula *  f  ) 
 

Whether a formula starts with FG.

bool is_GF const formula *  f  ) 
 

Whether a formula starts with GF.

bool is_universal const formula *  f  ) 
 

Check whether a formula is universal.

FIXME: Describe what universal formulae are. Cite paper.

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.

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.

Parameters:
f The formula to normalize.
negated If true, return the negative normal form of !f
Note that this will not remove abbreviated operators. If you want to remove abbreviations, call spot::ltl::unabbreviate_logic or spot::ltl::unabbreviate_ltl first. (Calling these functions after spot::ltl::negative_normal_form would likely produce a formula which is not in negative normal form.)

formula* parse 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.

Parameters:
ltl_string The string to parse.
error_list A list that will be filled with parse errors that occured during parsing.
env The environment into which parsing should take place.
debug When true, causes the parser to trace its execution.
Returns:
A pointer to the formula built from ltl_string, or 0 if the input was unparsable.
Note that the parser usually tries to recover from errors. It can return an non zero value even if it encountered error during the parsing of ltl_string. If you want to make sure ltl_string was parsed succesfully, check error_list for emptiness.

Warning:
This function is not reentrant.

formula* reduce const formula *  f,
int  opt = Reduce_All
 

the reduced formula

Parameters:
f the formula to reduce
opt a conjonction of spot::ltl::reduce_options specifying

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

@InProceedings{ somenzi.00.cav, author = {Fabio Somenzi and Roderick Bloem}, title = {Efficient {B\"u}chi Automata for {LTL} Formulae}, booktitle = {Proceedings of the 12th International Conference on Computer Aided Verification (CAV'00)}, pages = {247--263}, year = {2000}, volume = {1855}, series = {Lecture Notes in Computer Science}, publisher = {Springer-Verlag} }

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::string to_spin_string const formula *  f  ) 
 

Convert a formula into a (parsable by Spin) string.

Parameters:
f The formula to translate.

std::ostream& to_spin_string const formula *  f,
std::ostream &  os
 

Output a formula as a (parsable by Spin) string.

Parameters:
f The formula to translate.
os The stream where it should be output.

std::string to_string const formula *  f  ) 
 

Convert a formula into a (parsable) string.

Parameters:
f The formula to translate.

std::ostream& to_string const formula *  f,
std::ostream &  os
 

Output a formula as a (parsable) string.

Parameters:
f The formula to translate.
os The stream where it should be output.

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* 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.


Generated on Tue Jun 29 17:02:16 2004 for spot by doxygen 1.3.7