spot 2.2.2

- 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
Public Types | Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | List of all members
spot::taa_tgba_labelled< label > Class Template Referenceabstract

`#include <spot/twa/taatgba.hh>`

Inheritance diagram for spot::taa_tgba_labelled< label >:
Collaboration diagram for spot::taa_tgba_labelled< label >:

## Public Types
typedef std::list< transition * > | state
typedef std::set< state * > | state_set

## Public Member Functions
| taa_tgba_labelled (const bdd_dict_ptr &dict)
void | set_init_state (const label &s)
void | set_init_state (const std::vector< label > &s)
transition * | create_transition (const label &s, const std::vector< label > &d)
transition * | create_transition (const label &s, const label &d)
void | add_acceptance_condition (transition *t, formula f)
virtual std::string | format_state (const spot::state *s) const override
| Format the state as a string for printing. More...
void | output (std::ostream &os) const
| Output a TAA in a stream. More...
void | add_condition (transition *t, formula f)
virtual spot::state * | get_init_state () const overridefinal
| Get the initial state of the automaton. More...
virtual twa_succ_iterator * | succ_iter (const spot::state *state) const overridefinal
| Get an iterator over the successors of local_state. More...
internal::twa_succ_iterable | succ (const state *s) const
| Build an iterable over the successors of s. More...
void | release_iter (twa_succ_iterator *i) const
| Release an iterator after usage. More...
bdd_dict_ptr | get_dict () const
| Get the dictionary associated to the automaton. More...
void | unregister_ap (int num)
| Unregister an atomic proposition. More...
void | register_aps_from_dict ()
| Register all atomic propositions that have already be register by the bdd_dict for this automaton. More...
const std::vector< formula > & | ap () const
| The vector of atomic propositions registered by this automaton. More...
bdd | ap_vars () const
| The set of atomic propositions as a conjunction. More...
virtual state * | project_state (const state *s, const const_twa_ptr &t) const
| Project a state on an automaton. More...
virtual bool | is_empty () const
| Check whether the language of the automaton is empty. More...
virtual twa_run_ptr | accepting_run () const
| Return an accepting run if one exists. More...
virtual twa_word_ptr | accepting_word () const
| Return an accepting word if one exists. More...
virtual bool | intersects (const_twa_ptr other) const
| Check whether the language of this automaton intersects that of the other automaton. More...
virtual twa_run_ptr | intersecting_run (const_twa_ptr other, bool from_other=false) const
| Return an accepting run recognizing a word accepted by two automata. More...
virtual twa_word_ptr | intersecting_word (const_twa_ptr other) const
| Return a word accepted by two automata. More...
unsigned | num_sets () const
| Number of acceptance sets used by the automaton. More...
const acc_cond::acc_code & | get_acceptance () const
| Acceptance formula used by the automaton. More...
void | set_acceptance (unsigned num, const acc_cond::acc_code &c)
| Set the acceptance condition of the automaton. More...
void | copy_acceptance_of (const const_twa_ptr &a)
| Copy the acceptance condition of another TωA. More...
void | copy_ap_of (const const_twa_ptr &a)
| Copy the atomic propositions of another TωA. More...
void | set_generalized_buchi (unsigned num)
| Set generalized Büchi acceptance. More...
acc_cond::mark_t | set_buchi ()
| Set Büchi acceptance. More...
void | set_named_prop (std::string s, void *val, std::function< void(void *)> destructor)
| Declare a named property. More...
template<typename T >
void | set_named_prop (std::string s, T *val)
| Declare a named property. More...
void | set_named_prop (std::string s, std::nullptr_t)
| Erase a named property. More...
template<typename T >
T * | get_named_prop (std::string s) const
| Retrieve a named property. More...
template<typename T >
T * | get_or_set_named_prop (std::string s)
| Create or retrieve a named property. More...
void | release_named_properties ()
| Destroy all named properties. More...
trival | prop_state_acc () const
| Whether the automaton uses state-based acceptance. More...
void | prop_state_acc (trival val)
| Set the state-based-acceptance property. More...
trival | is_sba () const
| Whether this is a state-based Büchi automaton. More...
trival | prop_inherently_weak () const
| Whether the automaton is inherently weak. More...
void | prop_inherently_weak (trival val)
| Set the "inherently weak" proeprty. More...
trival | prop_terminal () const
| Whether the automaton is terminal. More...
void | prop_terminal (trival val)
| Set the terminal property. More...
trival | prop_weak () const
| Whether the automaton is weak. More...
void | prop_weak (trival val)
| Set the weak property. More...
trival | prop_deterministic () const
| Whether the automaton is deterministic. More...
void | prop_deterministic (trival val)
| Set the deterministic property. More...
trival | prop_unambiguous () const
| Whether the automaton is unambiguous. More...
void | prop_unambiguous (trival val)
| Sets the unambiguous property. More...
trival | prop_stutter_invariant () const
| Whether the automaton is stutter-invariant. More...
void | prop_stutter_invariant (trival val)
| Set the stutter-invariant property. More...
void | prop_copy (const const_twa_ptr &other, prop_set p)
| Copy the properties of another automaton. More...
void | prop_keep (prop_set p)
| Keep only a subset of properties of the current automaton. More...
int | register_ap (formula ap)
| Register an atomic proposition designated by ap. More...
int | register_ap (std::string ap)
| Register an atomic proposition designated by ap. More...
const acc_cond & | acc () const
| The acceptance condition of the automaton. More...
acc_cond & | acc ()
| The acceptance condition of the automaton. More...

## Protected Types
typedef label | label_t
typedef std::unordered_map < label, taa_tgba::state * > | ns_map
typedef std::unordered_map < const taa_tgba::state *, label, ptr_hash < taa_tgba::state > > | sn_map
typedef std::vector < taa_tgba::state_set * > | ss_vec

## Protected Member Functions
virtual std::string | label_to_string (const label_t &lbl) const =0
| Return a label as a string. More...

## Protected Attributes
ns_map | name_state_map_
sn_map | state_name_map_
taa_tgba::state_set * | init_
ss_vec | state_set_vec_
std::map< formula, acc_cond::mark_t > | acc_map_
twa_succ_iterator * | iter_cache_
| Any iterator returned via release_iter. More...
bdd_dict_ptr | dict_
| BDD dictionary used by the automaton. More...

## Detailed Description

### template<typename label>
class spot::taa_tgba_labelled< label >

A taa_tgba instance with states labeled by a given type. Still an abstract class, see below.

## Member Function Documentation

const acc_cond& spot::twa::acc | ( |  | ) | const
| inline inherited

The acceptance condition of the automaton.

acc_cond& spot::twa::acc | ( |  | ) |
| inline inherited

The acceptance condition of the automaton.

virtual twa_run_ptr spot::twa::accepting_run | ( |  | ) | const
| virtual inherited

Return an accepting run if one exists.

Note that this method currently only works for Fin-less acceptance. For acceptance conditions that contain Fin acceptance, you can either rely on is_empty() and not use any accepting run, or remove Fin acceptance using remove_fin() and compute an accepting run on that larger automaton.

Return nullptr if no accepting run were found.

If you are calling this method on a product of two automata, consider using intersecting_run() instead.

virtual twa_word_ptr spot::twa::accepting_word | ( |  | ) | const
| virtual inherited

Return an accepting word if one exists.

Note that this method DOES works with Fin acceptance.

Return nullptr if no accepting word were found.

If you are calling this method on a product of two automata, consider using intersecting_word() instead.

const std::vector<formula>& spot::twa::ap | ( |  | ) | const
| inline inherited

The vector of atomic propositions registered by this automaton.

bdd spot::twa::ap_vars | ( |  | ) | const
| inline inherited

