Commit e341cc9a authored by Alexandre Duret-Lutz's avatar Alexandre Duret-Lutz
Browse files

* iface/gspn/eesrg.cc, iface/gspn/eesrg.hh, iface/gspn/gspn.cc,

iface/gspn/gspn.hh, src/tgba/bdddict.cc, src/tgba/bdddict.hh,
src/tgba/bddprint.hh, src/tgba/succiter.hh,
src/tgba/succiterconcrete.cc, src/tgba/succiterconcrete.hh,
src/tgba/tgba.hh, src/tgba/tgbabddconcrete.cc,
src/tgba/tgbabddconcrete.hh, src/tgba/tgbabddconcretefactory.cc,
src/tgba/tgbabddconcretefactory.hh, src/tgba/tgbabddcoredata.cc,
src/tgba/tgbabddcoredata.hh, src/tgba/tgbaexplicit.cc,
src/tgba/tgbaexplicit.hh, src/tgba/tgbaproduct.cc,
src/tgba/tgbaproduct.hh, src/tgba/tgbatba.cc, src/tgba/tgbatba.hh,
src/tgbaalgos/dotty.cc, src/tgbaalgos/dupexp.cc,
src/tgbaalgos/emptinesscheck.cc, src/tgbaalgos/emptinesscheck.hh,
src/tgbaalgos/lbtt.cc, src/tgbaalgos/lbtt.hh,
src/tgbaalgos/ltl2tgba_fm.cc, src/tgbaalgos/ltl2tgba_lacim.cc,
src/tgbaalgos/save.cc, src/tgbatest/explicit.cc,
src/tgbatest/ltl2tgba.cc, src/tgbaparse/tgbaparse.yy,
wrap/python/tests/ltl2tgba.py:
Rewrite `accepting condition' as `acceptance condition'.
The symbols which have been renamed are:
tgba::all_accepting_conditions
tgba::neg_accepting_conditions
succ_iterator::current_accepting_conditions
bdd_dict::register_accepting_variable
bdd_dict::register_accepting_variables
bdd_dict::is_registered_accepting_variable
tgba_bdd_concrete_factory::declare_accepting_condition
tgba_bdd_core_data::accepting_conditions
tgba_bdd_core_data::all_accepting_conditions
tgba_explicit::declare_accepting_condition
tgba_explicit::complement_all_accepting_conditions
tgba_explicit::has_accepting_condition
tgba_explicit::get_accepting_condition
tgba_explicit::add_accepting_condition
tgba_explicit::all_accepting_conditions
tgba_explicit::neg_accepting_conditions
state_tba_proxy::acceptance_cond
accepting_cond_splitter
parent 334ae6e7
2003-11-28 Alexandre Duret-Lutz <adl@src.lip6.fr>
* iface/gspn/eesrg.cc, iface/gspn/eesrg.hh, iface/gspn/gspn.cc,
iface/gspn/gspn.hh, src/tgba/bdddict.cc, src/tgba/bdddict.hh,
src/tgba/bddprint.hh, src/tgba/succiter.hh,
src/tgba/succiterconcrete.cc, src/tgba/succiterconcrete.hh,
src/tgba/tgba.hh, src/tgba/tgbabddconcrete.cc,
src/tgba/tgbabddconcrete.hh, src/tgba/tgbabddconcretefactory.cc,
src/tgba/tgbabddconcretefactory.hh, src/tgba/tgbabddcoredata.cc,
src/tgba/tgbabddcoredata.hh, src/tgba/tgbaexplicit.cc,
src/tgba/tgbaexplicit.hh, src/tgba/tgbaproduct.cc,
src/tgba/tgbaproduct.hh, src/tgba/tgbatba.cc, src/tgba/tgbatba.hh,
src/tgbaalgos/dotty.cc, src/tgbaalgos/dupexp.cc,
src/tgbaalgos/emptinesscheck.cc, src/tgbaalgos/emptinesscheck.hh,
src/tgbaalgos/lbtt.cc, src/tgbaalgos/lbtt.hh,
src/tgbaalgos/ltl2tgba_fm.cc, src/tgbaalgos/ltl2tgba_lacim.cc,
src/tgbaalgos/save.cc, src/tgbatest/explicit.cc,
src/tgbatest/ltl2tgba.cc, src/tgbaparse/tgbaparse.yy,
wrap/python/tests/ltl2tgba.py:
Rewrite `accepting condition' as `acceptance condition'.
The symbols which have been renamed are:
tgba::all_accepting_conditions
tgba::neg_accepting_conditions
succ_iterator::current_accepting_conditions
bdd_dict::register_accepting_variable
bdd_dict::register_accepting_variables
bdd_dict::is_registered_accepting_variable
tgba_bdd_concrete_factory::declare_accepting_condition
tgba_bdd_core_data::accepting_conditions
tgba_bdd_core_data::all_accepting_conditions
tgba_explicit::declare_accepting_condition
tgba_explicit::complement_all_accepting_conditions
tgba_explicit::has_accepting_condition
tgba_explicit::get_accepting_condition
tgba_explicit::add_accepting_condition
tgba_explicit::all_accepting_conditions
tgba_explicit::neg_accepting_conditions
state_tba_proxy::acceptance_cond
accepting_cond_splitter
2003-11-26 Alexandre Duret-Lutz <adl@src.lip6.fr>
* src/tgbaalgos/ltl2tgba_fm.cc (ltl_trad_visitor::visit) <G>:
......
......@@ -319,11 +319,11 @@ namespace spot
}
virtual bdd
current_accepting_conditions() const
current_acceptance_conditions() const
{
// There is no acceptance conditions in GSPN systems, so we just
// return those from OPERAND_.
return operand_->current_accepting_conditions();
return operand_->current_acceptance_conditions();
}
private:
State state_;
......@@ -457,16 +457,16 @@ namespace spot
}
bdd
tgba_gspn_eesrg::all_accepting_conditions() const
tgba_gspn_eesrg::all_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddfalse;
}
bdd
tgba_gspn_eesrg::neg_accepting_conditions() const
tgba_gspn_eesrg::neg_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddtrue;
}
......
......@@ -60,8 +60,8 @@ namespace spot
const tgba* global_automaton = 0) const;
virtual bdd_dict* get_dict() const;
virtual std::string format_state(const state* state) const;
virtual bdd all_accepting_conditions() const;
virtual bdd neg_accepting_conditions() const;
virtual bdd all_acceptance_conditions() const;
virtual bdd neg_acceptance_conditions() const;
protected:
virtual bdd compute_support_conditions(const spot::state* state) const;
virtual bdd compute_support_variables(const spot::state* state) const;
......
......@@ -259,9 +259,9 @@ namespace spot
}
virtual bdd
current_accepting_conditions() const
current_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddfalse;
}
private:
......@@ -393,16 +393,16 @@ namespace spot
}
bdd
tgba_gspn::all_accepting_conditions() const
tgba_gspn::all_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddfalse;
}
bdd
tgba_gspn::neg_accepting_conditions() const
tgba_gspn::neg_acceptance_conditions() const
{
// There is no accepting conditions in GSPN systems.
// There is no acceptance conditions in GSPN systems.
return bddtrue;
}
......
......@@ -59,8 +59,8 @@ namespace spot
const tgba* global_automaton = 0) const;
virtual bdd_dict* get_dict() const;
virtual std::string format_state(const state* state) const;
virtual bdd all_accepting_conditions() const;
virtual bdd neg_accepting_conditions() const;
virtual bdd all_acceptance_conditions() const;
virtual bdd neg_acceptance_conditions() const;
protected:
virtual bdd compute_support_conditions(const spot::state* state) const;
virtual bdd compute_support_variables(const spot::state* state) const;
......
......@@ -102,11 +102,11 @@ namespace spot
}
int
bdd_dict::register_accepting_variable(const ltl::formula* f,
bdd_dict::register_acceptance_variable(const ltl::formula* f,
const void* for_me)
{
int num;
// Do not build an accepting variable that already exists.
// Do not build an acceptance variable that already exists.
fv_map::iterator sii = acc_map.find(f);
if (sii != acc_map.end())
{
......@@ -124,7 +124,7 @@ namespace spot
}
void
bdd_dict::register_accepting_variables(bdd f, const void* for_me)
bdd_dict::register_acceptance_variables(bdd f, const void* for_me)
{
if (f == bddtrue || f == bddfalse)
return;
......@@ -133,8 +133,8 @@ namespace spot
assert(i != acc_formula_map.end());
var_refs[i->first].insert(for_me);
register_accepting_variables(bdd_high(f), for_me);
register_accepting_variables(bdd_low(f), for_me);
register_acceptance_variables(bdd_high(f), for_me);
register_acceptance_variables(bdd_low(f), for_me);
}
......@@ -231,7 +231,7 @@ namespace spot
}
bool
bdd_dict::is_registered_accepting_variable(const ltl::formula* f,
bdd_dict::is_registered_acceptance_variable(const ltl::formula* f,
const void* by_me)
{
fv_map::iterator fi = acc_map.find(f);
......
......@@ -51,8 +51,8 @@ namespace spot
vf_map now_formula_map; ///< Maps "Now" BDD variables to formulae
fv_map var_map; ///< Maps atomic propositions to BDD variables
vf_map var_formula_map; ///< Maps BDD variables to atomic propositions
fv_map acc_map; ///< Maps accepting conditions to BDD variables
vf_map acc_formula_map; ///< Maps BDD variables to accepting conditions
fv_map acc_map; ///< Maps acceptance conditions to BDD variables
vf_map acc_formula_map; ///< Maps BDD variables to acceptance conditions
/// \brief Map Next variables to Now variables.
///
......@@ -100,23 +100,23 @@ namespace spot
/// \brief Register an atomic proposition.
///
/// Return (and maybe allocate) a BDD variable designating an
/// accepting set associated to formula \a f. The \a for_me
/// acceptance set associated to formula \a f. The \a for_me
/// argument should point to the object using this BDD variable,
/// this is used for reference counting. It is perfectly safe to
/// call this function several time with the same arguments.
///
/// \return The variable number. Use bdd_ithvar() or bdd_nithvar()
/// to convert this to a BDD.
int register_accepting_variable(const ltl::formula* f, const void* for_me);
int register_acceptance_variable(const ltl::formula* f, const void* for_me);
/// \brief Register BDD variables as accepting variables.
/// \brief Register BDD variables as acceptance variables.
///
/// Register all variables occurring in \a f as accepting variables
/// used by \a for_me. This assumes that these accepting variables
/// Register all variables occurring in \a f as acceptance variables
/// used by \a for_me. This assumes that these acceptance variables
/// are already known from the dictionary (i.e., they have already
/// been registered by register_accepting_variable() for another
/// been registered by register_acceptance_variable() for another
/// automaton).
void register_accepting_variables(bdd f, const void* for_me);
void register_acceptance_variables(bdd f, const void* for_me);
/// \brief Duplicate the variable usage of another object.
///
......@@ -135,7 +135,7 @@ namespace spot
/// Check whether formula \a f has already been registered by \a by_me.
bool is_registered_proposition(const ltl::formula* f, const void* by_me);
bool is_registered_state(const ltl::formula* f, const void* by_me);
bool is_registered_accepting_variable(const ltl::formula* f,
bool is_registered_acceptance_variable(const ltl::formula* f,
const void* by_me);
/// @}
......
......@@ -47,7 +47,7 @@ namespace spot
/// \return The BDD formated as a string.
std::string bdd_format_sat(const bdd_dict* dict, bdd b);
/// \brief Print a BDD as a list of accepting conditions.
/// \brief Print a BDD as a list of acceptance conditions.
///
/// This is used when saving a TGBA.
/// \param os The output stream.
......@@ -57,7 +57,7 @@ namespace spot
std::ostream& bdd_print_acc(std::ostream& os,
const bdd_dict* dict, bdd b);
/// \brief Print a BDD as a set of accepting conditions.
/// \brief Print a BDD as a set of acceptance conditions.
///
/// This is used when saving a TGBA.
/// \param os The output stream.
......
......@@ -32,7 +32,7 @@ namespace spot
/// This class provides the basic functionalities required to
/// iterate over the successors of a state, as well as querying
/// transition labels. Because transitions are never explicitely
/// encoded, labels (conditions and accepting conditions) can only
/// encoded, labels (conditions and acceptance conditions) can only
/// be queried while iterating over the successors.
class tgba_succ_iterator
{
......@@ -90,9 +90,9 @@ namespace spot
///
/// This is a boolean function of atomic propositions.
virtual bdd current_condition() const = 0;
/// \brief Get the accepting conditions on the transition leading
/// \brief Get the acceptance conditions on the transition leading
/// to this successor.
virtual bdd current_accepting_conditions() const = 0;
virtual bdd current_acceptance_conditions() const = 0;
//@}
};
......
......@@ -70,10 +70,10 @@ namespace spot
// (a + b) & Next[a] & Next[b]
// a & b & Next[a] & !Next[b]
// Is this always correct? No! It depends on the
// accepting conditions associated to each transition.
// acceptance conditions associated to each transition.
// We cannot merge transitions which have different
// accepting conditions.
// Let's label transitions with hypothetic accepting sets:
// acceptance conditions.
// Let's label transitions with hypothetic acceptance sets:
// a & b & Next[a] & Next[b] ; Acc[1]
// !a & b & Next[a] & Next[b] ; Acc[2]
// a & !b & Next[a] & Next[b] ; Acc[2]
......@@ -103,17 +103,17 @@ namespace spot
// Gather all transitions going to this destination...
current_ = succ_set_left_ & dest;
// ... and compute their accepting sets.
bdd as = data_.accepting_conditions & current_;
// ... and compute their acceptance sets.
bdd as = data_.acceptance_conditions & current_;
// AS is false when no satisfaction of the current transition
// belongs to an accepting set: current_ can be used as-is.
// belongs to an acceptance set: current_ can be used as-is.
if (as != bddfalse)
{
// Otherwise, we have accepting sets, and we should
// Otherwise, we have acceptance sets, and we should
// restrict current_ to a subset sharing the same
// accepting conditions.
// same accepting set.
// acceptance conditions.
// same acceptance set.
as = bdd_exist(as, data_.nownext_set);
// as = (a | (!a)&b) & (Acc[a] | Acc[b]) + (!a & Acc[b])
......@@ -125,7 +125,7 @@ namespace spot
// current_acc_ = (Acc[a] | Acc[b])
assert(current_acc_ != bddfalse);
// Find other transitions included exactly in each of these
// accepting sets and are not included in other sets.
// acceptance sets and are not included in other sets.
// Consider
// !p.!Acc[g].Acc[f] + p.!Acc[g].Acc[f] + p.Acc[g].!Acc[f]
// if current_acc_ = !Acc[g].Acc[f] we
......@@ -133,11 +133,11 @@ namespace spot
// belongs to !Acc[g].Acc[f] + Acc[g].!Acc[f], not
// only !Acc[g].Acc[f].
// So, first, filter out all transitions like p, which
// are also in other accepting sets.
// are also in other acceptance sets.
bdd fout = bdd_relprod(as, !current_acc_, data_.acc_set);
bdd as_fout = as - fout;
// Then, pick the remaining term that are exactly in all
// required accepting sets.
// required acceptance sets.
bdd all = bddtrue;
bdd acc = current_acc_;
do
......@@ -188,7 +188,7 @@ namespace spot
}
bdd
tgba_succ_iterator_concrete::current_accepting_conditions() const
tgba_succ_iterator_concrete::current_acceptance_conditions() const
{
assert(!done());
return current_acc_;
......
......@@ -35,13 +35,13 @@ namespace spot
/// \brief Build a spot::tgba_succ_iterator_concrete.
///
/// \param successors The set of successors with ingoing
/// conditions and accepting conditions, represented as a BDD.
/// conditions and acceptance conditions, represented as a BDD.
/// The job of this iterator will be to enumerate the
/// satisfactions of that BDD and split them into destination
/// states and conditions, and compute accepting conditions.
/// states and conditions, and compute acceptance conditions.
/// \param d The core data of the automata.
/// These contains sets of variables useful to split a BDD, and
/// compute accepting conditions.
/// compute acceptance conditions.
tgba_succ_iterator_concrete(const tgba_bdd_core_data& d, bdd successors);
virtual ~tgba_succ_iterator_concrete();
......@@ -53,7 +53,7 @@ namespace spot
// inspection
state_bdd* current_state() const;
bdd current_condition() const;
bdd current_accepting_conditions() const;
bdd current_acceptance_conditions() const;
private:
const tgba_bdd_core_data& data_; ///< Core data of the automaton.
......
......@@ -37,7 +37,7 @@ namespace spot
///
/// TGBAs are transition-based, meanings their labels are put
/// on arcs, not on nodes. They use Generalized Büchi acceptance
/// conditions: there are several accepting sets (of
/// conditions: there are several acceptance sets (of
/// transitions), and a path can be accepted only if it traverse
/// at least one transition of each set infinitely often.
///
......@@ -153,7 +153,7 @@ namespace spot
/// deleted by the caller.
virtual state* project_state(const state* s, const tgba* t) const;
/// \brief Return the set of all accepting conditions used
/// \brief Return the set of all acceptance conditions used
/// by this automaton.
///
/// The goal of the emptiness check is to ensure that
......@@ -161,19 +161,19 @@ namespace spot
/// 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.
virtual bdd all_accepting_conditions() const = 0;
virtual bdd all_acceptance_conditions() const = 0;
/// \brief Return the conjuction of all negated accepting
/// \brief Return the conjuction of all negated acceptance
/// variables.
///
/// For instance if the automaton uses variables <tt>Acc[a]</tt>,
/// <tt>Acc[b]</tt> and <tt>Acc[c]</tt> to describe accepting sets,
/// <tt>Acc[b]</tt> and <tt>Acc[c]</tt> to describe acceptance sets,
/// this function should return <tt>!Acc[a]\&!Acc[b]\&!Acc[c]</tt>.
///
/// This is useful when making products: each operand's condition
/// set should be augmented with the neg_accepting_conditions() of
/// set should be augmented with the neg_acceptance_conditions() of
/// the other operand.
virtual bdd neg_accepting_conditions() const = 0;
virtual bdd neg_acceptance_conditions() const = 0;
protected:
/// Do the actual computation of tgba::support_conditions().
......
......@@ -147,13 +147,13 @@ namespace spot
}
bdd
tgba_bdd_concrete::all_accepting_conditions() const
tgba_bdd_concrete::all_acceptance_conditions() const
{
return data_.all_accepting_conditions;
return data_.all_acceptance_conditions;
}
bdd
tgba_bdd_concrete::neg_accepting_conditions() const
tgba_bdd_concrete::neg_acceptance_conditions() const
{
return data_.negacc_set;
}
......
......@@ -76,8 +76,8 @@ namespace spot
/// rules, etc.
const tgba_bdd_core_data& get_core_data() const;
virtual bdd all_accepting_conditions() const;
virtual bdd neg_accepting_conditions() const;
virtual bdd all_acceptance_conditions() const;
virtual bdd neg_acceptance_conditions() const;
protected:
virtual bdd compute_support_conditions(const state* state) const;
......
......@@ -58,7 +58,7 @@ namespace spot
}
void
tgba_bdd_concrete_factory::declare_accepting_condition(bdd b,
tgba_bdd_concrete_factory::declare_acceptance_condition(bdd b,
const ltl::formula* a)
{
// Maintain a conjunction of BDDs associated to A. We will latter
......@@ -82,27 +82,27 @@ namespace spot
acc_map_::iterator ai;
for (ai = acc_.begin(); ai != acc_.end(); ++ai)
{
// Register a BDD variable for this accepting condition.
int num = get_dict()->register_accepting_variable(ai->first, this);
// Keep track of all accepting conditions for easy
// Register a BDD variable for this acceptance condition.
int num = get_dict()->register_acceptance_variable(ai->first, this);
// Keep track of all acceptance conditions for easy
// existential quantification.
data_.declare_accepting_condition(bdd_ithvar(num));
data_.declare_acceptance_condition(bdd_ithvar(num));
}
for (ai = acc_.begin(); ai != acc_.end(); ++ai)
{
bdd acc = bdd_ithvar(get_dict()->acc_map[ai->first]);
// Complete acc with all the other accepting conditions negated.
// Complete acc with all the other acceptance conditions negated.
acc &= bdd_exist(data_.negacc_set, acc);
// Any state matching the BDD formulae registered is part
// of this accepting set.
data_.accepting_conditions |= ai->second & acc;
// of this acceptance set.
data_.acceptance_conditions |= ai->second & acc;
// Keep track of all accepting conditions, so that we can
// easily check whether a transition satisfies all accepting
// Keep track of all acceptance conditions, so that we can
// easily check whether a transition satisfies all acceptance
// conditions.
data_.all_accepting_conditions |= acc;
data_.all_acceptance_conditions |= acc;
}
// Any constraint between Now variables also exist between Next
......
......@@ -56,18 +56,18 @@ namespace spot
/// can be turned into BDD using ithvar().
int create_atomic_prop(const ltl::formula* f);
/// Declare an accepting condition.
/// Declare an acceptance condition.
///
/// Formula such as 'f U g' or 'F g' make the promise
/// that 'g' will be fulfilled eventually. So once
/// one of this formula has been translated into a BDD,
/// we use declare_accepting_condition() to associate
/// all other states to the accepting set of 'g'.
/// we use declare_acceptance_condition() to associate
/// all other states to the acceptance set of 'g'.
///
/// \param b a BDD indicating which variables are in the
/// accepting set
/// acceptance set
/// \param a the formula associated
void declare_accepting_condition(bdd b, const ltl::formula* a);
void declare_acceptance_condition(bdd b, const ltl::formula* a);
const tgba_bdd_core_data& get_core_data() const;
bdd_dict* get_dict() const;
......@@ -78,7 +78,7 @@ namespace spot
/// \brief Perfom final computations before the relation can be used.
///
/// This function should be called after all propositions, state,
/// accepting conditions, and constraints have been declared, and
/// acceptance conditions, and constraints have been declared, and
/// before calling get_code_data() or get_dict().
void finish();
......@@ -87,7 +87,7 @@ namespace spot
typedef Sgi::hash_map<const ltl::formula*, bdd,
ptr_hash<ltl::formula> > acc_map_;
acc_map_ acc_; ///< BDD associated to each accepting condition
acc_map_ acc_; ///< BDD associated to each acceptance condition
};
}
......
......@@ -26,8 +26,8 @@ namespace spot
{
tgba_bdd_core_data::tgba_bdd_core_data(bdd_dict* dict)
: relation(bddtrue),
accepting_conditions(bddfalse),
all_accepting_conditions(bddfalse),
acceptance_conditions(bddfalse),
all_acceptance_conditions(bddfalse),
now_set(bddtrue),
next_set(bddtrue),
nownext_set(bddtrue),
......@@ -45,8 +45,8 @@ namespace spot
tgba_bdd_core_data::tgba_bdd_core_data(const tgba_bdd_core_data& copy)
: relation(copy.relation),
accepting_conditions(copy.accepting_conditions),
all_accepting_conditions(copy.all_accepting_conditions),
acceptance_conditions(copy.acceptance_conditions),
all_acceptance_conditions(copy.all_acceptance_conditions),
now_set(copy.now_set),
next_set(copy.next_set),
nownext_set(copy.nownext_set),
......@@ -66,10 +66,10 @@ namespace spot
tgba_bdd_core_data::tgba_bdd_core_data(const tgba_bdd_core_data& left,
const tgba_bdd_core_data& right)
: relation(left.relation & right.relation),
accepting_conditions(left.accepting_conditions
| right.accepting_conditions),
all_accepting_conditions(left.all_accepting_conditions
| right.all_accepting_conditions),
acceptance_conditions(left.acceptance_conditions
| right.acceptance_conditions),
all_acceptance_conditions(left.all_acceptance_conditions
| right.all_acceptance_conditions),
now_set(left.now_set & right.now_set),
next_set(left.next_set & right.next_set),
nownext_set(left.nownext_set & right.nownext_set),
......@@ -122,7 +122,7 @@ namespace spot
}
void
tgba_bdd_core_data::declare_accepting_condition(bdd acc)
tgba_bdd_core_data::declare_acceptance_condition(bdd acc)
{
notnow_set &= acc;
notnext_set &= acc;
......
......@@ -39,21 +39,21 @@ namespace spot
/// to the next state
bdd relation;
/// \brief encodes the accepting conditions
/// \brief encodes the acceptance conditions
///
/// <tt>a U b</tt>, or <tt>F b</tt>, both imply that \c b should
/// be verified eventually. We encode this with generalized Büchi
/// acceptating conditions. An accepting set, called
/// acceptating conditions. An acceptance set, called
/// <tt>Acc[b]</tt>, hold all the state that do not promise to
/// verify \c b eventually. (I.e., all the states that contain \c
/// b, or do not contain <tt>a U b</tt>, or <tt>F b</tt>.)
///
/// The spot::succ_iter::current_accepting_conditions() method
/// will return the \c Acc[x] variables of the accepting sets
/// The spot::succ_iter::current_acceptance_conditions() method
/// will return the \c Acc[x] variables of the acceptance sets
/// in which a transition is. Actually we never return \c Acc[x]
/// alone, but \c Acc[x] and all other accepting variables negated.
/// alone, but \c Acc[x] and all other acceptance variables negated.
///
/// So if there is three accepting set \c a, \c b, and \c c, and a
/// So if there is three acceptance set \c a, \c b, and \c c, and a
/// transition is in set \c a, we'll return <tt>
/// Acc[a]&!Acc[b]&!Acc[c]</tt>. If the transition is in both \c
/// a and \c b, we'll return <tt>(Acc[a]\&!Acc[b]\&!Acc[c]) \c | \c
......@@ -66,22 +66,22 @@ namespace spot
/// check for `b' and have a destination of the form <tt>a U b</tt>,
/// or <tt>F b</tt>.
///
/// To summarize, \c accepting_conditions contains three kinds of
/// To summarize, \c acceptance_conditions contains three kinds of
/// variables:
/// \li "Next" variables, that encode the destination state,
/// \li atomic propositions, which are things to verify before going on
/// to the next state,
/// \li "Acc" variables.
bdd accepting_conditions;
bdd acceptance_conditions;
/// \brief The set of all accepting conditions used by the Automaton.
/// \brief The set of all acceptance conditions used by the 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.
bdd all_accepting_conditions;
bdd all_acceptance_conditions;