Introduce ltl_simplifier.
It is limited to negative_normal_form_visitor for now. * src/ltlvisit/simplify.cc, src/ltlvisit/simplify.hh: New files. * src/ltlvisit/Makefile.am: Add them. * src/ltlvisit/nenoform.cc, src/ltlvisit/nenoform.hh: Rewrite using ltl_simplifier.
This commit is contained in:
Alexandre Duret-Lutz
parent
0caa631c0d
commit
9f7ef5d0c3
5 changed files with 662 additions and 265 deletions
|
|
@ -1,4 +1,4 @@
|
|||
// Copyright (C) 2009, 2010 Laboratoire de Recherche et Développement
|
||||
// Copyright (C) 2009, 2010, 2011 Laboratoire de Recherche et Développement
|
||||
// de l'Epita (LRDE).
|
||||
// Copyright (C) 2003, 2004 Laboratoire d'Informatique de Paris 6 (LIP6),
|
||||
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
|
||||
|
|
@ -21,279 +21,20 @@
|
|||
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
||||
// 02111-1307, USA.
|
||||
|
||||
#include "nenoform.hh"
|
||||
#include "ltlast/allnodes.hh"
|
||||
#include <cassert>
|
||||
#include "simplify.hh"
|
||||
|
||||
namespace spot
|
||||
{
|
||||
namespace ltl
|
||||
{
|
||||
namespace
|
||||
{
|
||||
class negative_normal_form_visitor: public visitor
|
||||
{
|
||||
public:
|
||||
negative_normal_form_visitor(bool negated)
|
||||
: negated_(negated)
|
||||
{
|
||||
}
|
||||
|
||||
virtual
|
||||
~negative_normal_form_visitor()
|
||||
{
|
||||
}
|
||||
|
||||
formula* result() const
|
||||
{
|
||||
return result_;
|
||||
}
|
||||
|
||||
void
|
||||
visit(atomic_prop* ap)
|
||||
{
|
||||
formula* f = ap->clone();
|
||||
if (negated_)
|
||||
result_ = unop::instance(unop::Not, f);
|
||||
else
|
||||
result_ = f;
|
||||
}
|
||||
|
||||
void
|
||||
visit(constant* c)
|
||||
{
|
||||
if (!negated_)
|
||||
{
|
||||
result_ = c;
|
||||
return;
|
||||
}
|
||||
|
||||
switch (c->val())
|
||||
{
|
||||
case constant::True:
|
||||
result_ = constant::false_instance();
|
||||
return;
|
||||
case constant::False:
|
||||
result_ = constant::true_instance();
|
||||
return;
|
||||
case constant::EmptyWord:
|
||||
result_ = unop::instance(unop::Not,
|
||||
constant::empty_word_instance());
|
||||
return;
|
||||
}
|
||||
/* Unreachable code. */
|
||||
assert(0);
|
||||
}
|
||||
|
||||
void
|
||||
visit(unop* uo)
|
||||
{
|
||||
formula* f = uo->child();
|
||||
switch (uo->op())
|
||||
{
|
||||
case unop::Not:
|
||||
result_ = recurse_(f, negated_ ^ true);
|
||||
return;
|
||||
case unop::X:
|
||||
/* !Xa == X!a */
|
||||
result_ = unop::instance(unop::X, recurse(f));
|
||||
return;
|
||||
case unop::F:
|
||||
/* !Fa == G!a */
|
||||
result_ = unop::instance(negated_ ? unop::G : unop::F,
|
||||
recurse(f));
|
||||
return;
|
||||
case unop::G:
|
||||
/* !Ga == F!a */
|
||||
result_ = unop::instance(negated_ ? unop::F : unop::G,
|
||||
recurse(f));
|
||||
return;
|
||||
case unop::Closure:
|
||||
result_ = unop::instance(negated_ ?
|
||||
unop::NegClosure : unop::Closure,
|
||||
recurse_(f, false));
|
||||
return;
|
||||
case unop::NegClosure:
|
||||
result_ = unop::instance(negated_ ?
|
||||
unop::Closure : uo->op(),
|
||||
recurse_(f, false));
|
||||
return;
|
||||
/* !Finish(x), is not simplified */
|
||||
case unop::Finish:
|
||||
result_ = unop::instance(uo->op(), recurse_(f, false));
|
||||
if (negated_)
|
||||
result_ = unop::instance(unop::Not, result_);
|
||||
return;
|
||||
}
|
||||
/* Unreachable code. */
|
||||
assert(0);
|
||||
}
|
||||
|
||||
void
|
||||
visit(bunop* bo)
|
||||
{
|
||||
// !(a*) is not simplified
|
||||
result_ = bunop::instance(bo->op(), recurse_(bo->child(), false),
|
||||
bo->min(), bo->max());
|
||||
if (negated_)
|
||||
result_ = unop::instance(unop::Not, result_);
|
||||
}
|
||||
|
||||
void
|
||||
visit(binop* bo)
|
||||
{
|
||||
formula* f1 = bo->first();
|
||||
formula* f2 = bo->second();
|
||||
switch (bo->op())
|
||||
{
|
||||
case binop::Xor:
|
||||
/* !(a ^ b) == a <=> b */
|
||||
result_ = binop::instance(negated_ ? binop::Equiv : binop::Xor,
|
||||
recurse_(f1, false),
|
||||
recurse_(f2, false));
|
||||
return;
|
||||
case binop::Equiv:
|
||||
/* !(a <=> b) == a ^ b */
|
||||
result_ = binop::instance(negated_ ? binop::Xor : binop::Equiv,
|
||||
recurse_(f1, false),
|
||||
recurse_(f2, false));
|
||||
return;
|
||||
case binop::Implies:
|
||||
if (negated_)
|
||||
/* !(a => b) == a & !b */
|
||||
result_ = multop::instance(multop::And,
|
||||
recurse_(f1, false),
|
||||
recurse_(f2, true));
|
||||
else
|
||||
result_ = binop::instance(binop::Implies,
|
||||
recurse(f1), recurse(f2));
|
||||
return;
|
||||
case binop::U:
|
||||
/* !(a U b) == !a R !b */
|
||||
result_ = binop::instance(negated_ ? binop::R : binop::U,
|
||||
recurse(f1), recurse(f2));
|
||||
return;
|
||||
case binop::R:
|
||||
/* !(a R b) == !a U !b */
|
||||
result_ = binop::instance(negated_ ? binop::U : binop::R,
|
||||
recurse(f1), recurse(f2));
|
||||
return;
|
||||
case binop::W:
|
||||
/* !(a W b) == !a M !b */
|
||||
result_ = binop::instance(negated_ ? binop::M : binop::W,
|
||||
recurse(f1), recurse(f2));
|
||||
return;
|
||||
case binop::M:
|
||||
/* !(a M b) == !a W !b */
|
||||
result_ = binop::instance(negated_ ? binop::W : binop::M,
|
||||
recurse(f1), recurse(f2));
|
||||
return;
|
||||
case binop::UConcat:
|
||||
/* !(a []-> b) == a<>-> !b */
|
||||
result_ = binop::instance(negated_ ?
|
||||
binop::EConcat : binop::UConcat,
|
||||
recurse_(f1, false), recurse(f2));
|
||||
return;
|
||||
case binop::EConcat:
|
||||
/* !(a <>-> b) == a[]-> !b */
|
||||
result_ = binop::instance(negated_ ?
|
||||
binop::UConcat : binop::EConcat,
|
||||
recurse_(f1, false), recurse(f2));
|
||||
return;
|
||||
case binop::EConcatMarked:
|
||||
/* !(a <>-> b) == a[]-> !b */
|
||||
result_ = binop::instance(negated_ ?
|
||||
binop::UConcat :
|
||||
binop::EConcatMarked,
|
||||
recurse_(f1, false), recurse(f2));
|
||||
return;
|
||||
}
|
||||
/* Unreachable code. */
|
||||
assert(0);
|
||||
}
|
||||
|
||||
void
|
||||
visit(automatop* ao)
|
||||
{
|
||||
bool negated = negated_;
|
||||
negated_ = false;
|
||||
automatop::vec* res = new automatop::vec;
|
||||
unsigned aos = ao->size();
|
||||
for (unsigned i = 0; i < aos; ++i)
|
||||
res->push_back(recurse(ao->nth(i)));
|
||||
result_ = automatop::instance(ao->get_nfa(), res, negated);
|
||||
}
|
||||
|
||||
void
|
||||
visit(multop* mo)
|
||||
{
|
||||
multop::type op = mo->op();
|
||||
/* !(a & b & c) == !a | !b | !c */
|
||||
/* !(a | b | c) == !a & !b & !c */
|
||||
if (negated_)
|
||||
switch (op)
|
||||
{
|
||||
case multop::And:
|
||||
op = multop::Or;
|
||||
break;
|
||||
case multop::Or:
|
||||
op = multop::And;
|
||||
break;
|
||||
case multop::Concat:
|
||||
case multop::Fusion:
|
||||
case multop::AndNLM:
|
||||
break;
|
||||
}
|
||||
multop::vec* res = new multop::vec;
|
||||
unsigned mos = mo->size();
|
||||
switch (op)
|
||||
{
|
||||
case multop::And:
|
||||
case multop::Or:
|
||||
{
|
||||
for (unsigned i = 0; i < mos; ++i)
|
||||
res->push_back(recurse(mo->nth(i)));
|
||||
result_ = multop::instance(op, res);
|
||||
break;
|
||||
}
|
||||
case multop::Concat:
|
||||
case multop::Fusion:
|
||||
case multop::AndNLM:
|
||||
{
|
||||
for (unsigned i = 0; i < mos; ++i)
|
||||
res->push_back(recurse_(mo->nth(i), false));
|
||||
result_ = multop::instance(op, res);
|
||||
assert(!negated_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
formula*
|
||||
recurse_(formula* f, bool negated)
|
||||
{
|
||||
return negative_normal_form(f, negated);
|
||||
}
|
||||
|
||||
formula*
|
||||
recurse(formula* f)
|
||||
{
|
||||
return recurse_(f, negated_);
|
||||
}
|
||||
|
||||
protected:
|
||||
formula* result_;
|
||||
bool negated_;
|
||||
};
|
||||
}
|
||||
|
||||
formula*
|
||||
negative_normal_form(const formula* f, bool negated)
|
||||
{
|
||||
if (!negated && f->is_in_nenoform())
|
||||
return f->clone();
|
||||
negative_normal_form_visitor v(negated);
|
||||
const_cast<formula*>(f)->accept(v);
|
||||
return v.result();
|
||||
|
||||
ltl_simplifier s;
|
||||
return s.negative_normal_form(f, negated);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue