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, 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")
#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()