The set of atomic propositions as a conjunction.

void spot::twa::copy_acceptance_of | ( | const const_twa_ptr & | a | ) |
| inline inherited

Copy the acceptance condition of another TωA.

void spot::twa::copy_ap_of | ( | const const_twa_ptr & | a | ) |
| inline inherited

Copy the atomic propositions of another TωA.

template<typename label>

virtual std::string spot::taa_tgba_labelled< label >::format_state | ( | const spot::state * | s | ) | const
| inline override virtual

Format the state as a string for printing.

If state is a spot::set_state of only one element, then the string corresponding to state->get_state() is returned.

Otherwise a string composed of each string corresponding to each state->get_state() in the spot::set_state is returned, e.g. like {string_1,...,string_n}.

Implements spot::twa.

const acc_cond::acc_code& spot::twa::get_acceptance | ( |  | ) | const
| inline inherited

Acceptance formula used by the automaton.

bdd_dict_ptr spot::twa::get_dict | ( |  | ) | const
| inline inherited

Get the dictionary associated to the automaton.

Automata are labeled by Boolean formulas over atomic propositions. These Boolean formula are represented as BDDs. The dictionary allows to map BDD variables back to atomic propositions, and vice versa.

Usually automata that are involved in the same computations should share their dictionaries so that operations between BDDs of the two automata work naturally.

It is however possible to declare automata that use different sets of atomic propositions with different dictionaries. That way a BDD variable associated to some atomic proposition in one automaton might be reused for another atomic proposition in the other automaton.

virtual spot::state* spot::taa_tgba::get_init_state | ( |  | ) | const
| final override virtual inherited

Get the initial state of the automaton.

The state has been allocated with `new`. It is the responsability of the caller to `destroy` it when no longer needed.

Implements spot::twa.

template<typename T >

T* spot::twa::get_named_prop | ( | std::string | s | ) | const
| inline inherited

Retrieve a named property.

Because named property can be object of any type, retrieving the object requires knowing its type.

Parameters

  s | the name of the object to retrieve

Template Parameters

  T | the type of the object to retrieve

Note that the return is a pointer to `T`, so the type should not include the pointer.

Returns a nullptr if no such named property exists.

See https://spot.lrde.epita.fr/concepts.html#named-properties for a list of named properties used by Spot.

template<typename T >

T* spot::twa::get_or_set_named_prop | ( | std::string | s | ) |
| inline inherited

Create or retrieve a named property.

Arbitrary objects can be attached to automata. Those are called named properties. They are used for instance to name all the state of an automaton.

This function create a property object of a given type, and attached it to name if not such property exist, or it returns

See https://spot.lrde.epita.fr/concepts.html#named-properties for a list of named properties used by Spot.

virtual twa_run_ptr spot::twa::intersecting_run | ( | const_twa_ptr | other,
|  | bool | from_other = `false`
| ) |  | const
| virtual inherited

Return an accepting run recognizing a word accepted by two automata.

If from_other is true, the returned run will be over the other automaton. Otherwise, the run will be over this automaton.

Note that this method currently only works if the automaton from which the accepting run is extracted uses Fin-less acceptance. (The other automaton can have any acceptance condition.)

For acceptance conditions that contain Fin acceptance, you can either rely on intersects() and not use any accepting run, or remove Fin acceptance using remove_fin() and compute an intersecting run on this larger automaton.

Return nullptr if no accepting run were found.

virtual twa_word_ptr spot::twa::intersecting_word | ( | const_twa_ptr | other | ) | const
| virtual inherited

Return a word accepted by two automata.

Note that this method DOES works with Fin acceptance.

Return nullptr if no accepting word were found.

virtual bool spot::twa::intersects | ( | const_twa_ptr | other | ) | const
| virtual inherited

Check whether the language of this automaton intersects that of the other automaton.

virtual bool spot::twa::is_empty | ( |  | ) | const
| virtual inherited

Check whether the language of the automaton is empty.

If you are calling this method on a product of two automata, consider using intersects() instead.

trival spot::twa::is_sba | ( |  | ) | const
| inline inherited

Whether this is a state-based Büchi automaton.

An SBA has a Büchi acceptance, and should have its state-based acceptance property set.

template<typename label>

virtual std::string spot::taa_tgba_labelled< label >::label_to_string | ( | const label_t & | lbl | ) | const
| protected pure virtual

Return a label as a string.

Implemented in spot::taa_tgba_formula, and spot::taa_tgba_string.

unsigned spot::twa::num_sets | ( |  | ) | const
| inline inherited

Number of acceptance sets used by the automaton.

template<typename label>

void spot::taa_tgba_labelled< label >::output | ( | std::ostream & | os | ) | const
| inline

Output a TAA in a stream.

virtual state* spot::twa::project_state | ( | const state * | s,
|  | const const_twa_ptr & | t
| ) |  | const
| virtual inherited

Project a state on an automaton.

This converts s, into that corresponding spot::state for t. This is useful when you have the state of a product, and want restrict this state to a specific automata occuring in the product.

It goes without saying that s and t should be compatible (i.e., s is a state of t).

Returns
  0 if the projection fails (s is unrelated to t), or a new `state*` (the projected state) that must be destroyed by the caller.

Reimplemented in spot::twa_product.

void spot::twa::prop_copy | ( | const const_twa_ptr & | other,
|  | prop_set | p
| ) |  |
| inline inherited

Copy the properties of another automaton.

Copy the property speciefied with p from other to the current automaton.

There is no default value for p on purpose. This way any time we add a new property we have to update every call to prop_copy().

See also
  prop_set

References spot::twa::prop_set::deterministic, spot::twa::prop_set::inherently_weak, spot::twa::prop_set::state_based, and spot::twa::prop_set::stutter_inv.

trival spot::twa::prop_deterministic | ( |  | ) | const
| inline inherited

Whether the automaton is deterministic.

An automaton is deterministic if the conjunction between the labels of two transitions leaving a state is always false.

Note that this method may return trival::maybe() when it is unknown whether the automaton is deterministic or not. If you need a true/false answer, prefer the is_deterministic() function.

See also
  prop_unambiguous()
  is_deterministic()

void spot::twa::prop_deterministic | ( | trival | val | ) |
| inline inherited

Set the deterministic property.

Setting the "deterministic" property automatically sets the "unambiguous" property.

See also
  prop_unambiguous()

trival spot::twa::prop_inherently_weak | ( |  | ) | const
| inline inherited

Whether the automaton is inherently weak.

An automaton is inherently weak if accepting cycles and rejecting cycles are never mixed in the same strongly connected component.

See also
  prop_weak()
  prop_terminal()

void spot::twa::prop_inherently_weak | ( | trival | val | ) |
| inline inherited

Set the "inherently weak" proeprty.

Setting "inherently weak" to false automatically disables "terminal" and "weak".

See also
  prop_weak()
  prop_terminal()

void spot::twa::prop_keep | ( | prop_set | p | ) |
| inline inherited

Keep only a subset of properties of the current automaton.

All properties part of a group set to `false` in p are reset to their default value of trival::maybe().

References spot::twa::prop_set::deterministic, spot::twa::prop_set::inherently_weak, spot::twa::prop_set::state_based, and spot::twa::prop_set::stutter_inv.

trival spot::twa::prop_state_acc | ( |  | ) | const
| inline inherited

Whether the automaton uses state-based acceptance.

From the point of view of Spot, this means that all transitions leaving a state belong to the same acceptance sets. Then it is equivalent to pretend that the state is in the acceptance set.

void spot::twa::prop_state_acc | ( | trival | val | ) |
| inline inherited

Set the state-based-acceptance property.

If this property is set to true, then all transitions leaving a state must belong to the same acceptance sets.

