spot 2.3.4

- Main Page
- Related Pages
- Modules
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
Classes | Public Member Functions | Static Public Member Functions | List of all members
spot::formula Class Referencefinal
Temporal Logic » Essential Temporal Logic Types

Main class for temporal logic formula. More...

`#include <spot/tl/formula.hh>`

Collaboration diagram for spot::formula:

## Classes
class | formula_child_iterator
| Allow iterating over children. More...

## Public Member Functions
| formula (const fnode *f) noexcept
| Create a formula from an fnode. More...
| formula (std::nullptr_t) noexcept
| Create a null formula. More...
| formula () noexcept
| Default initialize a formula to nullptr. More...
| formula (const formula &f) noexcept
| Clone a formula. More...
| formula (formula &&f) noexcept
| Move-construct a formula. More...
| ~formula ()
| Destroy a formula. More...
const formula & | operator= (std::nullptr_t)
| Reset a formula to null. More...
const formula & | operator= (const formula &f)
const formula & | operator= (formula &&f) noexcept
bool | operator< (const formula &other) const noexcept
bool | operator<= (const formula &other) const noexcept
bool | operator> (const formula &other) const noexcept
bool | operator>= (const formula &other) const noexcept
bool | operator== (const formula &other) const noexcept
bool | operator== (std::nullptr_t) const noexcept
bool | operator!= (const formula &other) const noexcept
bool | operator!= (std::nullptr_t) const noexcept
| operator bool () const
const fnode * | to_node_ ()
| Return the underlying pointer to the formula. More...
op | kind () const
| Return top-most operator. More...
std::string | kindstr () const
| Return the name of the top-most operator. More...
bool | is (op o) const
| Return true if the formula is of kind o. More...
bool | is (op o1, op o2) const
| Return true if the formula is of kind o1 or o2. More...
bool | is (std::initializer_list< op > l) const
| Return true if the formulas nests all the operators in l. More...
formula | get_child_of (op o) const
| Remove operator o and return the child. More...
formula | get_child_of (std::initializer_list< op > l) const
| Remove all operators in l and return the child. More...
unsigned | min () const
| Return start of the range for star-like operators. More...
unsigned | max () const
| Return end of the range for star-like operators. More...
unsigned | size () const
| Return the number of children. More...
size_t | id () const
| Return the id of a formula. More...
formula_child_iterator | begin () const
| Allow iterating over children. More...
formula_child_iterator | end () const
| Allow iterating over children. More...
formula | operator[] (unsigned i) const
| Return children number i. More...
bool | is_ff () const
| Whether the formula is the false constant. More...
bool | is_tt () const
| Whether the formula is the true constant. More...
bool | is_eword () const
| Whether the formula is the empty word constant. More...
bool | is_constant () const
| Whether the formula is op::ff, op::tt, or op::eword. More...
bool | is_Kleene_star () const
| Test whether the formula represent a Kleene star. More...
bool | is_literal ()
| Whether the formula is an atomic proposition or its negation. More...
const std::string & | ap_name () const
| Print the name of an atomic proposition. More...
std::ostream & | dump (std::ostream &os) const
| Print the formula for debugging. More...
formula | all_but (unsigned i) const
| clone this formula, omitting child i More...
unsigned | boolean_count () const
| number of Boolean children More...
formula | boolean_operands (unsigned *width=nullptr) const
| return a clone of the current node, restricted to its Boolean children More...
bool | is_boolean () const
| Whether the formula use only boolean operators. More...
bool | is_sugar_free_boolean () const
| Whether the formula use only AND, OR, and NOT operators. More...
bool | is_in_nenoform () const
| Whether the formula is in negative normal form. More...
bool | is_syntactic_stutter_invariant () const
| Whether the formula is syntactically stutter_invariant. More...
bool | is_sugar_free_ltl () const
| Whether the formula avoids the F and G operators. More...
bool | is_ltl_formula () const
| Whether the formula uses only LTL operators. More...
bool | is_psl_formula () const
| Whether the formula uses only PSL operators. More...
bool | is_sere_formula () const
| Whether the formula uses only SERE operators. More...
bool | is_finite () const
| Whether a SERE describes a finite language, or an LTL formula uses no temporal operator but X. More...
bool | is_eventual () const
| Whether the formula is purely eventual. More...
bool | is_universal () const
| Whether a formula is purely universal. More...
bool | is_syntactic_safety () const
| Whether a PSL/LTL formula is syntactic safety property. More...
bool | is_syntactic_guarantee () const
| Whether a PSL/LTL formula is syntactic guarantee property. More...
bool | is_syntactic_obligation () const
| Whether a PSL/LTL formula is syntactic obligation property. More...
bool | is_syntactic_recurrence () const
| Whether a PSL/LTL formula is syntactic recurrence property. More...
bool | is_syntactic_persistence () const
| Whether a PSL/LTL formula is syntactic persistence property. More...
bool | is_marked () const
| Whether the formula has an occurrence of EConcatMarked or NegClosureMarked. More...
bool | accepts_eword () const
| Whether the formula accepts [*0]. More...
bool | has_lbt_atomic_props () const
| Whether the formula has only LBT-compatible atomic propositions. More...
bool | has_spin_atomic_props () const
| Whether the formula has spin-compatible atomic propositions. More...
template<typename Trans >
formula | map (Trans trans)
| Clone this node after applying trans to its children. More...
template<typename Func >
void | traverse (Func func)
| Apply func to each subformula. More...

