spot
1.0.2
|
Rewrite or simplify f in various ways. More...
#include <ltlvisit/simplify.hh>
Public Member Functions | |
ltl_simplifier (bdd_dict *dict=0) | |
ltl_simplifier (const ltl_simplifier_options &opt, bdd_dict *dict=0) | |
~ltl_simplifier () | |
const formula * | simplify (const formula *f) |
const formula * | negative_normal_form (const formula *f, bool negated=false) |
bool | syntactic_implication (const formula *f, const formula *g) |
Syntactic implication. | |
bool | syntactic_implication_neg (const formula *f, const formula *g, bool right) |
Syntactic implication with one negated argument. | |
bool | are_equivalent (const formula *f, const formula *g) |
check whether two formulae are equivalent. | |
bool | implication (const formula *f, const formula *g) |
Check whether f implies g. | |
bdd | as_bdd (const formula *f) |
Convert a Boolean formula as a BDD. | |
void | clear_as_bdd_cache () |
Clear the as_bdd() cache. | |
bdd_dict * | get_dict () const |
Return the bdd_dict used. | |
const formula * | star_normal_form (const formula *f) |
Cached version of spot::ltl::star_normal_form(). | |
const formula * | boolean_to_isop (const formula *f) |
Rewrite a Boolean formula f into as an irredundant sum of product. | |
void | print_stats (std::ostream &os) const |
Dump statistics about the caches. |
Private Member Functions | |
ltl_simplifier (const ltl_simplifier &) |
Private Attributes | |
ltl_simplifier_cache * | cache_ |
bool | owndict |
Rewrite or simplify f in various ways.
spot::ltl::ltl_simplifier::ltl_simplifier | ( | bdd_dict * | dict = 0 | ) |
spot::ltl::ltl_simplifier::ltl_simplifier | ( | const ltl_simplifier_options & | opt, |
bdd_dict * | dict = 0 |
||
) |
spot::ltl::ltl_simplifier::~ltl_simplifier | ( | ) |
|
private |
check whether two formulae are equivalent.
This costly check performs up to four translations, two products, and two emptiness checks.
bdd spot::ltl::ltl_simplifier::as_bdd | ( | const formula * | f | ) |
Convert a Boolean formula as a BDD.
If you plan to use this method, be sure to pass a bdd_dict to the constructor.
Rewrite a Boolean formula f into as an irredundant sum of product.
This uses a cache, so it is OK to call this with identical arguments.
void spot::ltl::ltl_simplifier::clear_as_bdd_cache | ( | ) |
Clear the as_bdd() cache.
Calling this function is recommended before running other algorithms that create BDD variables in a more natural order. For instance ltl_to_tgba_fm() will usually be more efficient if the BDD variables for atomic propositions have not been ordered before hand.
This also clears the language containment cache.
Check whether f implies g.
This operation is costlier than syntactic_implication() because it requires two translation, one product and one emptiness check.
const formula* spot::ltl::ltl_simplifier::negative_normal_form | ( | const formula * | f, |
bool | negated = false |
||
) |
Build the negative normal form of formula f. All negations of the formula are pushed in front of the atomic propositions. Operators <=>, =>, xor are all removed (calling spot::ltl::unabbreviate_ltl is not needed).
f | The formula to normalize. |
negated | If true , return the negative normal form of !f |
void spot::ltl::ltl_simplifier::print_stats | ( | std::ostream & | os | ) | const |
Dump statistics about the caches.
Simplify the formula f (using options supplied to the constructor).
Cached version of spot::ltl::star_normal_form().
Syntactic implication.
Returns whether \a f syntactically implies \a g. This is adapted from @verbatim
/// { somenzi.00.cav, /// author = {Fabio Somenzi and Roderick Bloem}, /// title = {Efficient {B"u}chi Automata for {LTL} Formulae}, /// booktitle = {Proceedings of the 12th International Conference on /// Computer Aided Verification (CAV'00)}, /// pages = {247–263}, /// year = {2000}, /// volume = {1855}, /// series = {Lecture Notes in Computer Science}, /// publisher = {Springer-Verlag} /// } ///
bool spot::ltl::ltl_simplifier::syntactic_implication_neg | ( | const formula * | f, |
const formula * | g, | ||
bool | right | ||
) |
Syntactic implication with one negated argument.
If right is true, this method returns whether f implies !g. If right is false, this returns whether !g implies g.
|
private |
|
private |