spot  0.8.1
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes
spot::tgba_tba_proxy Class Reference

Degeneralize a spot::tgba on the fly, producing a TBA.This class acts as a proxy in front of a spot::tgba, that should be degeneralized on the fly. The result is still a spot::tgba, but it will always have exactly one acceptance condition so it could be called TBA (without the G). More...

#include <tgba/tgbatba.hh>

Inheritance diagram for spot::tgba_tba_proxy:
Inheritance graph
[legend]
Collaboration diagram for spot::tgba_tba_proxy:
Collaboration graph
[legend]

List of all members.

Public Types

typedef std::list< bdd > cycle_list

Public Member Functions

 tgba_tba_proxy (const tgba *a)
virtual ~tgba_tba_proxy ()
virtual stateget_init_state () const
 Get the initial state of the automaton.
virtual tgba_succ_iteratorsucc_iter (const state *local_state, const state *global_state=0, const tgba *global_automaton=0) const
 Get an iterator over the successors of local_state.
virtual bdd_dictget_dict () const
 Get the dictionary associated to the automaton.
virtual std::string format_state (const state *state) const
 Format the state as a string for printing.
virtual stateproject_state (const state *s, const tgba *t) const
 Project a state on an automaton.
virtual bdd all_acceptance_conditions () const
 Return the set of all acceptance conditions used by this automaton.
virtual bdd neg_acceptance_conditions () const
 Return the conjuction of all negated acceptance variables.
bdd common_acceptance_conditions_of_original_state (const state *ostate) const
 Return the acceptance conditions common to all outgoing transitions of state ostate in the original automaton.
bdd union_acceptance_conditions_of_original_state (const state *s) const
 Return the union of acceptance conditions of all outgoing transitions of state ostate in the original automaton.
bdd support_conditions (const state *state) const
 Get a formula that must hold whatever successor is taken.
bdd support_variables (const state *state) const
 Get the conjunctions of variables tested by the outgoing transitions of state.
virtual std::string transition_annotation (const tgba_succ_iterator *t) const
 Return a possible annotation for the transition pointed to by the iterator.
virtual unsigned int number_of_acceptance_conditions () const
 The number of acceptance conditions.

Protected Member Functions

virtual bdd compute_support_conditions (const state *state) const
 Do the actual computation of tgba::support_conditions().
virtual bdd compute_support_variables (const state *state) const
 Do the actual computation of tgba::support_variables().

Protected Attributes

cycle_list acc_cycle_
const tgbaa_
const statelast_support_conditions_input_
const statelast_support_variables_input_

Private Types

typedef Sgi::hash_map< const
state *, bdd, state_ptr_hash,
state_ptr_equal
accmap_t

Private Member Functions

 tgba_tba_proxy (const tgba_tba_proxy &)
tgba_tba_proxyoperator= (const tgba_tba_proxy &)

Private Attributes

bdd the_acceptance_cond_
accmap_t accmap_
accmap_t accmapu_

Detailed Description

Degeneralize a spot::tgba on the fly, producing a TBA.

This class acts as a proxy in front of a spot::tgba, that should be degeneralized on the fly. The result is still a spot::tgba, but it will always have exactly one acceptance condition so it could be called TBA (without the G).

The degeneralization is done by synchronizing the input automaton with a "counter" automaton such as the one shown in "On-the-fly Verification of Linear Temporal Logic" (Jean-Michel Couveur, FME99).

If the input automaton uses N acceptance conditions, the output automaton can have at most max(N,1) times more states and transitions.

See also:
tgba_sba_proxy

Member Typedef Documentation

typedef std::list<bdd> spot::tgba_tba_proxy::cycle_list

Constructor & Destructor Documentation


Member Function Documentation

virtual bdd spot::tgba_tba_proxy::all_acceptance_conditions ( ) const [virtual]

Return the set of all acceptance conditions used by this automaton.

The goal of the emptiness check is to ensure that a strongly connected component walks through each of these acceptiong conditions. I.e., the union of the acceptiong conditions of all transition in the SCC should be equal to the result of this function.

Implements spot::tgba.

Return the acceptance conditions common to all outgoing transitions of state ostate in the original automaton.

This internal function is only meant to be used to implement the iterator returned by succ_iter.

The result of this function is computed the first time, and then cached.

virtual bdd spot::tgba_tba_proxy::compute_support_conditions ( const state state) const [protected, virtual]

Do the actual computation of tgba::support_conditions().

Implements spot::tgba.