## Static Public Member Functions
static constexpr uint8_t | unbounded ()
| Unbounded constant to use as end of range for bounded operators. More...
static formula | ap (const std::string &name)
| Build an atomic proposition. More...
static formula | ap (const formula &a)
| Build an atomic proposition from... an atomic proposition. More...
static formula | sugar_goto (const formula &b, uint8_t min, uint8_t max)
| Create a SERE equivalent to b[->min..max]. More...
static formula | sugar_equal (const formula &b, uint8_t min, uint8_t max)
static formula | ff ()
| Return the false constant. More...
static formula | tt ()
| Return the true constant. More...
static formula | eword ()
| Return the empty word constant. More...
static formula | one_star ()
| Return a copy of the formula 1[*]. More...
static formula | unop (op o, const formula &f)
| Build a unary operator. More...
static formula | unop (op o, formula &&f)
| Build a unary operator. More...
static formula | Not (const formula &f)
| Construct a negation. More...
static formula | Not (formula &&f)
| Construct a negation. More...
static formula | X (const formula &f)
| Construct an X. More...
static formula | X (formula &&f)
| Construct an X. More...
static formula | F (const formula &f)
| Construct an F. More...
static formula | F (formula &&f)
| Construct an F. More...
static formula | G (const formula &f)
| Construct a G. More...
static formula | G (formula &&f)
| Construct a G. More...
static formula | Closure (const formula &f)
| Construct a PSL Closure. More...
static formula | Closure (formula &&f)
| Construct a PSL Closure. More...
static formula | NegClosure (const formula &f)
| Construct a negated PSL Closure. More...
static formula | NegClosure (formula &&f)
| Construct a negated PSL Closure. More...
static formula | NegClosureMarked (const formula &f)
| Construct a marked negated PSL Closure. More...
static formula | NegClosureMarked (formula &&f)
| Construct a marked negated PSL Closure. More...
static formula | binop (op o, const formula &f, const formula &g)
| Construct a binary operator. More...
static formula | binop (op o, const formula &f, formula &&g)
| Construct a binary operator. More...
static formula | binop (op o, formula &&f, const formula &g)
| Construct a binary operator. More...
static formula | binop (op o, formula &&f, formula &&g)
| Construct a binary operator. More...
static formula | Xor (const formula &f, const formula &g)
| Construct an `Xor` formula. More...
static formula | Xor (const formula &f, formula &&g)
| Construct an `Xor` formula. More...
static formula | Xor (formula &&f, const formula &g)
| Construct an `Xor` formula. More...
static formula | Xor (formula &&f, formula &&g)
| Construct an `Xor` formula. More...
static formula | Implies (const formula &f, const formula &g)
| Construct an `->` formula. More...
static formula | Implies (const formula &f, formula &&g)
| Construct an `->` formula. More...
static formula | Implies (formula &&f, const formula &g)
| Construct an `->` formula. More...
static formula | Implies (formula &&f, formula &&g)
| Construct an `->` formula. More...
static formula | Equiv (const formula &f, const formula &g)
| Construct an `<->` formula. More...
static formula | Equiv (const formula &f, formula &&g)
| Construct an `<->` formula. More...
static formula | Equiv (formula &&f, const formula &g)
| Construct an `<->` formula. More...
static formula | Equiv (formula &&f, formula &&g)
| Construct an `<->` formula. More...
static formula | U (const formula &f, const formula &g)
| Construct a `U` formula. More...
static formula | U (const formula &f, formula &&g)
| Construct a `U` formula. More...
static formula | U (formula &&f, const formula &g)
| Construct a `U` formula. More...
static formula | U (formula &&f, formula &&g)
| Construct a `U` formula. More...
static formula | R (const formula &f, const formula &g)
| Construct an `R` formula. More...
static formula | R (const formula &f, formula &&g)
| Construct an `R` formula. More...
static formula | R (formula &&f, const formula &g)
| Construct an `R` formula. More...
static formula | R (formula &&f, formula &&g)
| Construct an `R` formula. More...
static formula | W (const formula &f, const formula &g)
| Construct a `W` formula. More...
static formula | W (const formula &f, formula &&g)
| Construct a `W` formula. More...
static formula | W (formula &&f, const formula &g)
| Construct a `W` formula. More...
static formula | W (formula &&f, formula &&g)
| Construct a `W` formula. More...
static formula | M (const formula &f, const formula &g)
| Construct an `M` formula. More...
static formula | M (const formula &f, formula &&g)
| Construct an `M` formula. More...
static formula | M (formula &&f, const formula &g)
| Construct an `M` formula. More...
static formula | M (formula &&f, formula &&g)
| Construct an `M` formula. More...
static formula | EConcat (const formula &f, const formula &g)
| Construct a `<>->` PSL formula. More...
static formula | EConcat (const formula &f, formula &&g)
| Construct a `<>->` PSL formula. More...
static formula | EConcat (formula &&f, const formula &g)
| Construct a `<>->` PSL formula. More...
static formula | EConcat (formula &&f, formula &&g)
| Construct a `<>->` PSL formula. More...
static formula | EConcatMarked (const formula &f, const formula &g)
| Construct a marked `<>->` PSL formula. More...
static formula | EConcatMarked (const formula &f, formula &&g)
| Construct a marked `<>->` PSL formula. More...
static formula | EConcatMarked (formula &&f, const formula &g)
| Construct a marked `<>->` PSL formula. More...
static formula | EConcatMarked (formula &&f, formula &&g)
| Construct a marked `<>->` PSL formula. More...
static formula | UConcat (const formula &f, const formula &g)
| Construct a `[]->` PSL formula. More...
static formula | UConcat (const formula &f, formula &&g)
| Construct a `[]->` PSL formula. More...
static formula | UConcat (formula &&f, const formula &g)
| Construct a `[]->` PSL formula. More...
static formula | UConcat (formula &&f, formula &&g)
| Construct a `[]->` PSL formula. More...
static formula | multop (op o, const std::vector< formula > &l)
| Construct an n-ary operator. More...
static formula | multop (op o, std::vector< formula > &&l)
| Construct an n-ary operator. More...
static formula | Or (const std::vector< formula > &l)
| Construct an Or formula. More...
static formula | Or (std::vector< formula > &&l)
| Construct an Or formula. More...
static formula | OrRat (const std::vector< formula > &l)
| Construct an Or SERE. More...
static formula | OrRat (std::vector< formula > &&l)
| Construct an Or SERE. More...
static formula | And (const std::vector< formula > &l)
| Construct an And formula. More...
static formula | And (std::vector< formula > &&l)
| Construct an And formula. More...
static formula | AndRat (const std::vector< formula > &l)
| Construct an And SERE. More...
static formula | AndRat (std::vector< formula > &&l)
| Construct an And SERE. More...
static formula | AndNLM (const std::vector< formula > &l)
| Construct a non-length-matching And SERE. More...
static formula | AndNLM (std::vector< formula > &&l)
| Construct a non-length-matching And SERE. More...
static formula | Concat (const std::vector< formula > &l)
| Construct a Concatenation SERE. More...
static formula | Concat (std::vector< formula > &&l)
| Construct a Concatenation SERE. More...
static formula | Fusion (const std::vector< formula > &l)
| Construct a Fusion SERE. More...
static formula | Fusion (std::vector< formula > &&l)
| Construct a Fusion SERE. More...
static formula | bunop (op o, const formula &f, uint8_t min=0U, uint8_t max=unbounded())
| Define a bounded unary-operator (i.e. star-like) More...
static formula | bunop (op o, formula &&f, uint8_t min=0U, uint8_t max=unbounded())
| Define a bounded unary-operator (i.e. star-like) More...
static formula | Star (const formula &f, uint8_t min=0U, uint8_t max=unbounded())
| Create SERE for f[*min..max]. More...
static formula | Star (formula &&f, uint8_t min=0U, uint8_t max=unbounded())
| Create SERE for f[*min..max]. More...
static formula | FStar (const formula &f, uint8_t min=0U, uint8_t max=unbounded())
| Create SERE for f[:*min..max]. More...
static formula | FStar (formula &&f, uint8_t min=0U, uint8_t max=unbounded())
| Create SERE for f[:*min..max]. More...

