kill the ltl namespace
* NEWS: Mention it. * bench/stutter/stutter_invariance_formulas.cc, bench/stutter/stutter_invariance_randomgraph.cc, doc/mainpage.dox, doc/org/tut01.org, doc/org/tut02.org, doc/org/tut10.org, doc/tl/tl.tex, iface/ltsmin/ltsmin.cc, iface/ltsmin/ltsmin.hh, iface/ltsmin/modelcheck.cc, src/bin/autfilt.cc, src/bin/common_aoutput.cc, src/bin/common_aoutput.hh, src/bin/common_finput.cc, src/bin/common_finput.hh, src/bin/common_output.cc, src/bin/common_output.hh, src/bin/common_r.hh, src/bin/common_trans.cc, src/bin/common_trans.hh, src/bin/dstar2tgba.cc, src/bin/genltl.cc, src/bin/ltl2tgba.cc, src/bin/ltl2tgta.cc, src/bin/ltlcross.cc, src/bin/ltldo.cc, src/bin/ltlfilt.cc, src/bin/ltlgrind.cc, src/bin/randaut.cc, src/bin/randltl.cc, src/kripke/kripkeexplicit.cc, src/kripke/kripkeexplicit.hh, src/kripkeparse/kripkeparse.yy, src/kripkeparse/public.hh, src/ltlparse/fmterror.cc, src/ltlparse/ltlparse.yy, src/ltlparse/ltlscan.ll, src/ltlparse/parsedecl.hh, src/ltlparse/public.hh, src/parseaut/parseaut.yy, src/parseaut/public.hh, src/tests/checkpsl.cc, src/tests/checkta.cc, src/tests/complementation.cc, src/tests/consterm.cc, src/tests/emptchk.cc, src/tests/equalsf.cc, src/tests/ikwiad.cc, src/tests/kind.cc, src/tests/length.cc, src/tests/ltlprod.cc, src/tests/ltlrel.cc, src/tests/parse.test, src/tests/parse_print_test.cc, src/tests/randtgba.cc, src/tests/readltl.cc, src/tests/reduc.cc, src/tests/syntimpl.cc, src/tests/taatgba.cc, src/tests/tostring.cc, src/tests/tostring.test, src/tl/apcollect.cc, src/tl/apcollect.hh, src/tl/contain.cc, src/tl/contain.hh, src/tl/declenv.cc, src/tl/declenv.hh, src/tl/defaultenv.cc, src/tl/defaultenv.hh, src/tl/dot.cc, src/tl/dot.hh, src/tl/environment.hh, src/tl/exclusive.cc, src/tl/exclusive.hh, src/tl/formula.cc, src/tl/formula.hh, src/tl/length.cc, src/tl/length.hh, src/tl/mark.cc, src/tl/mark.hh, src/tl/mutation.cc, src/tl/mutation.hh, src/tl/nenoform.cc, src/tl/nenoform.hh, src/tl/print.cc, src/tl/print.hh, src/tl/randomltl.cc, src/tl/randomltl.hh, src/tl/relabel.cc, src/tl/relabel.hh, src/tl/remove_x.cc, src/tl/remove_x.hh, src/tl/simpfg.cc, src/tl/simpfg.hh, src/tl/simplify.cc, src/tl/simplify.hh, src/tl/snf.cc, src/tl/snf.hh, src/tl/unabbrev.cc, src/tl/unabbrev.hh, src/twa/bdddict.cc, src/twa/bdddict.hh, src/twa/bddprint.cc, src/twa/formula2bdd.cc, src/twa/formula2bdd.hh, src/twa/taatgba.cc, src/twa/taatgba.hh, src/twa/twa.hh, src/twa/twagraph.cc, src/twa/twagraph.hh, src/twaalgos/compsusp.cc, src/twaalgos/compsusp.hh, src/twaalgos/ltl2taa.cc, src/twaalgos/ltl2taa.hh, src/twaalgos/ltl2tgba_fm.cc, src/twaalgos/ltl2tgba_fm.hh, src/twaalgos/minimize.cc, src/twaalgos/minimize.hh, src/twaalgos/neverclaim.cc, src/twaalgos/postproc.cc, src/twaalgos/postproc.hh, src/twaalgos/powerset.cc, src/twaalgos/powerset.hh, src/twaalgos/randomgraph.cc, src/twaalgos/randomgraph.hh, src/twaalgos/relabel.cc, src/twaalgos/relabel.hh, src/twaalgos/remprop.cc, src/twaalgos/remprop.hh, src/twaalgos/stats.cc, src/twaalgos/stats.hh, src/twaalgos/stutter.cc, src/twaalgos/stutter.hh, src/twaalgos/translate.cc, src/twaalgos/translate.hh, wrap/python/spot_impl.i: Remove the ltl namespace.
This commit is contained in:
Alexandre Duret-Lutz
parent
6ded5e75c4
commit
cb39210166
137 changed files with 10771 additions and 10919 deletions
|
|
@ -27,461 +27,457 @@
|
|||
|
||||
namespace spot
|
||||
{
|
||||
namespace ltl
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Basic relabeler
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Basic relabeler
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace
|
||||
struct ap_generator
|
||||
{
|
||||
struct ap_generator
|
||||
{
|
||||
virtual formula next() = 0;
|
||||
virtual ~ap_generator() {}
|
||||
};
|
||||
virtual formula next() = 0;
|
||||
virtual ~ap_generator() {}
|
||||
};
|
||||
|
||||
struct pnn_generator final: ap_generator
|
||||
{
|
||||
unsigned nn;
|
||||
pnn_generator()
|
||||
: nn(0)
|
||||
{
|
||||
}
|
||||
|
||||
formula next()
|
||||
{
|
||||
std::ostringstream s;
|
||||
s << 'p' << nn++;
|
||||
return formula::ap(s.str());
|
||||
}
|
||||
};
|
||||
|
||||
struct abc_generator final: ap_generator
|
||||
{
|
||||
public:
|
||||
abc_generator()
|
||||
: nn(0)
|
||||
{
|
||||
}
|
||||
|
||||
unsigned nn;
|
||||
|
||||
formula next()
|
||||
{
|
||||
std::string s;
|
||||
unsigned n = nn++;
|
||||
do
|
||||
{
|
||||
s.push_back('a' + (n % 26));
|
||||
n /= 26;
|
||||
}
|
||||
while (n);
|
||||
return formula::ap(s);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
class relabeler
|
||||
{
|
||||
public:
|
||||
typedef std::unordered_map<formula, formula> map;
|
||||
map newname;
|
||||
ap_generator* gen;
|
||||
relabeling_map* oldnames;
|
||||
|
||||
relabeler(ap_generator* gen, relabeling_map* m)
|
||||
: gen(gen), oldnames(m)
|
||||
{
|
||||
}
|
||||
|
||||
~relabeler()
|
||||
{
|
||||
delete gen;
|
||||
}
|
||||
|
||||
formula rename(formula old)
|
||||
{
|
||||
auto r = newname.emplace(old, nullptr);
|
||||
if (!r.second)
|
||||
{
|
||||
return r.first->second;
|
||||
}
|
||||
else
|
||||
{
|
||||
formula res = gen->next();
|
||||
r.first->second = res;
|
||||
if (oldnames)
|
||||
(*oldnames)[res] = old;
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
formula
|
||||
visit(formula f)
|
||||
{
|
||||
if (f.is(op::ap))
|
||||
return rename(f);
|
||||
else
|
||||
return f.map([this](formula f)
|
||||
{
|
||||
return this->visit(f);
|
||||
});
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
formula
|
||||
relabel(formula f, relabeling_style style, relabeling_map* m)
|
||||
struct pnn_generator final: ap_generator
|
||||
{
|
||||
ap_generator* gen = nullptr;
|
||||
switch (style)
|
||||
unsigned nn;
|
||||
pnn_generator()
|
||||
: nn(0)
|
||||
{
|
||||
case Pnn:
|
||||
gen = new pnn_generator;
|
||||
break;
|
||||
case Abc:
|
||||
gen = new abc_generator;
|
||||
break;
|
||||
}
|
||||
|
||||
relabeler r(gen, m);
|
||||
return r.visit(f);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Boolean-subexpression relabeler
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Here we want to rewrite a formula such as
|
||||
// "a & b & X(c & d) & GF(c & d)" into "p0 & Xp1 & GFp1"
|
||||
// where Boolean subexpressions are replaced by fresh propositions.
|
||||
//
|
||||
// Detecting Boolean subexpressions is not a problem.
|
||||
// Furthermore, because we are already representing LTL formulas
|
||||
// with sharing of identical sub-expressions we can easily rename
|
||||
// a subexpression (such as c&d above) only once. However this
|
||||
// scheme has two problems:
|
||||
//
|
||||
// 1. It will not detect inter-dependent Boolean subexpressions.
|
||||
// For instance it will mistakenly relabel "(a & b) U (a & !b)"
|
||||
// as "p0 U p1", hiding the dependency between a&b and a&!b.
|
||||
//
|
||||
// 2. Because of our n-ary operators, it will fail to
|
||||
// notice that (a & b) is a sub-expression of (a & b & c).
|
||||
//
|
||||
// The code below only addresses point 1 so that interdependent
|
||||
// subexpressions are not relabeled. Point 2 could be improved in
|
||||
// a future version of somebody feels inclined to do so.
|
||||
//
|
||||
// The way we compute the subexpressions that can be relabeled is
|
||||
// by transforming the formula syntax tree into an undirected
|
||||
// graph, and computing the cut points of this graph. The cut
|
||||
// points (or articulation points) are the nodes whose removal
|
||||
// would split the graph in two components. To ensure that a
|
||||
// Boolean operator is only considered as a cut point if it would
|
||||
// separate all of its children from the rest of the graph, we
|
||||
// connect all the children of Boolean operators.
|
||||
//
|
||||
// For instance (a & b) U (c & d) has two (Boolean) cut points
|
||||
// corresponding to the two AND operators:
|
||||
//
|
||||
// (a&b)U(c&d)
|
||||
// ╱ ╲
|
||||
// a&b c&d
|
||||
// ╱ ╲ ╱ ╲
|
||||
// a─────b c─────d
|
||||
//
|
||||
// (The root node is also a cut-point, but we only consider Boolean
|
||||
// cut-points for relabeling.)
|
||||
//
|
||||
// On the other hand, (a & b) U (b & !c) has only one Boolean
|
||||
// cut-point which corresponds to the NOT operator:
|
||||
//
|
||||
// (a&b)U(b&!c)
|
||||
// ╱ ╲
|
||||
// a&b b&c
|
||||
// ╱ ╲ ╱ ╲
|
||||
// a─────b────!c
|
||||
// │
|
||||
// c
|
||||
//
|
||||
// Note that if the children of a&b and b&c were not connected,
|
||||
// a&b and b&c would be considered as cut points because they
|
||||
// separate "a" or "!c" from the rest of the graph.
|
||||
//
|
||||
// The relabeling of a formula is therefore done in 3 passes:
|
||||
// 1. convert the formula's syntax tree into an undirected graph,
|
||||
// adding links between children of Boolean operators
|
||||
// 2. compute the (Boolean) cut points of that graph, using the
|
||||
// Hopcroft-Tarjan algorithm (see below for a reference)
|
||||
// 3. recursively scan the formula's tree until we reach
|
||||
// either a (Boolean) cut point or an atomic proposition, and
|
||||
// replace that node by a fresh atomic proposition.
|
||||
//
|
||||
// In the example above (a&b)U(b&!c), the last recursion
|
||||
// stop a, b, and !c, producing (p0&p1)U(p1&p2).
|
||||
namespace
|
||||
{
|
||||
typedef std::vector<formula> succ_vec;
|
||||
typedef std::map<formula, succ_vec> fgraph;
|
||||
|
||||
// Convert the formula's syntax tree into an undirected graph
|
||||
// labeled by subformulas.
|
||||
class formula_to_fgraph final
|
||||
formula next()
|
||||
{
|
||||
public:
|
||||
fgraph& g;
|
||||
std::stack<formula> s;
|
||||
std::ostringstream s;
|
||||
s << 'p' << nn++;
|
||||
return formula::ap(s.str());
|
||||
}
|
||||
};
|
||||
|
||||
formula_to_fgraph(fgraph& g):
|
||||
g(g)
|
||||
struct abc_generator final: ap_generator
|
||||
{
|
||||
public:
|
||||
abc_generator()
|
||||
: nn(0)
|
||||
{
|
||||
}
|
||||
|
||||
~formula_to_fgraph()
|
||||
{
|
||||
}
|
||||
unsigned nn;
|
||||
|
||||
void
|
||||
visit(formula f)
|
||||
{
|
||||
formula next()
|
||||
{
|
||||
std::string s;
|
||||
unsigned n = nn++;
|
||||
do
|
||||
{
|
||||
// Connect to parent
|
||||
auto in = g.emplace(f, succ_vec());
|
||||
if (!s.empty())
|
||||
{
|
||||
formula top = s.top();
|
||||
in.first->second.push_back(top);
|
||||
g[top].push_back(f);
|
||||
if (!in.second)
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(in.second);
|
||||
}
|
||||
s.push_back('a' + (n % 26));
|
||||
n /= 26;
|
||||
}
|
||||
s.push(f);
|
||||
while (n);
|
||||
return formula::ap(s);
|
||||
}
|
||||
};
|
||||
|
||||
unsigned sz = f.size();
|
||||
unsigned i = 0;
|
||||
if (sz > 2 && !f.is_boolean())
|
||||
|
||||
class relabeler
|
||||
{
|
||||
public:
|
||||
typedef std::unordered_map<formula, formula> map;
|
||||
map newname;
|
||||
ap_generator* gen;
|
||||
relabeling_map* oldnames;
|
||||
|
||||
relabeler(ap_generator* gen, relabeling_map* m)
|
||||
: gen(gen), oldnames(m)
|
||||
{
|
||||
}
|
||||
|
||||
~relabeler()
|
||||
{
|
||||
delete gen;
|
||||
}
|
||||
|
||||
formula rename(formula old)
|
||||
{
|
||||
auto r = newname.emplace(old, nullptr);
|
||||
if (!r.second)
|
||||
{
|
||||
return r.first->second;
|
||||
}
|
||||
else
|
||||
{
|
||||
formula res = gen->next();
|
||||
r.first->second = res;
|
||||
if (oldnames)
|
||||
(*oldnames)[res] = old;
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
formula
|
||||
visit(formula f)
|
||||
{
|
||||
if (f.is(op::ap))
|
||||
return rename(f);
|
||||
else
|
||||
return f.map([this](formula f)
|
||||
{
|
||||
return this->visit(f);
|
||||
});
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
formula
|
||||
relabel(formula f, relabeling_style style, relabeling_map* m)
|
||||
{
|
||||
ap_generator* gen = nullptr;
|
||||
switch (style)
|
||||
{
|
||||
case Pnn:
|
||||
gen = new pnn_generator;
|
||||
break;
|
||||
case Abc:
|
||||
gen = new abc_generator;
|
||||
break;
|
||||
}
|
||||
|
||||
relabeler r(gen, m);
|
||||
return r.visit(f);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Boolean-subexpression relabeler
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Here we want to rewrite a formula such as
|
||||
// "a & b & X(c & d) & GF(c & d)" into "p0 & Xp1 & GFp1"
|
||||
// where Boolean subexpressions are replaced by fresh propositions.
|
||||
//
|
||||
// Detecting Boolean subexpressions is not a problem.
|
||||
// Furthermore, because we are already representing LTL formulas
|
||||
// with sharing of identical sub-expressions we can easily rename
|
||||
// a subexpression (such as c&d above) only once. However this
|
||||
// scheme has two problems:
|
||||
//
|
||||
// 1. It will not detect inter-dependent Boolean subexpressions.
|
||||
// For instance it will mistakenly relabel "(a & b) U (a & !b)"
|
||||
// as "p0 U p1", hiding the dependency between a&b and a&!b.
|
||||
//
|
||||
// 2. Because of our n-ary operators, it will fail to
|
||||
// notice that (a & b) is a sub-expression of (a & b & c).
|
||||
//
|
||||
// The code below only addresses point 1 so that interdependent
|
||||
// subexpressions are not relabeled. Point 2 could be improved in
|
||||
// a future version of somebody feels inclined to do so.
|
||||
//
|
||||
// The way we compute the subexpressions that can be relabeled is
|
||||
// by transforming the formula syntax tree into an undirected
|
||||
// graph, and computing the cut points of this graph. The cut
|
||||
// points (or articulation points) are the nodes whose removal
|
||||
// would split the graph in two components. To ensure that a
|
||||
// Boolean operator is only considered as a cut point if it would
|
||||
// separate all of its children from the rest of the graph, we
|
||||
// connect all the children of Boolean operators.
|
||||
//
|
||||
// For instance (a & b) U (c & d) has two (Boolean) cut points
|
||||
// corresponding to the two AND operators:
|
||||
//
|
||||
// (a&b)U(c&d)
|
||||
// ╱ ╲
|
||||
// a&b c&d
|
||||
// ╱ ╲ ╱ ╲
|
||||
// a─────b c─────d
|
||||
//
|
||||
// (The root node is also a cut-point, but we only consider Boolean
|
||||
// cut-points for relabeling.)
|
||||
//
|
||||
// On the other hand, (a & b) U (b & !c) has only one Boolean
|
||||
// cut-point which corresponds to the NOT operator:
|
||||
//
|
||||
// (a&b)U(b&!c)
|
||||
// ╱ ╲
|
||||
// a&b b&c
|
||||
// ╱ ╲ ╱ ╲
|
||||
// a─────b────!c
|
||||
// │
|
||||
// c
|
||||
//
|
||||
// Note that if the children of a&b and b&c were not connected,
|
||||
// a&b and b&c would be considered as cut points because they
|
||||
// separate "a" or "!c" from the rest of the graph.
|
||||
//
|
||||
// The relabeling of a formula is therefore done in 3 passes:
|
||||
// 1. convert the formula's syntax tree into an undirected graph,
|
||||
// adding links between children of Boolean operators
|
||||
// 2. compute the (Boolean) cut points of that graph, using the
|
||||
// Hopcroft-Tarjan algorithm (see below for a reference)
|
||||
// 3. recursively scan the formula's tree until we reach
|
||||
// either a (Boolean) cut point or an atomic proposition, and
|
||||
// replace that node by a fresh atomic proposition.
|
||||
//
|
||||
// In the example above (a&b)U(b&!c), the last recursion
|
||||
// stop a, b, and !c, producing (p0&p1)U(p1&p2).
|
||||
namespace
|
||||
{
|
||||
typedef std::vector<formula> succ_vec;
|
||||
typedef std::map<formula, succ_vec> fgraph;
|
||||
|
||||
// Convert the formula's syntax tree into an undirected graph
|
||||
// labeled by subformulas.
|
||||
class formula_to_fgraph final
|
||||
{
|
||||
public:
|
||||
fgraph& g;
|
||||
std::stack<formula> s;
|
||||
|
||||
formula_to_fgraph(fgraph& g):
|
||||
g(g)
|
||||
{
|
||||
}
|
||||
|
||||
~formula_to_fgraph()
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
visit(formula f)
|
||||
{
|
||||
{
|
||||
// Connect to parent
|
||||
auto in = g.emplace(f, succ_vec());
|
||||
if (!s.empty())
|
||||
{
|
||||
/// If we have a formula like (a & b & Xc), consider
|
||||
/// it as ((a & b) & Xc) in the graph to isolate the
|
||||
/// Boolean operands as a single node.
|
||||
formula b = f.boolean_operands(&i);
|
||||
if (b)
|
||||
visit(b);
|
||||
formula top = s.top();
|
||||
in.first->second.push_back(top);
|
||||
g[top].push_back(f);
|
||||
if (!in.second)
|
||||
return;
|
||||
}
|
||||
for (; i < sz; ++i)
|
||||
visit(f[i]);
|
||||
if (sz > 1 && f.is_boolean())
|
||||
else
|
||||
{
|
||||
// For Boolean nodes, connect all children in a
|
||||
// loop. This way the node can only be a cut-point
|
||||
// if it separates all children from the reset of
|
||||
// the graph (not only one).
|
||||
formula pred = f[0];
|
||||
for (i = 1; i < sz; ++i)
|
||||
assert(in.second);
|
||||
}
|
||||
}
|
||||
s.push(f);
|
||||
|
||||
unsigned sz = f.size();
|
||||
unsigned i = 0;
|
||||
if (sz > 2 && !f.is_boolean())
|
||||
{
|
||||
/// If we have a formula like (a & b & Xc), consider
|
||||
/// it as ((a & b) & Xc) in the graph to isolate the
|
||||
/// Boolean operands as a single node.
|
||||
formula b = f.boolean_operands(&i);
|
||||
if (b)
|
||||
visit(b);
|
||||
}
|
||||
for (; i < sz; ++i)
|
||||
visit(f[i]);
|
||||
if (sz > 1 && f.is_boolean())
|
||||
{
|
||||
// For Boolean nodes, connect all children in a
|
||||
// loop. This way the node can only be a cut-point
|
||||
// if it separates all children from the reset of
|
||||
// the graph (not only one).
|
||||
formula pred = f[0];
|
||||
for (i = 1; i < sz; ++i)
|
||||
{
|
||||
formula next = f[i];
|
||||
// Note that we only add an edge in one
|
||||
// direction, because we are building a cycle
|
||||
// between all children anyway.
|
||||
g[pred].push_back(next);
|
||||
pred = next;
|
||||
}
|
||||
g[pred].push_back(f[0]);
|
||||
}
|
||||
s.pop();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
typedef std::set<formula> fset;
|
||||
struct data_entry // for each node of the graph
|
||||
{
|
||||
unsigned num; // serial number, in pre-order
|
||||
unsigned low; // lowest number accessible via unstacked descendants
|
||||
data_entry(unsigned num = 0, unsigned low = 0)
|
||||
: num(num), low(low)
|
||||
{
|
||||
}
|
||||
};
|
||||
typedef std::unordered_map<formula, data_entry> fmap_t;
|
||||
struct stack_entry
|
||||
{
|
||||
formula grand_parent;
|
||||
formula parent; // current node
|
||||
succ_vec::const_iterator current_child;
|
||||
succ_vec::const_iterator last_child;
|
||||
};
|
||||
typedef std::stack<stack_entry> stack_t;
|
||||
|
||||
// Fill c with the Boolean cutpoints of g, starting from start.
|
||||
//
|
||||
// This is based no "Efficient Algorithms for Graph
|
||||
// Manipulation", J. Hopcroft & R. Tarjan, in Communications of
|
||||
// the ACM, 16 (6), June 1973.
|
||||
//
|
||||
// It differs from the original algorithm by returning only the
|
||||
// Boolean cutpoints, and not dealing with the initial state
|
||||
// properly (our initial state will always be considered as a
|
||||
// cut-point, but since we only return Boolean cut-points it's
|
||||
// OK: if the top-most formula is Boolean we want to replace it
|
||||
// as a whole).
|
||||
void cut_points(const fgraph& g, fset& c, formula start)
|
||||
{
|
||||
stack_t s;
|
||||
|
||||
unsigned num = 0;
|
||||
fmap_t data;
|
||||
data_entry d = { num, num };
|
||||
data[start] = d;
|
||||
++num;
|
||||
const succ_vec& children = g.find(start)->second;
|
||||
stack_entry e = { start, start, children.begin(), children.end() };
|
||||
s.push(e);
|
||||
|
||||
while (!s.empty())
|
||||
{
|
||||
stack_entry& e = s.top();
|
||||
if (e.current_child != e.last_child)
|
||||
{
|
||||
// Skip the edge if it is just the reverse of the one
|
||||
// we took.
|
||||
formula child = *e.current_child;
|
||||
if (child == e.grand_parent)
|
||||
{
|
||||
formula next = f[i];
|
||||
// Note that we only add an edge in one
|
||||
// direction, because we are building a cycle
|
||||
// between all children anyway.
|
||||
g[pred].push_back(next);
|
||||
pred = next;
|
||||
++e.current_child;
|
||||
continue;
|
||||
}
|
||||
g[pred].push_back(f[0]);
|
||||
}
|
||||
s.pop();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
typedef std::set<formula> fset;
|
||||
struct data_entry // for each node of the graph
|
||||
{
|
||||
unsigned num; // serial number, in pre-order
|
||||
unsigned low; // lowest number accessible via unstacked descendants
|
||||
data_entry(unsigned num = 0, unsigned low = 0)
|
||||
: num(num), low(low)
|
||||
{
|
||||
}
|
||||
};
|
||||
typedef std::unordered_map<formula, data_entry> fmap_t;
|
||||
struct stack_entry
|
||||
{
|
||||
formula grand_parent;
|
||||
formula parent; // current node
|
||||
succ_vec::const_iterator current_child;
|
||||
succ_vec::const_iterator last_child;
|
||||
};
|
||||
typedef std::stack<stack_entry> stack_t;
|
||||
|
||||
// Fill c with the Boolean cutpoints of g, starting from start.
|
||||
//
|
||||
// This is based no "Efficient Algorithms for Graph
|
||||
// Manipulation", J. Hopcroft & R. Tarjan, in Communications of
|
||||
// the ACM, 16 (6), June 1973.
|
||||
//
|
||||
// It differs from the original algorithm by returning only the
|
||||
// Boolean cutpoints, and not dealing with the initial state
|
||||
// properly (our initial state will always be considered as a
|
||||
// cut-point, but since we only return Boolean cut-points it's
|
||||
// OK: if the top-most formula is Boolean we want to replace it
|
||||
// as a whole).
|
||||
void cut_points(const fgraph& g, fset& c, formula start)
|
||||
{
|
||||
stack_t s;
|
||||
|
||||
unsigned num = 0;
|
||||
fmap_t data;
|
||||
data_entry d = { num, num };
|
||||
data[start] = d;
|
||||
++num;
|
||||
const succ_vec& children = g.find(start)->second;
|
||||
stack_entry e = { start, start, children.begin(), children.end() };
|
||||
s.push(e);
|
||||
|
||||
while (!s.empty())
|
||||
{
|
||||
stack_entry& e = s.top();
|
||||
if (e.current_child != e.last_child)
|
||||
{
|
||||
// Skip the edge if it is just the reverse of the one
|
||||
// we took.
|
||||
formula child = *e.current_child;
|
||||
if (child == e.grand_parent)
|
||||
{
|
||||
++e.current_child;
|
||||
continue;
|
||||
}
|
||||
auto i = data.emplace(std::piecewise_construct,
|
||||
std::forward_as_tuple(child),
|
||||
std::forward_as_tuple(num, num));
|
||||
if (i.second) // New destination.
|
||||
{
|
||||
++num;
|
||||
const succ_vec& children = g.find(child)->second;
|
||||
stack_entry newe = { e.parent, child,
|
||||
children.begin(), children.end() };
|
||||
s.push(newe);
|
||||
}
|
||||
else // Destination exists.
|
||||
{
|
||||
data_entry& dparent = data[e.parent];
|
||||
data_entry& dchild = i.first->second;
|
||||
// If this is a back-edge, update
|
||||
// the low field of the parent.
|
||||
if (dchild.num <= dparent.num)
|
||||
if (dparent.low > dchild.num)
|
||||
dparent.low = dchild.num;
|
||||
}
|
||||
++e.current_child;
|
||||
}
|
||||
else
|
||||
{
|
||||
formula grand_parent = e.grand_parent;
|
||||
formula parent = e.parent;
|
||||
s.pop();
|
||||
if (!s.empty())
|
||||
{
|
||||
data_entry& dparent = data[parent];
|
||||
data_entry& dgrand_parent = data[grand_parent];
|
||||
if (dparent.low >= dgrand_parent.num // cut-point
|
||||
&& grand_parent.is_boolean())
|
||||
c.insert(grand_parent);
|
||||
if (dparent.low < dgrand_parent.low)
|
||||
dgrand_parent.low = dparent.low;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class bse_relabeler final: public relabeler
|
||||
{
|
||||
public:
|
||||
fset& c;
|
||||
bse_relabeler(ap_generator* gen, fset& c,
|
||||
relabeling_map* m)
|
||||
: relabeler(gen, m), c(c)
|
||||
{
|
||||
}
|
||||
|
||||
using relabeler::visit;
|
||||
|
||||
formula
|
||||
visit(formula f)
|
||||
{
|
||||
if (f.is(op::ap) || (c.find(f) != c.end()))
|
||||
return rename(f);
|
||||
|
||||
unsigned sz = f.size();
|
||||
if (sz <= 2)
|
||||
return f.map([this](formula f)
|
||||
{
|
||||
return visit(f);
|
||||
});
|
||||
|
||||
unsigned i = 0;
|
||||
std::vector<formula> res;
|
||||
/// If we have a formula like (a & b & Xc), consider
|
||||
/// it as ((a & b) & Xc) in the graph to isolate the
|
||||
/// Boolean operands as a single node.
|
||||
formula b = f.boolean_operands(&i);
|
||||
if (b)
|
||||
{
|
||||
res.reserve(sz - i + 1);
|
||||
res.push_back(visit(b));
|
||||
auto i = data.emplace(std::piecewise_construct,
|
||||
std::forward_as_tuple(child),
|
||||
std::forward_as_tuple(num, num));
|
||||
if (i.second) // New destination.
|
||||
{
|
||||
++num;
|
||||
const succ_vec& children = g.find(child)->second;
|
||||
stack_entry newe = { e.parent, child,
|
||||
children.begin(), children.end() };
|
||||
s.push(newe);
|
||||
}
|
||||
else // Destination exists.
|
||||
{
|
||||
data_entry& dparent = data[e.parent];
|
||||
data_entry& dchild = i.first->second;
|
||||
// If this is a back-edge, update
|
||||
// the low field of the parent.
|
||||
if (dchild.num <= dparent.num)
|
||||
if (dparent.low > dchild.num)
|
||||
dparent.low = dchild.num;
|
||||
}
|
||||
++e.current_child;
|
||||
}
|
||||
else
|
||||
{
|
||||
res.reserve(sz);
|
||||
formula grand_parent = e.grand_parent;
|
||||
formula parent = e.parent;
|
||||
s.pop();
|
||||
if (!s.empty())
|
||||
{
|
||||
data_entry& dparent = data[parent];
|
||||
data_entry& dgrand_parent = data[grand_parent];
|
||||
if (dparent.low >= dgrand_parent.num // cut-point
|
||||
&& grand_parent.is_boolean())
|
||||
c.insert(grand_parent);
|
||||
if (dparent.low < dgrand_parent.low)
|
||||
dgrand_parent.low = dparent.low;
|
||||
}
|
||||
}
|
||||
for (; i < sz; ++i)
|
||||
res.push_back(visit(f[i]));
|
||||
return formula::multop(f.kind(), res);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
formula
|
||||
relabel_bse(formula f, relabeling_style style, relabeling_map* m)
|
||||
class bse_relabeler final: public relabeler
|
||||
{
|
||||
fgraph g;
|
||||
|
||||
// Build the graph g from the formula f.
|
||||
public:
|
||||
fset& c;
|
||||
bse_relabeler(ap_generator* gen, fset& c,
|
||||
relabeling_map* m)
|
||||
: relabeler(gen, m), c(c)
|
||||
{
|
||||
formula_to_fgraph conv(g);
|
||||
conv.visit(f);
|
||||
}
|
||||
|
||||
// Compute its cut-points
|
||||
fset c;
|
||||
cut_points(g, c, f);
|
||||
using relabeler::visit;
|
||||
|
||||
// Relabel the formula recursively, stopping
|
||||
// at cut-points or atomic propositions.
|
||||
ap_generator* gen = nullptr;
|
||||
switch (style)
|
||||
{
|
||||
case Pnn:
|
||||
gen = new pnn_generator;
|
||||
break;
|
||||
case Abc:
|
||||
gen = new abc_generator;
|
||||
break;
|
||||
}
|
||||
bse_relabeler rel(gen, c, m);
|
||||
return rel.visit(f);
|
||||
formula
|
||||
visit(formula f)
|
||||
{
|
||||
if (f.is(op::ap) || (c.find(f) != c.end()))
|
||||
return rename(f);
|
||||
|
||||
unsigned sz = f.size();
|
||||
if (sz <= 2)
|
||||
return f.map([this](formula f)
|
||||
{
|
||||
return visit(f);
|
||||
});
|
||||
|
||||
unsigned i = 0;
|
||||
std::vector<formula> res;
|
||||
/// If we have a formula like (a & b & Xc), consider
|
||||
/// it as ((a & b) & Xc) in the graph to isolate the
|
||||
/// Boolean operands as a single node.
|
||||
formula b = f.boolean_operands(&i);
|
||||
if (b)
|
||||
{
|
||||
res.reserve(sz - i + 1);
|
||||
res.push_back(visit(b));
|
||||
}
|
||||
else
|
||||
{
|
||||
res.reserve(sz);
|
||||
}
|
||||
for (; i < sz; ++i)
|
||||
res.push_back(visit(f[i]));
|
||||
return formula::multop(f.kind(), res);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
formula
|
||||
relabel_bse(formula f, relabeling_style style, relabeling_map* m)
|
||||
{
|
||||
fgraph g;
|
||||
|
||||
// Build the graph g from the formula f.
|
||||
{
|
||||
formula_to_fgraph conv(g);
|
||||
conv.visit(f);
|
||||
}
|
||||
|
||||
// Compute its cut-points
|
||||
fset c;
|
||||
cut_points(g, c, f);
|
||||
|
||||
// Relabel the formula recursively, stopping
|
||||
// at cut-points or atomic propositions.
|
||||
ap_generator* gen = nullptr;
|
||||
switch (style)
|
||||
{
|
||||
case Pnn:
|
||||
gen = new pnn_generator;
|
||||
break;
|
||||
case Abc:
|
||||
gen = new abc_generator;
|
||||
break;
|
||||
}
|
||||
bse_relabeler rel(gen, c, m);
|
||||
return rel.visit(f);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue