def __init__(self, env=None, invalidate_memoization=None):
IdentityDagWalker.__init__(
self, env=env, invalidate_memoization=invalidate_memoization)
self.Times = self.env.formula_manager.Times
self.Plus = self.env.formula_manager.Plus
self.rminus_one = self.env.formula_manager.Real(-1)
self.iminus_one = self.env.formula_manager.Int(-1)
self.get_type = self.env.stc.get_type
def __init__(self, env=None, invalidate_memoization=None):
IdentityDagWalker.__init__(self, env=env,
invalidate_memoization=invalidate_memoization)
self.Times = self.env.formula_manager.Times
self.Plus = self.env.formula_manager.Plus
self.rminus_one = self.env.formula_manager.Real(-1)
self.iminus_one = self.env.formula_manager.Int(-1)
self.get_type = self.env.stc.get_type
def bmc_summarize(smtin_filename="UNNAMED_in.smt2",
smtout_filename="UNNAMED_out.smt2"):
parser = SmtLibParser()
with open(smtin_filename, 'r+') as f:
smtlib = parser.get_script(f)
asserts = list(smtlib.filter_by_command_name([smtcmd.ASSERT]))
defs = list(smtlib.filter_by_command_name([smtcmd.DEFINE_FUN]))
decls = list(smtlib.filter_by_command_name([smtcmd.DECLARE_FUN]))
#print(smtlib.get_last_formula())
func_summary = None
for stmt in asserts:
#print(stmt)
if stmt.args[0].is_iff() or stmt.args[0].is_equals():
assert stmt.args[0].arg(0).is_symbol() and stmt.args[0].arg(1)
#print("Assertion on a symbolic equation.")
symbol_table[stmt.args[0].arg(0).symbol_name()] = stmt.args[0].arg(
1)
#pattern match for assertion on summary (PROPERTY: !(... = 0) )
if stmt.args[0].is_not():
safety_prop = stmt.args[0].arg(0)
if (safety_prop.is_equals() or safety_prop.is_iff()
) and safety_prop.arg(1).is_bv_constant(0):
func_summary = safety_prop.arg(0)
summarizer = IdentityDagWalker()
try:
summary = summarizer.walk(func_summary)
except:
print("Could not summarize the summary.")
import pdb
pdb.set_trace() #Exception raised.
#import pdb; pdb.set_trace() #PLAY WITH REPRESENTATION in pdb if desired
#Print to stdout in SMTLib format:
print(";Summary looks like:\n")
print(summary.to_smtlib(False) + "\n")
#Rewrite back into SMTLibScript, then print simplification back to file
newscript = SmtLibScript()
newscript.add(smtcmd.SET_OPTION, [':produce-models', 'true'])
newscript.add(smtcmd.SET_LOGIC, ["QF_AUFBV"])
for decl in decls:
newscript.add_command(decl)
newscript.add(
smtcmd.ASSERT,
[Not(Equals(summary, BVZero(width=32)))
]) #NOTE: need the !(...=0) structure again, for the assertion
newscript.add(smtcmd.CHECK_SAT, [])
newscript.add(smtcmd.EXIT, [])
with open(smtout_filename, 'w+') as f:
newscript.serialize(f, daggify=False)
def __init__(self, environment=None):
IdentityDagWalker.__init__(self, environment)
# funs_to_args keeps for every function symbol f,
# a set of lists of arguments.
# if f(g(x),y) and f(x,g(y)) occur in a formula, then we
# will have "f": set([g(x), y], [x, g(y)])
self._funs_to_args = {}
#maps the actual applications to the constants that will be
#generated, or to the original term if it is not replaced.
self._terms_dict = {}
def __init__(self, environment=None):
IdentityDagWalker.__init__(self, environment)
# funs_to_args keeps for every function symbol f,
# a set of lists of arguments.
# if f(g(x),y) and f(x,g(y)) occur in a formula, then we
# will have "f": set([g(x), y], [x, g(y)])
self._funs_to_args = {}
#maps the actual applications to the constants that will be
#generated, or to the original term if it is not replaced.
self._terms_dict = {}
def __init__(self, env=None, conf):
if env is None:
self.env = get_env()
else:
self.env = env
IdentityDagWalker.__init__(self, env=self.env)
self.mgr = self.env.formula_manager
self.conf = conf
self.symbol_map = dict()
self.fbvand = self.mgr.Symbol(
"fbvand", FunctionType(INT, (INT, INT, INT)))
self.extra_constraints = set()
self.zero = self.mgr.Int(0)
def test_walker_new_operators_complete(self):
walkerA = IdentityDagWalker(env=self.env)
idx = op.new_node_type(node_str="fancy_new_node")
walkerB = IdentityDagWalker(env=self.env)
with self.assertRaises(KeyError):
walkerA.functions[idx]
self.assertEqual(walkerB.functions[idx], walkerB.walk_error)
# Use a mixin to handle the node type
class FancyNewNodeWalkerMixin(object):
def walk_fancy_new_node(self, args, **kwargs):
raise UnsupportedOperatorError
class IdentityDagWalker2(IdentityDagWalker, FancyNewNodeWalkerMixin):
pass
walkerC = IdentityDagWalker2(env=self.env)
self.assertEqual(walkerC.functions[idx], walkerC.walk_fancy_new_node)
def test_identity_walker(self):
def walk_and_to_or(formula, args, **kwargs):
return Or(args)
def walk_or_to_and(formula, args, **kwargs):
return And(args)
walker = IdentityDagWalker(env=get_env())
walker.functions[op.AND] = walk_and_to_or
walker.functions[op.OR] = walk_or_to_and
x, y, z = Symbol('x'), Symbol('y'), Symbol('z')
cnf = And(Or(x, y, z), Or(z, Not(y)))
fake_dnf = Or(And(x, y, z), And(z, Not(y)))
result = walker.walk(cnf)
self.assertEqual(result, fake_dnf)
alternation = Or(cnf, Not(cnf))
expected = And(fake_dnf, Not(fake_dnf))
result = walker.walk(alternation)
self.assertEqual(result, expected)
def test_identity_walker_simple(self):
def walk_and_to_or(formula, args, **kwargs):
return Or(args)
def walk_or_to_and(formula, args, **kwargs):
return And(args)
walker = IdentityDagWalker(env=get_env())
walker.set_function(walk_and_to_or, op.AND)
walker.set_function(walk_or_to_and, op.OR)
x, y, z = Symbol("x"), Symbol("y"), Symbol("z")
cnf = And(Or(x, y, z), Or(z, Not(y)))
fake_dnf = Or(And(x, y, z), And(z, Not(y)))
result = walker.walk(cnf)
self.assertEqual(result, fake_dnf)
alternation = Or(cnf, Not(cnf))
expected = And(fake_dnf, Not(fake_dnf))
result = walker.walk(alternation)
self.assertEqual(result, expected)
return self.mgr.O(args[0])
def walk_ltl_h(self, formula, args, **kwargs):
return self.mgr.H(args[0])
def walk_assign(self, formula, args, **kwargs):
return self.mgr.Assign(args[0], args[1])
def walk_define(self, formula, args, **kwargs):
return self.mgr.Define(args[0], args[1])
IdentityDagWalker.set_handler(walk_ltl_x, LTL_X)
IdentityDagWalker.set_handler(walk_ltl_f, LTL_F)
IdentityDagWalker.set_handler(walk_ltl_g, LTL_G)
IdentityDagWalker.set_handler(walk_ltl_u, LTL_U)
IdentityDagWalker.set_handler(walk_ltl_r, LTL_R)
IdentityDagWalker.set_handler(walk_ltl_o, LTL_O)
IdentityDagWalker.set_handler(walk_ltl_h, LTL_H)
IdentityDagWalker.set_handler(walk_assign, ASSIGN)
IdentityDagWalker.set_handler(walk_define, DEFINE)
def walk_simplify_assign(self, formula, args, **kwargs):
assert len(args) == 2
sl = args[0]
return args[0].set_linear(False)
#updating some walkers with third approach
from pysmt.walkers import IdentityDagWalker
def walk_sin(self, formula, args, **kwargs):
return self.mgr.Sin(args[0])
def walk_cos(self, formula, args, **kwargs):
return self.mgr.Cos(args[0])
IdentityDagWalker.set_handler(walk_sin, SIN)
IdentityDagWalker.set_handler(walk_cos, COS)
from pysmt.smtlib.printers import SmtPrinter
def walk_sin(self, formula):
return self.walk_nary(formula, "sin")
def walk_cos(self, formula):
return self.walk_nary(formula, "cos")
SmtPrinter.set_handler(walk_sin, SIN)
SmtPrinter.set_handler(walk_cos, COS)
def test_identity_dag_walker(self):
idw = IdentityDagWalker()
for (f, _, _, _) in get_example_formulae():
rebuilt = idw.walk(f)
self.assertTrue(rebuilt == f, "Rebuilt formula is not identical")
def test_identity_dag_walker(self):
idw = IdentityDagWalker()
for (f, _, _, _) in get_example_formulae():
rebuilt = idw.walk(f)
self.assertTrue(rebuilt == f, "Rebuilt formula is not identical")
#from pysmt.shortcuts import Iff, Equals, Symbol
from pysmt.shortcuts import Not, Equals, BVZero
from pysmt.shortcuts import get_env, substitute
#This function modifies our IdentityDagWalker to substitute known symbols in summary
symbol_table = {}
def walk_symbol(self, formula, args, **kwargs):
symbol_subs = self.mgr.Symbol(formula.symbol_name(), formula.symbol_type())
if formula.symbol_name() in symbol_table:
symbol_subs = symbol_table[formula.symbol_name()]
return symbol_subs
IdentityDagWalker.set_handler(walk_symbol, SYMBOL)
def bmc_summarize(smtin_filename="UNNAMED_in.smt2",
smtout_filename="UNNAMED_out.smt2"):
parser = SmtLibParser()
with open(smtin_filename, 'r+') as f:
smtlib = parser.get_script(f)
asserts = list(smtlib.filter_by_command_name([smtcmd.ASSERT]))
defs = list(smtlib.filter_by_command_name([smtcmd.DEFINE_FUN]))
decls = list(smtlib.filter_by_command_name([smtcmd.DECLARE_FUN]))
#print(smtlib.get_last_formula())
func_summary = None
return self.mgr.F(args[0])
def walk_ltl_g(self, formula, args, **kwargs):
return self.mgr.G(args[0])
def walk_ltl_o(self, formula, args, **kwargs):
return self.mgr.O(args[0])
def walk_ltl_h(self, formula, args, **kwargs):
return self.mgr.H(args[0])
IdentityDagWalker.set_handler(walk_ltl_x, LTL_X)
IdentityDagWalker.set_handler(walk_ltl_y, LTL_Y)
IdentityDagWalker.set_handler(walk_ltl_u, LTL_U)
IdentityDagWalker.set_handler(walk_ltl_s, LTL_S)
IdentityDagWalker.set_handler(walk_ltl_f, LTL_F)
IdentityDagWalker.set_handler(walk_ltl_g, LTL_G)
IdentityDagWalker.set_handler(walk_ltl_o, LTL_O)
IdentityDagWalker.set_handler(walk_ltl_h, LTL_H)
# EOC IdentityDagWalker
from pysmt.environment import Environment, pop_env, get_env
from pysmt.environment import push_env as pysmt_push_env
class EnvironmentLTL(Environment):
"""Extension of pySMT environment."""
# EOC HRSerialize
# Finally, a third option is to define new methods and attach them to
# existing classes. We do so for the IdentityDagWalker
from pysmt.walkers import IdentityDagWalker
def walk_ltl_x(self, formula, args, **kwargs): return self.mgr.X(args[0])
def walk_ltl_y(self, formula, args, **kwargs): return self.mgr.Y(args[0])
def walk_ltl_u(self, formula, args, **kwargs): return self.mgr.U(args[0], args[1])
def walk_ltl_s(self, formula, args, **kwargs): return self.mgr.S(args[0], args[1])
def walk_ltl_f(self, formula, args, **kwargs): return self.mgr.F(args[0])
def walk_ltl_g(self, formula, args, **kwargs): return self.mgr.G(args[0])
def walk_ltl_o(self, formula, args, **kwargs): return self.mgr.O(args[0])
def walk_ltl_h(self, formula, args, **kwargs): return self.mgr.H(args[0])
IdentityDagWalker.set_handler(walk_ltl_x, LTL_X)
IdentityDagWalker.set_handler(walk_ltl_y, LTL_Y)
IdentityDagWalker.set_handler(walk_ltl_u, LTL_U)
IdentityDagWalker.set_handler(walk_ltl_s, LTL_S)
IdentityDagWalker.set_handler(walk_ltl_f, LTL_F)
IdentityDagWalker.set_handler(walk_ltl_g, LTL_G)
IdentityDagWalker.set_handler(walk_ltl_o, LTL_O)
IdentityDagWalker.set_handler(walk_ltl_h, LTL_H)
# EOC IdentityDagWalker
from pysmt.environment import Environment, pop_env, get_env
from pysmt.environment import push_env as pysmt_push_env
class EnvironmentLTL(Environment):
"""Extension of pySMT environment."""
# Only specify new classes. Classes that have been extended
def __init__(self):
IdentityDagWalker.__init__(self)
self.symbols = set()