## Detailed Description

Main class for temporal logic formula.

## Constructor & Destructor Documentation

spot::formula::formula | ( | const fnode * | f | ) |
| inline explicit noexcept

Create a formula from an fnode.

This constructor is mainly for internal use, as spot::fnode object should usually not be manipulated from user code.

spot::formula::formula | ( | std::nullptr_t |  | ) |
| inline noexcept

Create a null formula.

This could be used to default-initialize a formula, however null formula should be short lived: most algorithms and member functions assume that formulas should not be null.

spot::formula::formula | ( |  | ) |
| inline noexcept

Default initialize a formula to nullptr.

spot::formula::formula | ( | const formula & | f | ) |
| inline noexcept

Clone a formula.

spot::formula::formula | ( | formula && | f | ) |
| inline noexcept

Move-construct a formula.

spot::formula::~formula | ( |  | ) |
| inline

Destroy a formula.

## Member Function Documentation

bool spot::formula::accepts_eword | ( |  | ) | const
| inline

Whether the formula accepts [*0].

formula spot::formula::all_but | ( | unsigned | i | ) | const
| inline

clone this formula, omitting child i

Precondition
  The current node should be an n-ary operator such as op::And, op::AndRat, op::AndNLM, op::Or, op::OrRat, op::Concat, or op::Fusion.

static formula spot::formula::And | ( | std::vector< formula > && | l | ) |
| inline static

Construct an And formula.

static formula spot::formula::And | ( | const std::vector< formula > & | l | ) |
| inline static

Construct an And formula.

static formula spot::formula::AndNLM | ( | const std::vector< formula > & | l | ) |
| inline static

Construct a non-length-matching And SERE.

static formula spot::formula::AndNLM | ( | std::vector< formula > && | l | ) |
| inline static

Construct a non-length-matching And SERE.

static formula spot::formula::AndRat | ( | const std::vector< formula > & | l | ) |
| inline static

Construct an And SERE.

static formula spot::formula::AndRat | ( | std::vector< formula > && | l | ) |
| inline static

Construct an And SERE.

static formula spot::formula::ap | ( | const std::string & | name | ) |
| inline static

Build an atomic proposition.

References spot::fnode::ap().

Referenced by spot::twa::register_ap().

static formula spot::formula::ap | ( | const formula & | a | ) |
| inline static

Build an atomic proposition from... an atomic proposition.

The only practical interest of this methods is for the Python bindings, where ap() can therefore work both from string or atomic propositions.

References spot::ap, and kind().

const std::string& spot::formula::ap_name | ( |  | ) | const
| inline

Print the name of an atomic proposition.

Precondition
  the formula should be of kind op::ap.

formula_child_iterator spot::formula::begin | ( |  | ) | const
| inline

Allow iterating over children.