trival spot::twa::prop_stutter_invariant | ( |  | ) | const
| inline inherited

Whether the automaton is stutter-invariant.

An automaton is stutter-invariant iff any accepted word remains accepted after removing a finite number of duplicate letters, or after duplicating finite number of letters.

Note that this method may return trival::maybe() when it is unknown whether the automaton is stutter-invariant or not. If you need a true/false answer, prefer one using of the the is_stutter_invariant() function.

See also
  is_stutter_invariant

void spot::twa::prop_stutter_invariant | ( | trival | val | ) |
| inline inherited

Set the stutter-invariant property.

trival spot::twa::prop_terminal | ( |  | ) | const
| inline inherited

Whether the automaton is terminal.

An automaton is terminal if it is weak, its accepting strongly components are complete, and no accepting edge lead to a non-accepting SCC.

This property ensures that a word can be accepted as soon as on of its prefixes move through an accepting edge.

See also
  prop_weak()
  prop_inherently_weak()

void spot::twa::prop_terminal | ( | trival | val | ) |
| inline inherited

Set the terminal property.

Marking an automaton as "terminal" automatically marks it as "weak" and "inherently weak".

See also
  prop_weak()
  prop_inherently_weak()

trival spot::twa::prop_unambiguous | ( |  | ) | const
| inline inherited

Whether the automaton is unambiguous.

An automaton is unambiguous if any accepted word is recognized by exactly one accepting path in the automaton. Any word (accepted or not) may be recognized by several rejecting paths in the automaton.

Note that this method may return trival::maybe() when it is unknown whether the automaton is unambiguous or not. If you need a true/false answer, prefer the is_unambiguous() function.

See also
  prop_deterministic()
  is_unambiguous()

void spot::twa::prop_unambiguous | ( | trival | val | ) |
| inline inherited

Sets the unambiguous property.

Marking an automaton as "non unambiguous" automatically marks it as "non deterministic".

See also
  prop_deterministic()

trival spot::twa::prop_weak | ( |  | ) | const
| inline inherited

Whether the automaton is weak.

An automaton is weak if inside each strongly connected component, all transitions belong to the same acceptance sets.

See also
  prop_terminal()
  prop_inherently_weak()

void spot::twa::prop_weak | ( | trival | val | ) |
| inline inherited

Set the weak property.

Marking an automaton as "weak" automatically marks it as "inherently weak". Marking an automaton as "not weak" automatically marks are as "not terminal".

See also
  prop_terminal()
  prop_inherently_weak()

int spot::twa::register_ap | ( | formula | ap | ) |
| inline inherited

Register an atomic proposition designated by ap.

This is the preferred way to declare that an automaton is using a given atomic proposition.

This adds the atomic proposition to the list of atomic proposition of the automaton, and also register it to the bdd_dict.

Returns
  The BDD variable number assigned for this atomic proposition.

int spot::twa::register_ap | ( | std::string | ap | ) |
| inline inherited

Register an atomic proposition designated by ap.

This is the preferred way to declare that an automaton is using a given atomic proposition.

This adds the atomic proposition to the list of atomic proposition of the automaton, and also register it to the bdd_dict.

Returns
  The BDD variable number assigned for this atomic proposition.

References spot::formula::ap().

void spot::twa::register_aps_from_dict | ( |  | ) |
| inline inherited

Register all atomic propositions that have already be register by the bdd_dict for this automaton.

This method may only be called on an automaton with an empty list of AP. It will fetch all atomic proposition that have been set in the bdd_dict for this particular automaton.

The typical use-case for this function is when the labels of an automaton are created by functions such as formula_to_bdd(). This is for instance done in the parser for never claims or LBTT.

void spot::twa::release_iter | ( | twa_succ_iterator * | i | ) | const
| inline inherited

Release an iterator after usage.

This iterator can then be reused by succ_iter() to avoid memory allocation.

void spot::twa::release_named_properties | ( |  | ) |
| inline inherited