virtual bdd spot::tgba_tba_proxy::compute_support_variables ( const state state) const [protected, virtual]

Do the actual computation of tgba::support_variables().

Implements spot::tgba.

virtual std::string spot::tgba_tba_proxy::format_state ( const state state) const [virtual]

Format the state as a string for printing.

This formating is the responsability of the automata that owns the state.

Implements spot::tgba.

virtual bdd_dict* spot::tgba_tba_proxy::get_dict ( ) const [virtual]

Get the dictionary associated to the automaton.

State are represented as BDDs. The dictionary allows to map BDD variables back to formulae, and vice versa. This is useful when dealing with several automata (which may use the same BDD variable for different formula), or simply when printing.

Implements spot::tgba.

virtual state* spot::tgba_tba_proxy::get_init_state ( ) const [virtual]

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::tgba.

Reimplemented in spot::tgba_sba_proxy.

virtual bdd spot::tgba_tba_proxy::neg_acceptance_conditions ( ) const [virtual]

Return the conjuction of all negated acceptance variables.

For instance if the automaton uses variables Acc[a], Acc[b] and Acc[c] to describe acceptance sets, this function should return !Acc[a]&!Acc[b]&!Acc[c].

This is useful when making products: each operand's condition set should be augmented with the neg_acceptance_conditions() of the other operand.

Implements spot::tgba.

virtual unsigned int spot::tgba::number_of_acceptance_conditions ( ) const [virtual, inherited]

The number of acceptance conditions.

tgba_tba_proxy& spot::tgba_tba_proxy::operator= ( const tgba_tba_proxy ) [private]
virtual state* spot::tgba_tba_proxy::project_state ( const state s,
const tgba t 
) const [virtual]

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 from spot::tgba.

virtual tgba_succ_iterator* spot::tgba_tba_proxy::succ_iter ( const state local_state,
const state global_state = 0,
const tgba global_automaton = 0 
) const [virtual]

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.

During synchornized products, additional informations are passed about the entire product and its state. Recall that products can be nested, forming a tree of spot::tgba where most values are computed on demand. global_automaton designate the root spot::tgba, and global_state its state. This two objects can be used by succ_iter() to restrict the set of successors to compute.

Parameters:
local_stateThe state whose successors are to be explored. This pointer is not adopted in any way by succ_iter, and it is still the caller's responsability to destroy it when appropriate (this can be done during the lifetime of the iterator).
global_stateIn a product, the state of the global product automaton. Otherwise, 0. Like locale_state, global_state is not adopted by succ_iter.
global_automatonIn a product, the global product automaton. Otherwise, 0.

Implements spot::tgba.

bdd spot::tgba::support_conditions ( const state state) const [inherited]

Get a formula that must hold whatever successor is taken.

Returns:
A formula which must be verified for all successors of state.

This can be as simple as bddtrue, or more completely the disjunction of the condition of all successors. This is used as an hint by succ_iter() to reduce the number of successor to compute in a product.

Sub classes should implement compute_support_conditions(), this function is just a wrapper that will cache the last return value for efficiency.

bdd spot::tgba::support_variables ( const state state) const [inherited]

Get the conjunctions of variables tested by the outgoing transitions of state.

All variables tested by outgoing transitions must be returned. This is mandatory.

This is used as an hint by some succ_iter() to reduce the number of successor to compute in a product.

Sub classes should implement compute_support_variables(), this function is just a wrapper that will cache the last return value for efficiency.

virtual std::string spot::tgba::transition_annotation ( const tgba_succ_iterator t) const [virtual, inherited]

Return a possible annotation for the transition pointed to by the iterator.

You may decide to use annotations when building a tgba class that represents the state space of a model, for instance to indicate how the tgba transitions relate to the original model (e.g. the annotation could be the name of a PetriNet transition, or the line number of some textual formalism).

Implementing this method is optional; the default annotation is the empty string.

This method is used for instance in dotty_reachable(), and replay_tgba_run().

Parameters:
ta non-done tgba_succ_iterator for this automaton

Reimplemented in spot::tgba_product, and spot::tgba_scc.

Return the union of acceptance conditions of all outgoing transitions of state ostate in the original automaton.

This internal function is only meant to be used to implement the iterator returned by succ_iter.

The result of this function is computed the first time, and then cached.


Member Data Documentation

const tgba* spot::tgba_tba_proxy::a_ [protected]
const state* spot::tgba::last_support_conditions_input_ [mutable, protected, inherited]
const state* spot::tgba::last_support_variables_input_ [mutable, protected, inherited]

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

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