static formula spot::formula::binop | ( | op | o,
|  | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a binary operator.

Precondition
  o should be one of op::Xor, op::Implies, op::Equiv, op::U, op::R, op::W, op::M, op::EConcat, op::EConcatMarked, or op::UConcat.

References spot::fnode::binop(), and spot::fnode::clone().

static formula spot::formula::binop | ( | op | o,
|  | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct a binary operator.

Precondition
  o should be one of op::Xor, op::Implies, op::Equiv, op::U, op::R, op::W, op::M, op::EConcat, op::EConcatMarked, or op::UConcat.

References spot::fnode::binop(), and spot::fnode::clone().

static formula spot::formula::binop | ( | op | o,
|  | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a binary operator.

Precondition
  o should be one of op::Xor, op::Implies, op::Equiv, op::U, op::R, op::W, op::M, op::EConcat, op::EConcatMarked, or op::UConcat.

References spot::fnode::binop(), spot::fnode::clone(), and to_node_().

static formula spot::formula::binop | ( | op | o,
|  | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct a binary operator.

Precondition
  o should be one of op::Xor, op::Implies, op::Equiv, op::U, op::R, op::W, op::M, op::EConcat, op::EConcatMarked, or op::UConcat.

References spot::fnode::binop(), and to_node_().

unsigned spot::formula::boolean_count | ( |  | ) | const
| inline

number of Boolean children

Precondition
  The current node should be an n-ary operator such as op::And, op::AndRat, op::AndNLM, op::Or, or op::OrRat.

Note that the children of an n-ary operator are always sorted when the node is constructed, and such that Boolean children appear at the beginning. This function therefore return the number of the first non-Boolean child if it exists.

formula spot::formula::boolean_operands | ( | unsigned * | width = `nullptr` | ) | const
| inline

return a clone of the current node, restricted to its Boolean children

Precondition
  The current node should be an n-ary operator such as op::And, op::AndRat, op::AndNLM, op::Or, or op::OrRat.

On a formula such as And({a,b,c,d,F(e),G(f)}), this returns And({a,b,c,d}). If width is not nullptr, it is set the the number of Boolean children gathered. Note that the children of an n-ary operator are always sorted when the node is constructed, and such that Boolean children appear at the beginning. width would therefore give the number of the first non-Boolean child if it exists.

static formula spot::formula::bunop | ( | op | o,
|  | const formula & | f,
|  | uint8_t | min = `0U`,
|  | uint8_t | max = `unbounded()`
| ) |  |
| inline static

Define a bounded unary-operator (i.e. star-like)

Precondition
  o should be op::Star or op::FStar.

References spot::fnode::bunop(), and spot::fnode::clone().

static formula spot::formula::bunop | ( | op | o,
|  | formula && | f,
|  | uint8_t | min = `0U`,
|  | uint8_t | max = `unbounded()`
| ) |  |
| inline static

Define a bounded unary-operator (i.e. star-like)

Precondition
  o should be op::Star or op::FStar.

References spot::fnode::bunop(), and to_node_().

static formula spot::formula::Closure | ( | const formula & | f | ) |
| inline static

Construct a PSL Closure.

static formula spot::formula::Closure | ( | formula && | f | ) |
| inline static

Construct a PSL Closure.

static formula spot::formula::Concat | ( | std::vector< formula > && | l | ) |
| inline static

Construct a Concatenation SERE.

static formula spot::formula::Concat | ( | const std::vector< formula > & | l | ) |
| inline static

Construct a Concatenation SERE.

std::ostream& spot::formula::dump | ( | std::ostream & | os | ) | const
| inline

Print the formula for debugging.

In addition to the operator and children, this also display the formula's unique id, and its reference count.

static formula spot::formula::EConcat | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a `<>->` PSL formula.

static formula spot::formula::EConcat | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct a `<>->` PSL formula.

static formula spot::formula::EConcat | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a `<>->` PSL formula.

static formula spot::formula::EConcat | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct a `<>->` PSL formula.

static formula spot::formula::EConcatMarked | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a marked `<>->` PSL formula.

static formula spot::formula::EConcatMarked | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct a marked `<>->` PSL formula.

static formula spot::formula::EConcatMarked | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a marked `<>->` PSL formula.

static formula spot::formula::EConcatMarked | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct a marked `<>->` PSL formula.

formula_child_iterator spot::formula::end | ( |  | ) | const
| inline

Allow iterating over children.

static formula spot::formula::Equiv | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `<->` formula.

static formula spot::formula::Equiv | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `<->` formula.

static formula spot::formula::Equiv | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `<->` formula.

static formula spot::formula::Equiv | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `<->` formula.

static formula spot::formula::eword | ( |  | ) |
| inline static

Return the empty word constant.

References spot::fnode::eword().

static formula spot::formula::F | ( | const formula & | f | ) |
| inline static

Construct an F.

static formula spot::formula::F | ( | formula && | f | ) |
| inline static

Construct an F.

static formula spot::formula::ff | ( |  | ) |
| inline static

Return the false constant.

References spot::fnode::ff().

static formula spot::formula::FStar | ( | const formula & | f,
|  | uint8_t | min = `0U`,
|  | uint8_t | max = `unbounded()`
| ) |  |
| inline static

Create SERE for f[:*min..max].

This operator is a generalization of the (+) operator defined in the following paper.

    @InProceedings{          dax.09.atva,
    author        = {Christian Dax and Felix Klaedtke and Stefan Leue},
    title         = {Specification Languages for Stutter-Invariant Regular
    Properties},
    booktitle     = {Proceedings of the 7th International Symposium on
    Automated Technology for Verification and Analysis
    (ATVA'09)},
    pages         = {244--254},
    year                = {2009},
    volume        = {5799},
    series        = {Lecture Notes in Computer Science},
    publisher        = {Springer-Verlag}
    }

static formula spot::formula::FStar | ( | formula && | f,
|  | uint8_t | min = `0U`,
|  | uint8_t | max = `unbounded()`
| ) |  |
| inline static

Create SERE for f[:*min..max].

This operator is a generalization of the (+) operator defined in the following paper.

    @InProceedings{          dax.09.atva,
    author        = {Christian Dax and Felix Klaedtke and Stefan Leue},
    title         = {Specification Languages for Stutter-Invariant Regular
    Properties},
    booktitle     = {Proceedings of the 7th International Symposium on
    Automated Technology for Verification and Analysis
    (ATVA'09)},
    pages         = {244--254},
    year                = {2009},
    volume        = {5799},
    series        = {Lecture Notes in Computer Science},
    publisher        = {Springer-Verlag}
    }

static formula spot::formula::Fusion | ( | const std::vector< formula > & | l | ) |
| inline static

Construct a Fusion SERE.

static formula spot::formula::Fusion | ( | std::vector< formula > && | l | ) |
| inline static

Construct a Fusion SERE.

static formula spot::formula::G | ( | formula && | f | ) |
| inline static

Construct a G.

static formula spot::formula::G | ( | const formula & | f | ) |
| inline static

Construct a G.

formula spot::formula::get_child_of | ( | op | o | ) | const
| inline

Remove operator o and return the child.

This works only for unary operators.

References get_child_of().

Referenced by get_child_of().

formula spot::formula::get_child_of | ( | std::initializer_list< op > | l | ) | const
| inline

Remove all operators in l and return the child.

This works only for a list of unary operators. For instance if `f` is a formula for XG(a U b), then `f.get_child_of({op::X, op::G})` will return the subformula a U b.

bool spot::formula::has_lbt_atomic_props | ( |  | ) | const
| inline

Whether the formula has only LBT-compatible atomic propositions.

LBT only supports atomic propositions of the form p1, p12, etc.

bool spot::formula::has_spin_atomic_props | ( |  | ) | const
| inline

Whether the formula has spin-compatible atomic propositions.

In Spin 5 (and hence ltl2ba, ltl3ba, ltl3dra), atomic propositions should start with a lowercase letter, and can then consist solely of alphanumeric characters and underscores.

See also
  spot::is_spin_ap()

size_t spot::formula::id | ( |  | ) | const
| inline

Return the id of a formula.

Can be used as a hash number.

The id is almost unique as it is an unsigned number incremented at each formula construction, and the unsigned may wrap around zero. If this is used for ordering, make sure to deal with equality

static formula spot::formula::Implies | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `->` formula.

static formula spot::formula::Implies | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `->` formula.

static formula spot::formula::Implies | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `->` formula.

static formula spot::formula::Implies | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `->` formula.

bool spot::formula::is | ( | op | o | ) | const
| inline

Return true if the formula is of kind o.

bool spot::formula::is | ( | op | o1,
|  | op | o2
| ) |  | const
| inline

Return true if the formula is of kind o1 or o2.

bool spot::formula::is | ( | std::initializer_list< op > | l | ) | const
| inline

Return true if the formulas nests all the operators in l.

bool spot::formula::is_boolean | ( |  | ) | const
| inline

Whether the formula use only boolean operators.

bool spot::formula::is_constant | ( |  | ) | const
| inline

Whether the formula is op::ff, op::tt, or op::eword.

bool spot::formula::is_eventual | ( |  | ) | const
| inline

Whether the formula is purely eventual.

Pure eventuality formulae are defined in

    @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}
    }

A word that satisfies a pure eventuality can be prefixed by anything and still satisfies the formula.

bool spot::formula::is_eword | ( |  | ) | const
| inline

Whether the formula is the empty word constant.

bool spot::formula::is_ff | ( |  | ) | const
| inline

Whether the formula is the false constant.

bool spot::formula::is_finite | ( |  | ) | const
| inline

Whether a SERE describes a finite language, or an LTL formula uses no temporal operator but X.

bool spot::formula::is_in_nenoform | ( |  | ) | const
| inline

Whether the formula is in negative normal form.

A formula is in negative normal form if the not operators occur only in front of atomic propositions.

bool spot::formula::is_Kleene_star | ( |  | ) | const
| inline

Test whether the formula represent a Kleene star.

That is, it should be of kind op::Star, with min=0 and max=unbounded().

bool spot::formula::is_literal | ( |  | ) |
| inline

Whether the formula is an atomic proposition or its negation.

References spot::ap, and spot::Not.

bool spot::formula::is_ltl_formula | ( |  | ) | const
| inline

Whether the formula uses only LTL operators.

bool spot::formula::is_marked | ( |  | ) | const
| inline

Whether the formula has an occurrence of EConcatMarked or NegClosureMarked.

bool spot::formula::is_psl_formula | ( |  | ) | const
| inline

Whether the formula uses only PSL operators.

bool spot::formula::is_sere_formula | ( |  | ) | const
| inline

Whether the formula uses only SERE operators.

bool spot::formula::is_sugar_free_boolean | ( |  | ) | const
| inline

Whether the formula use only AND, OR, and NOT operators.

bool spot::formula::is_sugar_free_ltl | ( |  | ) | const
| inline

Whether the formula avoids the F and G operators.

bool spot::formula::is_syntactic_guarantee | ( |  | ) | const
| inline

Whether a PSL/LTL formula is syntactic guarantee property.

bool spot::formula::is_syntactic_obligation | ( |  | ) | const
| inline

Whether a PSL/LTL formula is syntactic obligation property.

bool spot::formula::is_syntactic_persistence | ( |  | ) | const
| inline

Whether a PSL/LTL formula is syntactic persistence property.

bool spot::formula::is_syntactic_recurrence | ( |  | ) | const
| inline

Whether a PSL/LTL formula is syntactic recurrence property.

bool spot::formula::is_syntactic_safety | ( |  | ) | const
| inline

Whether a PSL/LTL formula is syntactic safety property.

bool spot::formula::is_syntactic_stutter_invariant | ( |  | ) | const
| inline

Whether the formula is syntactically stutter_invariant.

bool spot::formula::is_tt | ( |  | ) | const
| inline

Whether the formula is the true constant.

bool spot::formula::is_universal | ( |  | ) | const
| inline

Whether a formula is purely universal.

Purely universal formulae are defined in

    @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}
    }

Any (non-empty) suffix of a word that satisfies a purely universal formula also satisfies the formula.

op spot::formula::kind | ( |  | ) | const
| inline

Return top-most operator.

Referenced by ap().

std::string spot::formula::kindstr | ( |  | ) | const
| inline

Return the name of the top-most operator.

static formula spot::formula::M | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `M` formula.

static formula spot::formula::M | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `M` formula.

static formula spot::formula::M | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `M` formula.

static formula spot::formula::M | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `M` formula.

template<typename Trans >

formula spot::formula::map | ( | Trans | trans | ) |
| inline

Clone this node after applying trans to its children.

References spot::And, spot::AndNLM, spot::AndRat, spot::ap, spot::Closure, spot::Concat, spot::EConcat, spot::EConcatMarked, spot::Equiv, spot::eword, spot::F, spot::ff, spot::FStar, spot::Fusion, spot::G, spot::Implies, spot::M, spot::NegClosure, spot::NegClosureMarked, spot::Not, spot::Or, spot::OrRat, spot::R, spot::Star, spot::tt, spot::U, spot::UConcat, spot::W, spot::X, and spot::Xor.

unsigned spot::formula::max | ( |  | ) | const
| inline

Return end of the range for star-like operators.

Precondition
  The formula should have kind op::Star or op::FStar.

unsigned spot::formula::min | ( |  | ) | const
| inline

Return start of the range for star-like operators.

Precondition
  The formula should have kind op::Star or op::FStar.

static formula spot::formula::multop | ( | op | o,
|  | const std::vector< formula > & | l
| ) |  |
| inline static

Construct an n-ary operator.

Precondition
  o should be one of op::Or, op::OrRat, op::And, op::AndRat, op::AndNLM, op::Concat, op::Fusion.

References spot::fnode::clone(), and spot::fnode::multop().

static formula spot::formula::multop | ( | op | o,
|  | std::vector< formula > && | l
| ) |  |
| inline static

Construct an n-ary operator.

Precondition
  o should be one of op::Or, op::OrRat, op::And, op::AndRat, op::AndNLM, op::Concat, op::Fusion.

References spot::fnode::multop(), and to_node_().

static formula spot::formula::NegClosure | ( | const formula & | f | ) |
| inline static

Construct a negated PSL Closure.

static formula spot::formula::NegClosure | ( | formula && | f | ) |
| inline static

Construct a negated PSL Closure.

static formula spot::formula::NegClosureMarked | ( | const formula & | f | ) |
| inline static

Construct a marked negated PSL Closure.

static formula spot::formula::NegClosureMarked | ( | formula && | f | ) |
| inline static

Construct a marked negated PSL Closure.

static formula spot::formula::Not | ( | formula && | f | ) |
| inline static

Construct a negation.

static formula spot::formula::Not | ( | const formula & | f | ) |
| inline static

Construct a negation.

static formula spot::formula::one_star | ( |  | ) |
| inline static

Return a copy of the formula 1[*].

References spot::fnode::one_star().

const formula& spot::formula::operator= | ( | std::nullptr_t |  | ) |
| inline

Reset a formula to null.

Note that null formula should be short lived: most algorithms and member function assume that formulas should not be null. Assigning nullptr to a formula can be useful when cleaning an array of formula using multiple passes and marking some formula as nullptr before actually erasing them.

formula spot::formula::operator[] | ( | unsigned | i | ) | const
| inline

Return children number i.

static formula spot::formula::Or | ( | const std::vector< formula > & | l | ) |
| inline static

Construct an Or formula.

static formula spot::formula::Or | ( | std::vector< formula > && | l | ) |
| inline static

Construct an Or formula.

static formula spot::formula::OrRat | ( | std::vector< formula > && | l | ) |
| inline static

Construct an Or SERE.

static formula spot::formula::OrRat | ( | const std::vector< formula > & | l | ) |
| inline static

Construct an Or SERE.

static formula spot::formula::R | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `R` formula.

static formula spot::formula::R | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `R` formula.

static formula spot::formula::R | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `R` formula.

static formula spot::formula::R | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `R` formula.

unsigned spot::formula::size | ( |  | ) | const
| inline

Return the number of children.

static formula spot::formula::Star | ( | const formula & | f,
|  | uint8_t | min = `0U`,
|  | uint8_t | max = `unbounded()`
| ) |  |
| inline static

Create SERE for f[*min..max].

static formula spot::formula::Star | ( | formula && | f,
|  | uint8_t | min = `0U`,
|  | uint8_t | max = `unbounded()`
| ) |  |
| inline static

Create SERE for f[*min..max].

static formula spot::formula::sugar_equal | ( | const formula & | b,
|  | uint8_t | min,
|  | uint8_t | max
| ) |  |
| static

Create the SERE b[=min..max]

The operator does not exist: it is handled as sugar by the parser and the printer. This functions is used by the parser to create the equivalent SERE.

static formula spot::formula::sugar_goto | ( | const formula & | b,
|  | uint8_t | min,
|  | uint8_t | max
| ) |  |
| static

Create a SERE equivalent to b[->min..max].

The operator does not exist: it is handled as sugar by the parser and the printer. This functions is used by the parser to create the equivalent SERE.

const fnode* spot::formula::to_node_ | ( |  | ) |
| inline

Return the underlying pointer to the formula.

It is not recommended to call this function, which is mostly meant for internal use.

By calling this function you take ownership of the fnode instance pointed by this formula instance, and should take care of calling its destroy() methods once you are done with it. Otherwise the fnode will be leaked.

Referenced by binop(), bunop(), multop(), and unop().

template<typename Func >

void spot::formula::traverse | ( | Func | func | ) |
| inline

Apply func to each subformula.

This does a simple DFS without checking for duplicate subformulas. If func returns true, the children of the current node are skipped.

References traverse().

Referenced by traverse().

static formula spot::formula::tt | ( |  | ) |
| inline static

Return the true constant.

References spot::fnode::tt().

static formula spot::formula::U | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a `U` formula.

static formula spot::formula::U | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct a `U` formula.

static formula spot::formula::U | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct a `U` formula.

static formula spot::formula::U | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a `U` formula.

static formula spot::formula::UConcat | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a `[]->` PSL formula.

static formula spot::formula::UConcat | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a `[]->` PSL formula.

static formula spot::formula::UConcat | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct a `[]->` PSL formula.

static formula spot::formula::UConcat | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct a `[]->` PSL formula.

static constexpr uint8_t spot::formula::unbounded | ( |  | ) |
| inline static

Unbounded constant to use as end of range for bounded operators.

References spot::fnode::unbounded().

static formula spot::formula::unop | ( | op | o,
|  | const formula & | f
| ) |  |
| inline static

Build a unary operator.

Precondition
  o should be one of op::Not, op::X, op::F, op::G, op::Closure, op::NegClosure, op::NegClosureMarked.

References spot::fnode::clone(), and spot::fnode::unop().

static formula spot::formula::unop | ( | op | o,
|  | formula && | f
| ) |  |
| inline static

Build a unary operator.

Precondition
  o should be one of op::Not, op::X, op::F, op::G, op::Closure, op::NegClosure, op::NegClosureMarked.

References to_node_(), and spot::fnode::unop().

static formula spot::formula::W | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a `W` formula.

static formula spot::formula::W | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct a `W` formula.

static formula spot::formula::W | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct a `W` formula.

static formula spot::formula::W | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct a `W` formula.

static formula spot::formula::X | ( | formula && | f | ) |
| inline static

Construct an X.

static formula spot::formula::X | ( | const formula & | f | ) |
| inline static

Construct an X.

static formula spot::formula::Xor | ( | formula && | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `Xor` formula.

static formula spot::formula::Xor | ( | const formula & | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `Xor` formula.

static formula spot::formula::Xor | ( | const formula & | f,
|  | formula && | g
| ) |  |
| inline static

Construct an `Xor` formula.

static formula spot::formula::Xor | ( | formula && | f,
|  | const formula & | g
| ) |  |
| inline static

Construct an `Xor` formula.

The documentation for this class was generated from the following file:

- spot/tl/formula.hh

Please direct any question, comment, or bug report to the Spot mailing list at spot@lrde.epita.fr.