Destroy all named properties.

This is used by the automaton destructor, but it could be used by any algorithm that want to get rid of all named properties.

void spot::twa::set_acceptance | ( | unsigned | num,
|  | const acc_cond::acc_code & | c
| ) |  |
| inline inherited

Set the acceptance condition of the automaton.

Parameters

  num | the number of acceptance sets used
  c | the acceptance formula

acc_cond::mark_t spot::twa::set_buchi | ( |  | ) |
| inline inherited

Set Büchi acceptance.

This declares a single acceptance set, and `Inf(0)` acceptance. The returned mark `{0}` can be used to tag accepting transition.

Note that this does not make the automaton as using state-based acceptance. If you want to create a Büchi automaton with state-based acceptance, call

prop_state_acc(true)

in addition.

See also
  prop_state_acc

void spot::twa::set_generalized_buchi | ( | unsigned | num | ) |
| inline inherited

Set generalized Büchi acceptance.

Parameters

  num | the number of acceptance sets to used

The acceptance formula of the form

Inf(0)&Inf(1)&...&Inf(num-1)

is generated.

In the case where num is null, the state-acceptance property is automatically turned on.

void spot::twa::set_named_prop | ( | std::string | s,
|  | void * | val,
|  | std::function< void(void *)> | destructor
| ) |  |
| inherited

Declare a named property.

Arbitrary objects can be attached to automata. Those are called named properties. They are used for instance to name all the state of an automaton.

This function attaches the object val to the current automaton, under the name s and destroy any previous property with the same name.

When the automaton is destroyed, the destructor function will be called to destroy the attached object.

See https://spot.lrde.epita.fr/concepts.html#named-properties for a list of named properties used by Spot.

template<typename T >

void spot::twa::set_named_prop | ( | std::string | s,
|  | T * | val
| ) |  |
| inline inherited

Declare a named property.

Arbitrary objects can be attached to automata. Those are called named properties. They are used for instance to name all the state of an automaton.

This function attaches the object val to the current automaton, under the name s and destroy any previous property with the same name.

When the automaton is destroyed, the attached object will be destroyed with `delete`.

See https://spot.lrde.epita.fr/concepts.html#named-properties for a list of named properties used by Spot.

void spot::twa::set_named_prop | ( | std::string | s,
|  | std::nullptr_t |
| ) |  |
| inherited

Erase a named property.

Arbitrary objects can be attached to automata. Those are called named properties. They are used for instance to name all the state of an automaton.

This function removes the property s if it exists.

See https://spot.lrde.epita.fr/concepts.html#named-properties for a list of named properties used by Spot.

internal::twa_succ_iterable spot::twa::succ | ( | const state * | s | ) | const
| inline inherited

Build an iterable over the successors of s.

This is meant to be used as

for (auto i: aut->succ(s))
{
// use i->cond(), i->acc(), i->dst()
}

and the above loop is in fact syntactic sugar for

twa_succ_iterator* i = aut->succ_iter(s);
if (i->first())
do
{
// use i->cond(), i->acc(), i->dst()
}
while (i->next());
aut->release_iter(i);

virtual twa_succ_iterator* spot::taa_tgba::succ_iter | ( | const spot::state * | local_state | ) | const
| final override virtual inherited

Get an iterator over the successors of local_state.

The iterator has been allocated with `new`. It is the responsability of the caller to `delete` it when no longer needed.

See also
  succ()

Implements spot::twa.

void spot::twa::unregister_ap | ( | int | num | ) |
| inherited

Unregister an atomic proposition.

Parameters

  num | the BDD variable number returned by register_ap().

## Member Data Documentation

bdd_dict_ptr spot::twa::dict_
| protected inherited

BDD dictionary used by the automaton.

twa_succ_iterator* spot::twa::iter_cache_
| mutable protected inherited

Any iterator returned via release_iter.

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

- spot/twa/taatgba.hh

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