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

Switch from "promises" to "accepting set". Fix the definitions

of these accepting set so that they are really usable.  Provide
a all_accepting_conditions() method for use in the emptyness
check, and a neg_accepting_conditions() for products.
Predeclare TGBA accepting conditions is the i/o.

* src/tgba/bddprint.cc (want_prom): Rename as ...
(want_prom): ... this.
(print_handler): Adjust to display Acc[].
(print_acc_handler, bdd_print_acc): New functions.
* src/tgba/bddprint.hh (print_acc_handler, bdd_print_acc):
New functions.
* src/tgba/succiter.hh (current_promise): Rename as ...
(current_accepting_conditions): ... this.
* src/tgba/succiterconcrete.cc (current_state):
Rename next to now.
(current_promise): Rename as ...
(current_accepting_conditions): ... this, and compute
the accepting conditions.
* src/tgba/dictunion.cc, src/tgba/ltl2tgba.cc,
src/tgba/succiterconcrete.hh,
src/tgba/tgbabddconcretefactory.cc,
src/tgba/tgbabddcoredata.cc, src/tgba/tgbabddcoredata.hh,
src/tgba/tgbabdddict.hh, src/tgba/tgbabdddict.cc,
src/tgba/tgbabddtranslatefactory.cc,
src/tgbaalgos/dotty.cc: Adjust to new names.
* src/tgba/tgba.hh (all_accepting_conditions,
neg_accepting_conditions): New functions.
* src/tgba/tgbabddconcretefactory.cc: Adjust to new
names, and record accepting conditions instead of promises.
* src/tgba/tgbabddcoredata.hh (accepting_conditions,
all_accepting_conditions, negacc_set): New variables.
(notnow_set, notprom_set, declare_promise): Rename as ...
(notnext_set, notacc_set, declare_accepting_condition): ... these.
* src/tgba/tgbaexplicit.hh
(tgba_explicit_succ_iterator::current_promise): Rename as ...
(tgba_explicit_succ_iterator::current_accepting_conditions): ... this.
(tgba_explicit::add_promise): Rename as ...
(tgba_explicit::add_accepting_condition): ... this.
(tgba_explicit::declare_accepting_condition,
tgba_explicit::has_accepting_condition): New variables.
(tgba_explicit::get_promise): Rename as ...
(tgba_explicit::get_accepting_condition): ... this.
(tgba_explicit::all_accepting_conditions,
tgba_explicit::neg_accepting_conditions): Implement them.
(all_accepting_conditions, neg_accepting_conditions,
all_accepting_conditions): New variables.
(tgba_explicit_succ_iterator): Embed all_accepting_conditions_.
* src/tgba/tgbaexplicit.cc: Likewise.
* src/tgba/tgbaproduct.hh
(tgba_product_succ_uterator): Embed left_neg_ and right_neg_.
(tgba_product::all_accepting_conditions,
tgba_product::neg_accepting_conditions): Implement them.
* src/tgba/tgbatranslateproxy.hh:
(tgba_translate_proxy::all_accepting_conditions,
tgba_translate_proxy::neg_accepting_conditions): Implement them.
* src/tgba/tgbatranslateproxy.cc: Likewise.
* src/tgbaalgos/save.cc (save_rec): Call bdd_print
(tgba_save_reachable): Output the `acc =' line.
* src/tgbaparse/tgbaparse.yy: Support the for
accepting conditions definitions using an "acc =" line
at the start.  Later, use has_accepting_condition while
parsing	accepting conditions to ensure they were declared.
Disallow !cond in accepting conditions.
* src/tgbaparse/tgbascan.ll (ACC_DEF): New token.
* src/tgbatest/explicit.cc (main): Declare accepting conditions.
* src/tgbatest/ltl2tgba.cc (main): Add support for the -a, -A,
and -R new options.
* src/tgbatest/tgbaread.cc (main): Really exit on parse error.
* src/tgbatest/explicit.test, src/tgbatest/explprod.test,
src/tgbatest/mixprod.test, src/tgbatest/readsave.test,
src/tgbatest/tgbaread.test, src/tgbatest/tripprod.test: Reflect
recent changes.
parent fbbfda43
2003-06-23 Alexandre Duret-Lutz <aduret@src.lip6.fr>
Switch from "promises" to "accepting set". Fix the definitions
of these accepting set so that they are really usable. Provide
a all_accepting_conditions() method for use in the emptyness
check, and a neg_accepting_conditions() for products.
Predeclare TGBA accepting conditions is the i/o.
* src/tgba/bddprint.cc (want_prom): Rename as ...
(want_prom): ... this.
(print_handler): Adjust to display Acc[].
(print_acc_handler, bdd_print_acc): New functions.
* src/tgba/bddprint.hh (print_acc_handler, bdd_print_acc):
New functions.
* src/tgba/succiter.hh (current_promise): Rename as ...
(current_accepting_conditions): ... this.
* src/tgba/succiterconcrete.cc (current_state):
Rename next to now.
(current_promise): Rename as ...
(current_accepting_conditions): ... this, and compute
the accepting conditions.
* src/tgba/dictunion.cc, src/tgba/ltl2tgba.cc,
src/tgba/succiterconcrete.hh,
src/tgba/tgbabddconcretefactory.cc,
src/tgba/tgbabddcoredata.cc, src/tgba/tgbabddcoredata.hh,
src/tgba/tgbabdddict.hh, src/tgba/tgbabdddict.cc,
src/tgba/tgbabddtranslatefactory.cc,
src/tgbaalgos/dotty.cc: Adjust to new names.
* src/tgba/tgba.hh (all_accepting_conditions,
neg_accepting_conditions): New functions.
* src/tgba/tgbabddconcretefactory.cc: Adjust to new
names, and record accepting conditions instead of promises.
* src/tgba/tgbabddcoredata.hh (accepting_conditions,
all_accepting_conditions, negacc_set): New variables.
(notnow_set, notprom_set, declare_promise): Rename as ...
(notnext_set, notacc_set, declare_accepting_condition): ... these.
* src/tgba/tgbaexplicit.hh
(tgba_explicit_succ_iterator::current_promise): Rename as ...
(tgba_explicit_succ_iterator::current_accepting_conditions): ... this.
(tgba_explicit::add_promise): Rename as ...
(tgba_explicit::add_accepting_condition): ... this.
(tgba_explicit::declare_accepting_condition,
tgba_explicit::has_accepting_condition): New variables.
(tgba_explicit::get_promise): Rename as ...
(tgba_explicit::get_accepting_condition): ... this.
(tgba_explicit::all_accepting_conditions,
tgba_explicit::neg_accepting_conditions): Implement them.
(all_accepting_conditions, neg_accepting_conditions,
all_accepting_conditions): New variables.
(tgba_explicit_succ_iterator): Embed all_accepting_conditions_.
* src/tgba/tgbaexplicit.cc: Likewise.
* src/tgba/tgbaproduct.hh
(tgba_product_succ_uterator): Embed left_neg_ and right_neg_.
(tgba_product::all_accepting_conditions,
tgba_product::neg_accepting_conditions): Implement them.
* src/tgba/tgbatranslateproxy.hh:
(tgba_translate_proxy::all_accepting_conditions,
tgba_translate_proxy::neg_accepting_conditions): Implement them.
* src/tgba/tgbatranslateproxy.cc: Likewise.
* src/tgbaalgos/save.cc (save_rec): Call bdd_print
(tgba_save_reachable): Output the `acc =' line.
* src/tgbaparse/tgbaparse.yy: Support the for
accepting conditions definitions using an "acc =" line
at the start. Later, use has_accepting_condition while
parsing accepting conditions to ensure they were declared.
Disallow !cond in accepting conditions.
* src/tgbaparse/tgbascan.ll (ACC_DEF): New token.
* src/tgbatest/explicit.cc (main): Declare accepting conditions.
* src/tgbatest/ltl2tgba.cc (main): Add support for the -a, -A,
and -R new options.
* src/tgbatest/tgbaread.cc (main): Really exit on parse error.
* src/tgbatest/explicit.test, src/tgbatest/explprod.test,
src/tgbatest/mixprod.test, src/tgbatest/readsave.test,
src/tgbatest/tgbaread.test, src/tgbatest/tripprod.test: Reflect
recent changes.
2003-06-22 Alexandre Duret-Lutz <aduret@src.lip6.fr>
* src/tgbatest/tripprod.test, src/tgbatest/explprod.test:
......
......@@ -8,8 +8,8 @@ namespace spot
/// Global dictionary used by print_handler() to lookup variables.
static const tgba_bdd_dict* dict;
/// Global flag to enable Prom[x] output (instead of `x').
static bool want_prom;
/// Global flag to enable Acc[x] output (instead of `x').
static bool want_acc;
/// Stream handler used by Buddy to display BDD variables.
static void
......@@ -21,12 +21,12 @@ namespace spot
to_string(isi->second, o);
else
{
isi = dict->prom_formula_map.find(var);
if (isi != dict->prom_formula_map.end())
isi = dict->acc_formula_map.find(var);
if (isi != dict->acc_formula_map.end())
{
if (want_prom)
if (want_acc)
{
o << "Prom[";
o << "Acc[";
to_string(isi->second, o) << "]";
}
else
......@@ -83,9 +83,34 @@ namespace spot
{
dict = &d;
where = &os;
want_prom = false;
assert (bdd_satone(b) == b);
bdd_allsat (b, print_sat_handler);
want_acc = false;
assert(bdd_satone(b) == b);
bdd_allsat(b, print_sat_handler);
return os;
}
static void
print_acc_handler(char* varset, int size)
{
for (int v = 0; v < size; ++v)
{
if (varset[v] < 0)
continue;
if (varset[v] > 0)
{
*where << " ";
print_handler(*where, v);
}
}
}
std::ostream&
bdd_print_acc(std::ostream& os, const tgba_bdd_dict& d, bdd b)
{
dict = &d;
where = &os;
want_acc = false;
bdd_allsat(b, print_acc_handler);
return os;
}
......@@ -101,7 +126,7 @@ namespace spot
bdd_print_set(std::ostream& os, const tgba_bdd_dict& d, bdd b)
{
dict = &d;
want_prom = true;
want_acc = true;
bdd_strm_hook(print_handler);
os << bddset << b;
bdd_strm_hook(0);
......@@ -120,7 +145,7 @@ namespace spot
bdd_print_dot(std::ostream& os, const tgba_bdd_dict& d, bdd b)
{
dict = &d;
want_prom = true;
want_acc = true;
bdd_strm_hook(print_handler);
os << bdddot << b;
bdd_strm_hook(0);
......@@ -131,7 +156,7 @@ namespace spot
bdd_print_table(std::ostream& os, const tgba_bdd_dict& d, bdd b)
{
dict = &d;
want_prom = true;
want_acc = true;
bdd_strm_hook(print_handler);
os << bddtable << b;
bdd_strm_hook(0);
......
......@@ -26,6 +26,14 @@ namespace spot
/// \return The BDD formated as a string.
std::string bdd_format_sat(const tgba_bdd_dict& dict, bdd b);
/// \brief Print a BDD as a list of accepting conditions.
///
/// This is used when saving a TGBA.
/// \param b The BDD to print.
/// \return The BDD formated as a string.
std::ostream& bdd_print_acc(std::ostream& os,
const tgba_bdd_dict& dict, bdd b);
/// \brief Print a BDD as a set.
/// \param os The output stream.
/// \param dict The dictionary to use, to lookup variables.
......
......@@ -29,9 +29,9 @@ namespace spot
var.insert(i->first);
// Merge promises.
for (i = l.prom_map.begin(); i != l.prom_map.end(); ++i)
for (i = l.acc_map.begin(); i != l.acc_map.end(); ++i)
prom.insert(i->first);
for (i = r.prom_map.begin(); i != r.prom_map.end(); ++i)
for (i = r.acc_map.begin(); i != r.acc_map.end(); ++i)
prom.insert(i->first);
// Ensure we have enough BDD variables.
......@@ -54,8 +54,8 @@ namespace spot
for (f = prom.begin(); f != prom.end(); ++f)
{
clone(*f);
res.prom_map[*f] = v;
res.prom_formula_map[v] = *f;
res.acc_map[*f] = v;
res.acc_formula_map[v] = *f;
++v;
}
for (f = var.begin(); f != var.end(); ++f)
......
......@@ -73,12 +73,13 @@ namespace spot
fact_.add_relation(bdd_apply(now, x | next, bddop_biimp));
/*
`x | next', doesn't actually encode the fact that x
should be fulfilled at eventually. So we declare any
transition going to NEXT without checking X as
"promising x". This promises will be checked by during
the emptiness check.
should be fulfilled at eventually. We ensure
this by creating a new generalized Bchi accepting set,
Acc[x], and leave any transition going to NEXT without
checking X out of this set. Such accepting conditions
are checked for during the emptiness check.
*/
fact_.declare_promise(next & !x, node->child());
fact_.declare_accepting_condition(x | !next, node->child());
res_ = now;
return;
}
......@@ -145,10 +146,10 @@ namespace spot
/*
The rightmost conjunction, f1 & next, doesn't actually
encode the fact that f2 should be fulfilled eventually.
We declare a promise for this purpose (see the comment
in the unop::F case).
We declare an accepting condition for this purpose (see
the comment in the unop::F case).
*/
fact_.declare_promise(next & !f2, node->second());
fact_.declare_accepting_condition(f2 | !next, node->second());
res_ = now;
return;
}
......
......@@ -68,8 +68,9 @@ namespace spot
virtual state* current_state() = 0;
/// \brief Get the condition on the transition leading to this successor.
virtual bdd current_condition() = 0;
/// \brief Get the promise on the transition leading to this successor.
virtual bdd current_promise() = 0;
/// \brief Get the accepting conditions on the transition leading
/// to this successor.
virtual bdd current_accepting_conditions() = 0;
//@}
};
......
......@@ -45,7 +45,9 @@ namespace spot
tgba_succ_iterator_concrete::current_state()
{
assert(!done());
return new state_bdd(bdd_exist(current_, data_.notnow_set));
return new state_bdd(bdd_replace(bdd_exist(current_, data_.notnext_set),
data_.next_to_now));
}
bdd
......@@ -56,10 +58,11 @@ namespace spot
}
bdd
tgba_succ_iterator_concrete::current_promise()
tgba_succ_iterator_concrete::current_accepting_conditions()
{
assert(!done());
return bdd_exist(current_, data_.notprom_set);
return bdd_exist(bdd_restrict(data_.accepting_conditions, current_),
data_.notacc_set);
}
}
......@@ -30,7 +30,7 @@ namespace spot
// inspection
state_bdd* current_state();
bdd current_condition();
bdd current_promise();
bdd current_accepting_conditions();
private:
const tgba_bdd_core_data& data_; ///< Core data of the automata.
......
......@@ -77,6 +77,28 @@ namespace spot
/// This formating is the responsability of the automata
/// who owns the state.
virtual std::string format_state(const state* state) const = 0;
/// \brief Return the set of all accepting 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.
virtual bdd all_accepting_conditions() const = 0;
/// \brief Return the conjuction of all negated accepting
/// variables.
///
/// For instance if the automaton uses variables \c Acc[a],
/// \c Acc[b] and \c Acc[c] to describe accepting sets,
/// this function should return \c !Acc[a]\&!Acc[b]\&!Acc[c].
///
/// This is useful when making products: each operand conditions
/// set should be augmented with the neg_accepting_conditions() of
/// the other operand.
virtual bdd neg_accepting_conditions() const = 0;
};
}
......
......@@ -41,9 +41,7 @@ namespace spot
{
const state_bdd* s = dynamic_cast<const state_bdd*>(state);
assert(s);
bdd succ_set = bdd_replace(bdd_exist(data_.relation & s->as_bdd(),
data_.now_set),
data_.next_to_now);
bdd succ_set = bdd_exist(data_.relation & s->as_bdd(), data_.now_set);
return new tgba_succ_iterator_concrete(data_, succ_set);
}
......@@ -61,6 +59,18 @@ namespace spot
return dict_;
}
bdd
tgba_bdd_concrete::all_accepting_conditions() const
{
return data_.all_accepting_conditions;
}
bdd
tgba_bdd_concrete::neg_accepting_conditions() const
{
return data_.negacc_set;
}
const tgba_bdd_core_data&
tgba_bdd_concrete::get_core_data() const
{
......
......@@ -52,6 +52,9 @@ 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;
protected:
tgba_bdd_core_data data_; ///< Core data associated to the automaton.
tgba_bdd_dict dict_; ///< Dictionary used by the automaton.
......
#include "ltlvisit/clone.hh"
#include "ltlvisit/destroy.hh"
#include "tgbabddconcretefactory.hh"
namespace spot
{
tgba_bdd_concrete_factory::~tgba_bdd_concrete_factory()
{
promise_map_::iterator pi;
for (pi = prom_.begin(); pi != prom_.end(); ++pi)
destroy(pi->first);
acc_map_::iterator ai;
for (ai = acc_.begin(); ai != acc_.end(); ++ai)
destroy(ai->first);
}
int
......@@ -56,43 +55,50 @@ namespace spot
}
void
tgba_bdd_concrete_factory::declare_promise(bdd b,
const ltl::formula* p)
tgba_bdd_concrete_factory::declare_accepting_condition(bdd b,
const ltl::formula* a)
{
// Maintain a disjunction of BDDs associated to P.
// We will latter (in tgba_bdd_concrete_factory::finish())
// record this disjunction as equivalant to P.
promise_map_::iterator pi = prom_.find(p);
if (pi == prom_.end())
// Maintain a conjunction of BDDs associated to A. We will latter
// (in tgba_bdd_concrete_factory::finish()) associate this
// conjunction to A.
acc_map_::iterator ai = acc_.find(a);
if (ai == acc_.end())
{
p = clone(p);
prom_[p] = b;
a = clone(a);
acc_[a] = b;
}
else
{
pi->second |= b;
ai->second &= b;
}
}
void
tgba_bdd_concrete_factory::finish()
{
promise_map_::iterator pi;
for (pi = prom_.begin(); pi != prom_.end(); ++pi)
acc_map_::iterator ai;
for (ai = acc_.begin(); ai != acc_.end(); ++ai)
{
// Register a BDD variable for this accepting condition.
int a = create_node();
const ltl::formula* f = clone(ai->first); // The associated formula.
dict_.acc_map[f] = a;
dict_.acc_formula_map[a] = f;
bdd acc = ithvar(a);
// Keep track of all accepting conditions for easy
// existential quantification.
data_.declare_accepting_condition(acc);
}
for (ai = acc_.begin(); ai != acc_.end(); ++ai)
{
// Register a BDD variable for this promise.
int p = create_node();
const ltl::formula* f = clone(pi->first); // The promised formula.
dict_.prom_map[f] = p;
dict_.prom_formula_map[p] = f;
bdd prom = ithvar(p);
// Keep track of all promises for easy existential quantification.
data_.declare_promise(prom);
// The promise P must hold if we have to verify any of the
// (BDD) formulae registered.
add_relation(bdd_apply(prom, pi->second, bddop_biimp));
bdd acc = ithvar(dict_.acc_map[ai->first]);
// Complete acc with all the other accepting 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;
}
}
......
......@@ -34,17 +34,18 @@ namespace spot
/// can be turned into BDD using ithvar().
int create_atomic_prop(const ltl::formula* f);
/// Declare a promise.
///
/// \param b that BDD of the expression that makes a promise
/// \param p the formula promised
/// Declare an accepting 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_promise() to associate the promise 'g'
/// to this BDD.
void declare_promise(bdd b, const ltl::formula* p);
/// we use declare_accepting_condition() to associate
/// all other states to the accepting set of 'g'.
///
/// \param b a BDD indicating which variables are in the
/// accepting set
/// \param a the formula associated
void declare_accepting_condition(bdd b, const ltl::formula* a);
const tgba_bdd_core_data& get_core_data() const;
const tgba_bdd_dict& get_dict() const;
......@@ -63,8 +64,8 @@ namespace spot
tgba_bdd_core_data data_; ///< Core data for the new automata.
tgba_bdd_dict dict_; ///< Dictionary for the new automata.
typedef std::map<const ltl::formula*, bdd> promise_map_;
promise_map_ prom_; ///< BDD associated to each promises
typedef std::map<const ltl::formula*, bdd> acc_map_;
acc_map_ acc_; ///< BDD associated to each accepting condition
};
}
......
......@@ -3,17 +3,18 @@
namespace spot
{
tgba_bdd_core_data::tgba_bdd_core_data()
: relation(bddtrue),
now_set(bddtrue), negnow_set(bddtrue), notnow_set(bddtrue),
notvar_set(bddtrue), notprom_set(bddtrue), next_to_now(bdd_newpair())
: relation(bddtrue), accepting_conditions(bddfalse),
now_set(bddtrue), negnow_set(bddtrue), notnext_set(bddtrue),
notvar_set(bddtrue), notacc_set(bddtrue), negacc_set(bddtrue),
next_to_now(bdd_newpair())
{
}
tgba_bdd_core_data::tgba_bdd_core_data(const tgba_bdd_core_data& copy)
: relation(copy.relation),
: relation(copy.relation), accepting_conditions(copy.accepting_conditions),
now_set(copy.now_set), negnow_set(copy.negnow_set),
notnow_set(copy.notnow_set), notvar_set(copy.notvar_set),
notprom_set(copy.notprom_set),
notnext_set(copy.notnext_set), notvar_set(copy.notvar_set),
notacc_set(copy.notacc_set), negacc_set(copy.negacc_set),
next_to_now(bdd_copypair(copy.next_to_now))
{
}
......@@ -22,11 +23,14 @@ 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),
now_set(left.now_set & right.now_set),
negnow_set(left.negnow_set & right.negnow_set),
notnow_set(left.notnow_set & right.notnow_set),
notnext_set(left.notnext_set & right.notnext_set),
notvar_set(left.notvar_set & right.notvar_set),
notprom_set(left.notprom_set & right.notprom_set),
notacc_set(left.notacc_set & right.notacc_set),
negacc_set(left.negacc_set & right.negacc_set),
next_to_now(bdd_mergepairs(left.next_to_now, right.next_to_now))
{
}
......@@ -52,23 +56,24 @@ namespace spot
{
now_set &= now;
negnow_set &= !now;
notnow_set &= next;
notnext_set &= now;
bdd both = now & next;
notvar_set &= both;
notprom_set &= both;
notacc_set &= both;
}
void
tgba_bdd_core_data::declare_atomic_prop(bdd var)
{
notnow_set &= var;
notprom_set &= var;
notnext_set &= var;
notacc_set &= var;
}
void
tgba_bdd_core_data::declare_promise(bdd prom)
tgba_bdd_core_data::declare_accepting_condition(bdd acc)
{
notnow_set &= prom;
notvar_set &= prom;
notnext_set &= acc;
notvar_set &= acc;
negacc_set &= !acc;
}
}
......@@ -10,28 +10,72 @@ namespace spot
{
/// \brief encodes the transition relation of the TGBA.
///
/// \c relation uses four kinds of variables:
/// \c relation uses three kinds of variables:
/// \li "Now" variables, that encode the current state
/// \li "Next" variables, that encode the destination state
/// \li atomic propositions, which are things to verify before going on
/// to the next state
/// \li promises: \c a \c U \c b, or \c F \c b, both imply that \c b
/// should be verified eventually. We encode this with \c Prom[b],
/// and check that promises are fullfilled in the emptyness check.
bdd relation;
/// \brief encodes the accepting conditions
///
/// \c a \c U \c b, or \c F \c b, both imply that \c b
/// should be verified eventually. We encode this with generalized
/// Büchi acceptating conditions. An accepting set, called Acc[b],
/// 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 conatain
/// \c a \c U \c b, or \c F \c b.)
///
/// The spot::succ_iter::current_accepting_conditions() method
/// will return the Acc[x] variables of the accepting sets
/// in which a transition is. Actually we never return Acc[x]
/// alone, but Acc[x] and all other accepting variables negated.
///
/// So if there is three accepting set \c a, \c b, and \c c, and
/// a transition is in set \c a, we'll return \c Acc[a]&!Acc[b]&!Acc[c].
/// If the transition is in both \c a and \c b, we'll return
/// \c (Acc[a]\&!Acc[b]\&!Acc[c]) \c | \c (!Acc[a]\&Acc[b]\&!Acc[c]).
///
/// Accepting conditions are attributed to transitions and are
/// only concerned by atomic propositions (which label the
/// transitions) and Next variables (the destination). Typically,
/// a transition should bear the variable Acc[b] if it doesn't
/// check for `b' and have a destination of the form \c a \c U \c
/// b, or \c F \c b.
///
/// To summarize, \c accepting_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,