def __init__(self, env=None, invalidate_memoization=None):
DagWalker.__init__(self,
env=env,
invalidate_memoization=invalidate_memoization)
self.mgr = self.env.formula_manager
self.check_symbol = self.mgr.FreshSymbol(types.BOOL)
# The walker returns a pair (L, m) where m is a
# quantifier-free formula (the matrix) and L is a list of
# pairs (Q, vars) where Q is either mgr.Exists or mgr.ForAll
# and vars is a frozenset of variables. The semantics is that
# the input formula is equivalent to res computed as follows:
# res = m
# for Q, vars in L:
# res = Q(vars, res)
self.set_function(self.walk_error, *op.ALL_TYPES)
self.set_function(self.walk_quantifier, *op.QUANTIFIERS)
self.set_function(self.walk_theory_op, *op.THEORY_OPERATORS)
self.set_function(self.walk_constant, *op.CONSTANTS)
self.set_function(self.walk_theory_relation, *op.RELATIONS)
self.set_function(self.walk_symbol, op.SYMBOL)
self.set_function(self.walk_function, op.FUNCTION)
self.set_function(self.walk_ite, op.ITE)
self.set_function(self.walk_conj_disj, op.AND, op.OR)
self.set_function(self.walk_not, op.NOT)
self.set_function(self.walk_iff, op.IFF)
self.set_function(self.walk_implies, op.IMPLIES)
def __init__(self, environment=None):
DagWalker.__init__(self, env=environment)
self.mgr = self.env.formula_manager
self.set_function(self.walk_nop, *op.RELATIONS)
self.set_function(self.walk_nop, *op.THEORY_OPERATORS)
self.set_function(self.walk_nop, *op.CONSTANTS)
self.set_function(self.walk_nop, op.SYMBOL, op.FUNCTION)
self.set_function(self.walk_quantifier, *op.QUANTIFIERS)
def __init__(self, environment=None):
DagWalker.__init__(self, env=environment)
self.mgr = self.env.formula_manager
self.set_function(self.walk_nop, *op.RELATIONS)
self.set_function(self.walk_nop, *op.THEORY_OPERATORS)
self.set_function(self.walk_nop, *op.CONSTANTS)
self.set_function(self.walk_nop, op.SYMBOL, op.FUNCTION)
self.set_function(self.walk_quantifier, *op.QUANTIFIERS)
def __init__(self, stream, template=".def_%d"):
DagWalker.__init__(self, invalidate_memoization=True)
self.stream = stream
self.write = self.stream.write
self.openings = 0
self.name_seed = 0
self.template = template
self.names = None
self.mgr = get_env().formula_manager
def __init__(self, environment, btor):
DagWalker.__init__(self, environment)
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
self._back_memoization = {}
self._btor = btor
self.declared_vars = {}
self.function_declarations = {}
return
def __init__(self, environment, btor):
DagWalker.__init__(self, environment)
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
self._back_memoization = {}
self._btor = btor
self.declared_vars = {}
self.function_declarations = {}
return
def test_undefined_node(self):
varA = Symbol("At", INT)
dag_walker = DagWalker()
with self.assertRaises(NotImplementedError):
dag_walker.walk(varA)
tree_walker = TreeWalker()
with self.assertRaises(NotImplementedError):
tree_walker.walk(varA)
def __init__(self, environment):
DagWalker.__init__(self, environment)
self.backconversion = {}
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
# Maps a Symbol into the corresponding internal yices instance
self.symbol_to_decl = {}
# Maps an internal yices instance into the corresponding symbol
self.decl_to_symbol = {}
def __init__(self, environment):
DagWalker.__init__(self, environment)
self.backconversion = {}
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
# Maps a Symbol into the corresponding internal yices instance
self.symbol_to_decl = {}
# Maps an internal yices instance into the corresponding symbol
self.decl_to_symbol = {}
def test_undefined_node(self):
varA = Symbol("At", INT)
dag_walker = DagWalker()
with self.assertRaises(UnsupportedOperatorError):
dag_walker.walk(varA)
tree_walker = TreeWalker()
with self.assertRaises(UnsupportedOperatorError):
tree_walker.walk(varA)
def test_undefined_node(self):
varA = Symbol("At", INT)
dag_walker = DagWalker()
with self.assertRaises(UnsupportedOperatorError):
dag_walker.walk(varA)
tree_walker = TreeWalker()
with self.assertRaises(UnsupportedOperatorError):
tree_walker.walk(varA)
def __init__(self, stream, template=".def_%d"):
DagWalker.__init__(self, invalidate_memoization=True)
self.stream = stream
self.write = self.stream.write
self.openings = 0
self.name_seed = 0
self.template = template
self.names = None
self.mgr = get_env().formula_manager
self.set_function(partial(self._walk_nary, "and"), op.AND)
self.set_function(partial(self._walk_nary, "or"), op.OR)
self.set_function(partial(self._walk_nary, "not"), op.NOT)
self.set_function(partial(self._walk_nary, "=>"), op.IMPLIES)
self.set_function(partial(self._walk_nary, "="), op.IFF)
self.set_function(partial(self._walk_nary, "+"), op.PLUS)
self.set_function(partial(self._walk_nary, "-"), op.MINUS)
self.set_function(partial(self._walk_nary, "*"), op.TIMES)
self.set_function(partial(self._walk_nary, "pow"), op.POW)
self.set_function(partial(self._walk_nary, "="), op.EQUALS)
self.set_function(partial(self._walk_nary, "<="), op.LE)
self.set_function(partial(self._walk_nary, "<"), op.LT)
self.set_function(partial(self._walk_nary, "ite"), op.ITE)
self.set_function(partial(self._walk_nary, "to_real"), op.TOREAL)
self.set_function(partial(self._walk_nary, "/"), op.DIV)
self.set_function(partial(self._walk_nary, "bvand"), op.BV_AND)
self.set_function(partial(self._walk_nary, "bvor"), op.BV_OR)
self.set_function(partial(self._walk_nary, "bvnot"), op.BV_NOT)
self.set_function(partial(self._walk_nary, "bvxor"), op.BV_XOR)
self.set_function(partial(self._walk_nary, "bvadd"), op.BV_ADD)
self.set_function(partial(self._walk_nary, "bvsub"), op.BV_SUB)
self.set_function(partial(self._walk_nary, "bvneg"), op.BV_NEG)
self.set_function(partial(self._walk_nary, "bvmul"), op.BV_MUL)
self.set_function(partial(self._walk_nary, "bvudiv"), op.BV_UDIV)
self.set_function(partial(self._walk_nary, "bvurem"), op.BV_UREM)
self.set_function(partial(self._walk_nary, "bvshl"), op.BV_LSHL)
self.set_function(partial(self._walk_nary, "bvlshr"), op.BV_LSHR)
self.set_function(partial(self._walk_nary, "bvult"), op.BV_ULT)
self.set_function(partial(self._walk_nary, "bvule"), op.BV_ULE)
self.set_function(partial(self._walk_nary, "bvslt"), op.BV_SLT)
self.set_function(partial(self._walk_nary, "bvsle"), op.BV_SLE)
self.set_function(partial(self._walk_nary, "concat"), op.BV_CONCAT)
self.set_function(partial(self._walk_nary, "bvcomp"), op.BV_COMP)
self.set_function(partial(self._walk_nary, "bvashr"), op.BV_ASHR)
self.set_function(partial(self._walk_nary, "bvsdiv"), op.BV_SDIV)
self.set_function(partial(self._walk_nary, "bvsrem"), op.BV_SREM)
self.set_function(self.walk_bv_extract, op.BV_EXTRACT)
self.set_function(self.walk_bv_rotate, op.BV_ROR)
self.set_function(self.walk_bv_rotate, op.BV_ROL)
self.set_function(self.walk_bv_extend, op.BV_SEXT)
self.set_function(self.walk_bv_extend, op.BV_ZEXT)
self.set_function(partial(self._walk_nary, "select"), op.ARRAY_SELECT)
self.set_function(partial(self._walk_nary, "store"), op.ARRAY_STORE)
def __init__(self, environment, solver, mgr):
DagWalker.__init__(self, environment)
self.solver = solver
self.make_term = solver.make_term
self.make_symbol = solver.make_symbol
self.make_sort = solver.make_sort
self.declared_funs = fs = {}
self.declared_vars = vs = {}
self.declared_syms = ChainMap(vs, fs)
self.declared_sorts = {}
self.back_walker = BackVisitor(mgr)
def __init__(self, environment, ddmanager):
DagWalker.__init__(self)
self.environment = environment
self.fmgr = self.environment.formula_manager
self.ddmanager = ddmanager
# Note: Nodes in pycudd are not shared, but they overload all
# methods to perform comparison. This means that for two
# wrappers for the variable x, we have that id(x) != id(x1)
# but x == x1. Nevertheless, we need to store the ids, since
# nodes can be moved during operations by the
# ddManager. Therefore, when using nodes in a map, we should
# use the ids.
self.idx2var = {}
self.var2node = {}
def _push_with_children_to_stack(self, formula, **kwargs):
"""Add children to the stack."""
# Deal with quantifiers
if formula.is_quantifier():
# 1. We invoke the relevant function (walk_exists or
# walk_forall) to print the formula
fun = self.functions[formula.node_type()]
res = fun(formula, args=None, **kwargs)
# 2. We memoize the result
key = self._get_key(formula, **kwargs)
self.memoization[key] = res
else:
DagWalker._push_with_children_to_stack(self, formula, **kwargs)
def _push_with_children_to_stack(self, formula, **kwargs):
"""Add children to the stack."""
# Deal with quantifiers
if formula.is_quantifier():
# 1. We invoke the relevant function (walk_exists or
# walk_forall) to print the formula
fun = self.functions[formula.node_type()]
res = fun(formula, args=None, **kwargs)
# 2. We memoize the result
key = self._get_key(formula, **kwargs)
self.memoization[key] = res
else:
DagWalker._push_with_children_to_stack(self, formula, **kwargs)
def __init__(self, env, short_names=True):
DagWalker.__init__(self, env, None)
self.short_names = short_names
self.symb_map = {}
self.reverse_map = {}
self.counter = 0
self.def_counter = 0
# Map from formulas to define
# We explore and build the DAG of the formula
self.defines = {}
self.mgr = self.env.formula_manager
def __init__(self, environment, cvc4_exprMgr):
DagWalker.__init__(self, environment)
self.cvc4_exprMgr = cvc4_exprMgr
self.mkExpr = cvc4_exprMgr.mkExpr
self.mkConst = cvc4_exprMgr.mkConst
self.mkVar = cvc4_exprMgr.mkVar
self.realType = cvc4_exprMgr.realType()
self.intType = cvc4_exprMgr.integerType()
self.boolType = cvc4_exprMgr.booleanType()
self.declared_vars = {}
self.backconversion = {}
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
return
def __init__(self, environment, ddmanager):
DagWalker.__init__(self)
self.environment = environment
self.fmgr = self.environment.formula_manager
self.ddmanager = ddmanager
# Note: Nodes in repycudd are not shared, but they overload all
# methods to perform comparison. This means that for two
# wrappers for the variable x, we have that id(x) != id(x1)
# but x == x1. Nevertheless, we need to store the ids, since
# nodes can be moved during operations by the
# ddManager. Therefore, when using nodes in a map, we should
# use the ids.
self.idx2var = {}
self.var2node = {}
self.back_memoization = {}
def __init__(self, environment, cvc4_exprMgr):
DagWalker.__init__(self, environment)
self.cvc4_exprMgr = cvc4_exprMgr
self.mkExpr = cvc4_exprMgr.mkExpr
self.mkConst = cvc4_exprMgr.mkConst
self.mkVar = cvc4_exprMgr.mkVar
self.realType = cvc4_exprMgr.realType()
self.intType = cvc4_exprMgr.integerType()
self.boolType = cvc4_exprMgr.booleanType()
self.declared_vars = {}
self.backconversion = {}
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
return
def __init__(self, environment):
DagWalker.__init__(self, environment)
self.backconversion = {}
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
# self.qelim = QuantifierEliminator(name="z3")
self.qelim = QuantifierEliminator(name="scalarshannon")
self.cache_qf = {}
# Maps a Symbol into the corresponding internal yices instance
self.symbol_to_decl = {}
# Maps an internal yices instance into the corresponding symbol
self.decl_to_symbol = {}
self._yicesSort = {}
self._yicesEnumSort = {}
self._yicesEnumConsts = {}
self._yices2pysmt = {}
def test_walk_error(self):
"""All walk methods by default call walk_error."""
from pysmt.walkers import DagWalker
x = Symbol("x")
w = DagWalker()
for o in op.ALL_TYPES:
with self.assertRaises(UnsupportedOperatorError):
w.functions[o](x)
def __init__(self, environment, msat_env):
DagWalker.__init__(self, environment)
self.msat_env = msat_env
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
# Maps a Symbol into the corresponding msat_decl instance in the msat_env
self.symbol_to_decl = {}
# Maps a msat_decl instance inside the msat_env into the corresponding
# Symbol
self.decl_to_symbol = {}
self.boolType = mathsat.msat_get_bool_type(self.msat_env)
self.realType = mathsat.msat_get_rational_type(self.msat_env)
self.intType = mathsat.msat_get_integer_type(self.msat_env)
self.back_memoization = {}
return
def __init__(self, environment, msat_env):
DagWalker.__init__(self, environment)
self.msat_env = msat_env
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
# Maps a Symbol into the corresponding msat_decl instance in the msat_env
self.symbol_to_decl = {}
# Maps a msat_decl instance inside the msat_env into the corresponding
# Symbol
self.decl_to_symbol = {}
self.boolType = mathsat.msat_get_bool_type(self.msat_env)
self.realType = mathsat.msat_get_rational_type(self.msat_env)
self.intType = mathsat.msat_get_integer_type(self.msat_env)
self.back_memoization = {}
return
def __init__(self, environment=None):
DagWalker.__init__(self, environment)
self.set_function(self.walk_error, *op.ALL_TYPES)
self.set_function(self.walk_quantifier, *op.QUANTIFIERS)
self.set_function(self.walk_constant, *op.CONSTANTS)
self.set_function(self.walk_theory_op, *op.THEORY_OPERATORS)
self.set_function(self.walk_theory_relation, *op.RELATIONS)
self.set_function(self.walk_and, op.AND)
self.set_function(self.walk_or, op.OR)
self.set_function(self.walk_not, op.NOT)
self.set_function(self.walk_implies, op.IMPLIES)
self.set_function(self.walk_iff, op.IFF)
self.set_function(self.walk_symbol, op.SYMBOL)
self.set_function(self.walk_function, op.FUNCTION)
self.set_function(self.walk_ite, op.ITE)
self.mgr = self.env.formula_manager
self._introduced_variables = {}
self._cnf_pieces = {}
def __init__(self, environment=None):
DagWalker.__init__(self, environment)
self.set_function(self.walk_error, *op.ALL_TYPES)
self.set_function(self.walk_quantifier, *op.QUANTIFIERS)
self.set_function(self.walk_constant, *op.CONSTANTS)
self.set_function(self.walk_theory_op, *op.THEORY_OPERATORS)
self.set_function(self.walk_theory_relation, *op.RELATIONS)
self.set_function(self.walk_and, op.AND)
self.set_function(self.walk_or, op.OR)
self.set_function(self.walk_not, op.NOT)
self.set_function(self.walk_implies, op.IMPLIES)
self.set_function(self.walk_iff, op.IFF)
self.set_function(self.walk_symbol, op.SYMBOL)
self.set_function(self.walk_function, op.FUNCTION)
self.set_function(self.walk_ite, op.ITE)
self.mgr = self.env.formula_manager
self._introduced_variables = {}
self._cnf_pieces = {}
def __init__(self, environment, cvc4_exprMgr):
DagWalker.__init__(self, environment)
self.cvc4_exprMgr = cvc4_exprMgr
self.mkExpr = cvc4_exprMgr.mkExpr
self.mkConst = cvc4_exprMgr.mkConst
self.mkVar = cvc4_exprMgr.mkVar
self.realType = cvc4_exprMgr.realType()
self.intType = cvc4_exprMgr.integerType()
self.boolType = cvc4_exprMgr.booleanType()
self.stringType = cvc4_exprMgr.stringType()
self._cvc4Sorts = {}
self._cvc4EnumSorts = {}
self._cvc4EnumConsts = {}
self.declared_vars = {}
self.backconversion = {}
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
self.qelim = QuantifierEliminator(name="scalarshannon")
self.cache_qf = {}
return
def __init__(self, environment=None):
DagWalker.__init__(self, environment)
self.mgr = self.env.formula_manager
self._introduced_variables = {}
self._cnf_pieces = {}
def __init__(self, environment=None):
DagWalker.__init__(self, env=environment)
self.mgr = self.env.formula_manager
self.set_function(self.walk_constant, *op.CONSTANTS)
self.set_function(self.walk_theory_op, *op.THEORY_OPERATORS)
self.set_function(self.walk_theory_relation, *op.RELATIONS)
def __init__(self, environment=None):
DagWalker.__init__(self)
self.env = environment if environment else shortcuts.get_env()
self.mgr = self.env.formula_manager
self._introduced_variables = {}
self._cnf_pieces = {}
def __init__(self):
DagWalker.__init__(self)
def __init__(self, environment, z3_ctx):
DagWalker.__init__(self, environment)
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
self._back_memoization = {}
self.ctx = z3_ctx
# Back Conversion
self._back_fun = {
z3.Z3_OP_AND:
lambda args, expr: self.mgr.And(args),
z3.Z3_OP_OR:
lambda args, expr: self.mgr.Or(args),
z3.Z3_OP_MUL:
lambda args, expr: self.mgr.Times(args),
z3.Z3_OP_ADD:
lambda args, expr: self.mgr.Plus(args),
z3.Z3_OP_DIV:
lambda args, expr: self.mgr.Div(args[0], args[1]),
z3.Z3_OP_IDIV:
lambda args, expr: self.mgr.Div(args[0], args[1]),
z3.Z3_OP_MOD:
lambda args, expr: self.mgr.Mod(args[0], args[1]),
z3.Z3_OP_IFF:
lambda args, expr: self.mgr.Iff(args[0], args[1]),
z3.Z3_OP_XOR:
lambda args, expr: self.mgr.Xor(args[0], args[1]),
z3.Z3_OP_FALSE:
lambda args, expr: self.mgr.FALSE(),
z3.Z3_OP_TRUE:
lambda args, expr: self.mgr.TRUE(),
z3.Z3_OP_GT:
lambda args, expr: self.mgr.GT(args[0], args[1]),
z3.Z3_OP_GE:
lambda args, expr: self.mgr.GE(args[0], args[1]),
z3.Z3_OP_LT:
lambda args, expr: self.mgr.LT(args[0], args[1]),
z3.Z3_OP_LE:
lambda args, expr: self.mgr.LE(args[0], args[1]),
z3.Z3_OP_SUB:
lambda args, expr: self.mgr.Minus(args[0], args[1]),
z3.Z3_OP_NOT:
lambda args, expr: self.mgr.Not(args[0]),
z3.Z3_OP_IMPLIES:
lambda args, expr: self.mgr.Implies(args[0], args[1]),
z3.Z3_OP_ITE:
lambda args, expr: self.mgr.Ite(args[0], args[1], args[2]),
z3.Z3_OP_TO_REAL:
lambda args, expr: self.mgr.ToReal(args[0]),
z3.Z3_OP_BAND:
lambda args, expr: self.mgr.BVAnd(args[0], args[1]),
z3.Z3_OP_BOR:
lambda args, expr: self.mgr.BVOr(args[0], args[1]),
z3.Z3_OP_BXOR:
lambda args, expr: self.mgr.BVXor(args[0], args[1]),
z3.Z3_OP_BNOT:
lambda args, expr: self.mgr.BVNot(args[0]),
z3.Z3_OP_BNEG:
lambda args, expr: self.mgr.BVNeg(args[0]),
z3.Z3_OP_CONCAT:
lambda args, expr: self.mgr.BVConcat(args[0], args[1]),
z3.Z3_OP_ULT:
lambda args, expr: self.mgr.BVULT(args[0], args[1]),
z3.Z3_OP_ULEQ:
lambda args, expr: self.mgr.BVULE(args[0], args[1]),
z3.Z3_OP_SLT:
lambda args, expr: self.mgr.BVSLT(args[0], args[1]),
z3.Z3_OP_SLEQ:
lambda args, expr: self.mgr.BVSLE(args[0], args[1]),
z3.Z3_OP_UGT:
lambda args, expr: self.mgr.BVUGT(args[0], args[1]),
z3.Z3_OP_UGEQ:
lambda args, expr: self.mgr.BVUGE(args[0], args[1]),
z3.Z3_OP_SGT:
lambda args, expr: self.mgr.BVSGT(args[0], args[1]),
z3.Z3_OP_SGEQ:
lambda args, expr: self.mgr.BVSGE(args[0], args[1]),
z3.Z3_OP_BADD:
lambda args, expr: self.mgr.BVAdd(args[0], args[1]),
z3.Z3_OP_BMUL:
lambda args, expr: self.mgr.BVMul(args[0], args[1]),
z3.Z3_OP_BUDIV:
lambda args, expr: self.mgr.BVUDiv(args[0], args[1]),
z3.Z3_OP_BSDIV:
lambda args, expr: self.mgr.BVSDiv(args[0], args[1]),
z3.Z3_OP_BUREM:
lambda args, expr: self.mgr.BVURem(args[0], args[1]),
z3.Z3_OP_BSREM:
lambda args, expr: self.mgr.BVSRem(args[0], args[1]),
z3.Z3_OP_BSHL:
lambda args, expr: self.mgr.BVLShl(args[0], args[1]),
z3.Z3_OP_BLSHR:
lambda args, expr: self.mgr.BVLShr(args[0], args[1]),
z3.Z3_OP_BASHR:
lambda args, expr: self.mgr.BVAShr(args[0], args[1]),
z3.Z3_OP_BSUB:
lambda args, expr: self.mgr.BVSub(args[0], args[1]),
z3.Z3_OP_EXT_ROTATE_LEFT:
lambda args, expr: self.mgr.BVRol(args[0], args[1].
bv_unsigned_value()),
z3.Z3_OP_EXT_ROTATE_RIGHT:
lambda args, expr: self.mgr.BVRor(args[0], args[1].
bv_unsigned_value()),
z3.Z3_OP_BV2INT:
lambda args, expr: self.mgr.BVToNatural(args[0]),
z3.Z3_OP_POWER:
lambda args, expr: self.mgr.Pow(args[0], args[1]),
z3.Z3_OP_SELECT:
lambda args, expr: self.mgr.Select(args[0], args[1]),
z3.Z3_OP_STORE:
lambda args, expr: self.mgr.Store(args[0], args[1], args[2]),
# Actually use both args, expr
z3.Z3_OP_SIGN_EXT:
lambda args, expr: self.mgr.BVSExt(args[0], z3.get_payload(
expr, 0)),
z3.Z3_OP_ZERO_EXT:
lambda args, expr: self.mgr.BVZExt(args[0], z3.get_payload(
expr, 0)),
z3.Z3_OP_ROTATE_LEFT:
lambda args, expr: self.mgr.BVRol(args[0], z3.get_payload(expr, 0)
),
z3.Z3_OP_ROTATE_RIGHT:
lambda args, expr: self.mgr.BVRor(args[0], z3.get_payload(expr, 0)
),
z3.Z3_OP_EXTRACT:
lambda args, expr: self.mgr.BVExtract(args[
0], z3.get_payload(expr, 1), z3.get_payload(expr, 0)),
# Complex Back Translation
z3.Z3_OP_EQ:
self._back_z3_eq,
z3.Z3_OP_UMINUS:
self._back_z3_uminus,
z3.Z3_OP_CONST_ARRAY:
self._back_z3_const_array,
}
# Unique reference to Sorts
self.z3RealSort = z3.RealSort(self.ctx)
self.z3BoolSort = z3.BoolSort(self.ctx)
self.z3IntSort = z3.IntSort(self.ctx)
self._z3ArraySorts = {}
self._z3BitVecSorts = {}
self._z3Sorts = {}
# Unique reference to Function Declaration
self._z3_func_decl_cache = {}
return
def __init__(self, environment=None):
DagWalker.__init__(self, env=environment)
self.mgr = self.env.formula_manager
self.set_function(self.walk_constant, *op.CONSTANTS)
self.set_function(self.walk_theory_op, *op.THEORY_OPERATORS)
self.set_function(self.walk_theory_relation, *op.RELATIONS)
def __init__(self, environment, z3_ctx):
DagWalker.__init__(self, environment)
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
self._back_memoization = {}
self.ctx = z3_ctx
# Back Conversion
self._back_fun = {
z3.Z3_OP_AND: lambda args, expr: self.mgr.And(args),
z3.Z3_OP_OR: lambda args, expr: self.mgr.Or(args),
z3.Z3_OP_MUL: lambda args, expr: self.mgr.Times(args),
z3.Z3_OP_ADD: lambda args, expr: self.mgr.Plus(args),
z3.Z3_OP_DIV: lambda args, expr: self.mgr.Div(args[0], args[1]),
z3.Z3_OP_IFF: lambda args, expr: self.mgr.Iff(args[0], args[1]),
z3.Z3_OP_XOR: lambda args, expr: self.mgr.Xor(args[0], args[1]),
z3.Z3_OP_FALSE: lambda args, expr: self.mgr.FALSE(),
z3.Z3_OP_TRUE: lambda args, expr: self.mgr.TRUE(),
z3.Z3_OP_GT: lambda args, expr: self.mgr.GT(args[0], args[1]),
z3.Z3_OP_GE: lambda args, expr: self.mgr.GE(args[0], args[1]),
z3.Z3_OP_LT: lambda args, expr: self.mgr.LT(args[0], args[1]),
z3.Z3_OP_LE: lambda args, expr: self.mgr.LE(args[0], args[1]),
z3.Z3_OP_SUB: lambda args, expr: self.mgr.Minus(args[0], args[1]),
z3.Z3_OP_NOT: lambda args, expr: self.mgr.Not(args[0]),
z3.Z3_OP_IMPLIES: lambda args, expr: self.mgr.Implies(args[0], args[1]),
z3.Z3_OP_ITE: lambda args, expr: self.mgr.Ite(args[0], args[1], args[2]),
z3.Z3_OP_TO_REAL: lambda args, expr: self.mgr.ToReal(args[0]),
z3.Z3_OP_BAND : lambda args, expr: self.mgr.BVAnd(args[0], args[1]),
z3.Z3_OP_BOR : lambda args, expr: self.mgr.BVOr(args[0], args[1]),
z3.Z3_OP_BXOR : lambda args, expr: self.mgr.BVXor(args[0], args[1]),
z3.Z3_OP_BNOT : lambda args, expr: self.mgr.BVNot(args[0]),
z3.Z3_OP_BNEG : lambda args, expr: self.mgr.BVNeg(args[0]),
z3.Z3_OP_CONCAT : lambda args, expr: self.mgr.BVConcat(args[0], args[1]),
z3.Z3_OP_ULT : lambda args, expr: self.mgr.BVULT(args[0], args[1]),
z3.Z3_OP_ULEQ : lambda args, expr: self.mgr.BVULE(args[0], args[1]),
z3.Z3_OP_SLT : lambda args, expr: self.mgr.BVSLT(args[0], args[1]),
z3.Z3_OP_SLEQ : lambda args, expr: self.mgr.BVSLE(args[0], args[1]),
z3.Z3_OP_UGT : lambda args, expr: self.mgr.BVUGT(args[0], args[1]),
z3.Z3_OP_UGEQ : lambda args, expr: self.mgr.BVUGE(args[0], args[1]),
z3.Z3_OP_SGT : lambda args, expr: self.mgr.BVSGT(args[0], args[1]),
z3.Z3_OP_SGEQ : lambda args, expr: self.mgr.BVSGE(args[0], args[1]),
z3.Z3_OP_BADD : lambda args, expr: self.mgr.BVAdd(args[0], args[1]),
z3.Z3_OP_BMUL : lambda args, expr: self.mgr.BVMul(args[0], args[1]),
z3.Z3_OP_BUDIV : lambda args, expr: self.mgr.BVUDiv(args[0], args[1]),
z3.Z3_OP_BSDIV : lambda args, expr: self.mgr.BVSDiv(args[0], args[1]),
z3.Z3_OP_BUREM : lambda args, expr: self.mgr.BVURem(args[0], args[1]),
z3.Z3_OP_BSREM : lambda args, expr: self.mgr.BVSRem(args[0], args[1]),
z3.Z3_OP_BSHL : lambda args, expr: self.mgr.BVLShl(args[0], args[1]),
z3.Z3_OP_BLSHR : lambda args, expr: self.mgr.BVLShr(args[0], args[1]),
z3.Z3_OP_BASHR : lambda args, expr: self.mgr.BVAShr(args[0], args[1]),
z3.Z3_OP_BSUB : lambda args, expr: self.mgr.BVSub(args[0], args[1]),
z3.Z3_OP_EXT_ROTATE_LEFT : lambda args, expr: self.mgr.BVRol(args[0], args[1].bv_unsigned_value()),
z3.Z3_OP_EXT_ROTATE_RIGHT: lambda args, expr: self.mgr.BVRor(args[0], args[1].bv_unsigned_value()),
z3.Z3_OP_BV2INT: lambda args, expr: self.mgr.BVToNatural(args[0]),
z3.Z3_OP_POWER : lambda args, expr: self.mgr.Pow(args[0], args[1]),
z3.Z3_OP_SELECT : lambda args, expr: self.mgr.Select(args[0], args[1]),
z3.Z3_OP_STORE : lambda args, expr: self.mgr.Store(args[0], args[1], args[2]),
# Actually use both args, expr
z3.Z3_OP_SIGN_EXT: lambda args, expr: self.mgr.BVSExt(args[0], z3.get_payload(expr, 0)),
z3.Z3_OP_ZERO_EXT: lambda args, expr: self.mgr.BVZExt(args[0], z3.get_payload(expr, 0)),
z3.Z3_OP_ROTATE_LEFT: lambda args, expr: self.mgr.BVRol(args[0], z3.get_payload(expr, 0)),
z3.Z3_OP_ROTATE_RIGHT: lambda args, expr: self.mgr.BVRor(args[0], z3.get_payload(expr, 0)),
z3.Z3_OP_EXTRACT: lambda args, expr: self.mgr.BVExtract(args[0],
z3.get_payload(expr, 1),
z3.get_payload(expr, 0)),
# Complex Back Translation
z3.Z3_OP_EQ : self._back_z3_eq,
z3.Z3_OP_UMINUS : self._back_z3_uminus,
z3.Z3_OP_CONST_ARRAY : self._back_z3_const_array,
}
# Unique reference to Sorts
self.z3RealSort = z3.RealSort(self.ctx)
self.z3BoolSort = z3.BoolSort(self.ctx)
self.z3IntSort = z3.IntSort(self.ctx)
self._z3ArraySorts = {}
self._z3BitVecSorts = {}
self._z3Sorts = {}
# Unique reference to Function Declaration
self._z3_func_decl_cache = {}
return
def __init__(self, environment=None):
DagWalker.__init__(self, env=environment)
self.mgr = self.env.formula_manager
def __init__(self, env=None, invalidate_memoization=None):
DagWalker.__init__(self,
env=env,
invalidate_memoization=invalidate_memoization)
self.mgr = self.env.formula_manager
self.check_symbol = self.mgr.FreshSymbol(types.BOOL)
def __init__(self, environment=None):
DagWalker.__init__(self, environment)
self.mgr = self.env.formula_manager
self._introduced_variables = {}
self._cnf_pieces = {}
def __init__(self, environment, z3_ctx):
DagWalker.__init__(self, environment)
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
self._back_memoization = {}
self.ctx = z3_ctx
# Forward conversion
self.set_function(p_(self.walk_nary, z3.Z3_mk_and), op.AND)
self.set_function(p_(self.walk_nary, z3.Z3_mk_or), op.OR)
self.set_function(p_(self.walk_nary, z3.Z3_mk_add), op.PLUS)
self.set_function(p_(self.walk_nary, z3.Z3_mk_mul), op.TIMES)
self.set_function(p_(self.walk_nary, z3.Z3_mk_sub), op.MINUS)
self.set_function(p_(self.walk_binary, z3.Z3_mk_implies), op.IMPLIES)
self.set_function(p_(self.walk_binary, z3.Z3_mk_le), op.LE)
self.set_function(p_(self.walk_binary, z3.Z3_mk_lt), op.LT)
self.set_function(p_(self.walk_binary, z3.Z3_mk_eq), op.EQUALS, op.IFF)
self.set_function(p_(self.walk_binary, z3.Z3_mk_power), op.POW)
self.set_function(p_(self.walk_binary, z3.Z3_mk_div), op.DIV)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvult), op.BV_ULT)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvule), op.BV_ULE)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvslt), op.BV_SLT)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvsle), op.BV_SLE)
self.set_function(p_(self.walk_binary, z3.Z3_mk_concat), op.BV_CONCAT)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvor), op.BV_OR)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvand), op.BV_AND)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvxor), op.BV_XOR)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvadd), op.BV_ADD)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvsub), op.BV_SUB)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvmul), op.BV_MUL)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvudiv), op.BV_UDIV)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvurem), op.BV_UREM)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvshl), op.BV_LSHL)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvlshr), op.BV_LSHR)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvsdiv), op.BV_SDIV)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvsrem), op.BV_SREM)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvashr), op.BV_ASHR)
self.set_function(self.walk_quantifier, *op.QUANTIFIERS)
# Back Conversion
self._back_fun = {
z3.Z3_OP_AND:
lambda args, expr: self.mgr.And(args),
z3.Z3_OP_OR:
lambda args, expr: self.mgr.Or(args),
z3.Z3_OP_MUL:
lambda args, expr: self.mgr.Times(args),
z3.Z3_OP_ADD:
lambda args, expr: self.mgr.Plus(args),
z3.Z3_OP_DIV:
lambda args, expr: self.mgr.Div(args[0], args[1]),
z3.Z3_OP_IFF:
lambda args, expr: self.mgr.Iff(args[0], args[1]),
z3.Z3_OP_XOR:
lambda args, expr: self.mgr.Xor(args[0], args[1]),
z3.Z3_OP_FALSE:
lambda args, expr: self.mgr.FALSE(),
z3.Z3_OP_TRUE:
lambda args, expr: self.mgr.TRUE(),
z3.Z3_OP_GT:
lambda args, expr: self.mgr.GT(args[0], args[1]),
z3.Z3_OP_GE:
lambda args, expr: self.mgr.GE(args[0], args[1]),
z3.Z3_OP_LT:
lambda args, expr: self.mgr.LT(args[0], args[1]),
z3.Z3_OP_LE:
lambda args, expr: self.mgr.LE(args[0], args[1]),
z3.Z3_OP_SUB:
lambda args, expr: self.mgr.Minus(args[0], args[1]),
z3.Z3_OP_NOT:
lambda args, expr: self.mgr.Not(args[0]),
z3.Z3_OP_IMPLIES:
lambda args, expr: self.mgr.Implies(args[0], args[1]),
z3.Z3_OP_ITE:
lambda args, expr: self.mgr.Ite(args[0], args[1], args[2]),
z3.Z3_OP_TO_REAL:
lambda args, expr: self.mgr.ToReal(args[0]),
z3.Z3_OP_BAND:
lambda args, expr: self.mgr.BVAnd(args[0], args[1]),
z3.Z3_OP_BOR:
lambda args, expr: self.mgr.BVOr(args[0], args[1]),
z3.Z3_OP_BXOR:
lambda args, expr: self.mgr.BVXor(args[0], args[1]),
z3.Z3_OP_BNOT:
lambda args, expr: self.mgr.BVNot(args[0]),
z3.Z3_OP_BNEG:
lambda args, expr: self.mgr.BVNeg(args[0]),
z3.Z3_OP_CONCAT:
lambda args, expr: self.mgr.BVConcat(args[0], args[1]),
z3.Z3_OP_ULT:
lambda args, expr: self.mgr.BVULT(args[0], args[1]),
z3.Z3_OP_ULEQ:
lambda args, expr: self.mgr.BVULE(args[0], args[1]),
z3.Z3_OP_SLT:
lambda args, expr: self.mgr.BVSLT(args[0], args[1]),
z3.Z3_OP_SLEQ:
lambda args, expr: self.mgr.BVSLE(args[0], args[1]),
z3.Z3_OP_UGT:
lambda args, expr: self.mgr.BVUGT(args[0], args[1]),
z3.Z3_OP_UGEQ:
lambda args, expr: self.mgr.BVUGE(args[0], args[1]),
z3.Z3_OP_SGT:
lambda args, expr: self.mgr.BVSGT(args[0], args[1]),
z3.Z3_OP_SGEQ:
lambda args, expr: self.mgr.BVSGE(args[0], args[1]),
z3.Z3_OP_BADD:
lambda args, expr: self.mgr.BVAdd(args[0], args[1]),
z3.Z3_OP_BMUL:
lambda args, expr: self.mgr.BVMul(args[0], args[1]),
z3.Z3_OP_BUDIV:
lambda args, expr: self.mgr.BVUDiv(args[0], args[1]),
z3.Z3_OP_BSDIV:
lambda args, expr: self.mgr.BVSDiv(args[0], args[1]),
z3.Z3_OP_BUREM:
lambda args, expr: self.mgr.BVURem(args[0], args[1]),
z3.Z3_OP_BSREM:
lambda args, expr: self.mgr.BVSRem(args[0], args[1]),
z3.Z3_OP_BSHL:
lambda args, expr: self.mgr.BVLShl(args[0], args[1]),
z3.Z3_OP_BLSHR:
lambda args, expr: self.mgr.BVLShr(args[0], args[1]),
z3.Z3_OP_BASHR:
lambda args, expr: self.mgr.BVAShr(args[0], args[1]),
z3.Z3_OP_BSUB:
lambda args, expr: self.mgr.BVSub(args[0], args[1]),
z3.Z3_OP_EXT_ROTATE_LEFT:
lambda args, expr: self.mgr.BVRol(args[0], args[1].
bv_unsigned_value()),
z3.Z3_OP_EXT_ROTATE_RIGHT:
lambda args, expr: self.mgr.BVRor(args[0], args[1].
bv_unsigned_value()),
z3.Z3_OP_POWER:
lambda args, expr: self.mgr.Pow(args[0], args[1]),
z3.Z3_OP_SELECT:
lambda args, expr: self.mgr.Select(args[0], args[1]),
z3.Z3_OP_STORE:
lambda args, expr: self.mgr.Store(args[0], args[1], args[2]),
# Actually use both args, expr
z3.Z3_OP_SIGN_EXT:
lambda args, expr: self.mgr.BVSExt(args[0], z3.get_payload(
expr, 0)),
z3.Z3_OP_ZERO_EXT:
lambda args, expr: self.mgr.BVZExt(args[0], z3.get_payload(
expr, 0)),
z3.Z3_OP_ROTATE_LEFT:
lambda args, expr: self.mgr.BVRol(args[0], z3.get_payload(expr, 0)
),
z3.Z3_OP_ROTATE_RIGHT:
lambda args, expr: self.mgr.BVRor(args[0], z3.get_payload(expr, 0)
),
z3.Z3_OP_EXTRACT:
lambda args, expr: self.mgr.BVExtract(args[
0], z3.get_payload(expr, 1), z3.get_payload(expr, 0)),
# Complex Back Translation
z3.Z3_OP_EQ:
self._back_z3_eq,
z3.Z3_OP_UMINUS:
self._back_z3_uminus,
z3.Z3_OP_CONST_ARRAY:
self._back_z3_const_array,
}
# Unique reference to Sorts
self.z3RealSort = z3.RealSort(self.ctx)
self.z3BoolSort = z3.BoolSort(self.ctx)
self.z3IntSort = z3.IntSort(self.ctx)
self.z3ArraySorts = {}
self._z3BitVecSorts = {}
# Unique reference to Function Declaration
self._z3_func_decl_cache = {}
return
def __init__(self, env=None, invalidate_memoization=None):
DagWalker.__init__(self,
env=env,
invalidate_memoization=invalidate_memoization)
self.mgr = self.env.formula_manager
self.check_symbol = self.mgr.FreshSymbol(types.BOOL)
def __init__(self, environment=None):
DagWalker.__init__(self, env=environment)
self.mgr = self.env.formula_manager
"""
(set-logic QF_LIA)
(declare-const p Int)
(declare-const q Int)
(declare-const x Bool)
(declare-const z Bool)
(define-fun .def_1 () Bool (! (and x z) :cost 1))
(assert (=> x (> p q)))
(check-sat)
(push)
(assert (=> z (> q p)))
(check-sat)
(assert .def_1)
(check-sat)
(pop)
(check-sat)
"""
parser = SmtLibParser()
script = parser.get_script(cStringIO(DEMO_SMTLIB))
buf_out = cStringIO()
f = DagWalker()
for cmd in script:
if cmd.name != "define-fun":
continue
for args in cmd.args:
if isinstance(args, pysmt.fnode.FNode):
print(args)
print(f.iter_walk(args))
def __init__(self, environment, z3_ctx):
DagWalker.__init__(self, environment)
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
self._back_memoization = {}
self.ctx = z3_ctx
# Forward conversion
self.set_function(p_(self.walk_nary, z3.Z3_mk_and), op.AND)
self.set_function(p_(self.walk_nary, z3.Z3_mk_or), op.OR)
self.set_function(p_(self.walk_nary, z3.Z3_mk_add), op.PLUS)
self.set_function(p_(self.walk_nary, z3.Z3_mk_mul), op.TIMES)
self.set_function(p_(self.walk_nary, z3.Z3_mk_sub), op.MINUS)
self.set_function(p_(self.walk_binary, z3.Z3_mk_implies), op.IMPLIES)
self.set_function(p_(self.walk_binary, z3.Z3_mk_le), op.LE)
self.set_function(p_(self.walk_binary, z3.Z3_mk_lt), op.LT)
self.set_function(p_(self.walk_binary, z3.Z3_mk_eq), op.EQUALS, op.IFF)
self.set_function(p_(self.walk_binary, z3.Z3_mk_power), op.POW)
self.set_function(p_(self.walk_binary, z3.Z3_mk_div), op.DIV)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvult), op.BV_ULT)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvule), op.BV_ULE)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvslt), op.BV_SLT)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvsle), op.BV_SLE)
self.set_function(p_(self.walk_binary, z3.Z3_mk_concat), op.BV_CONCAT)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvor), op.BV_OR)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvand), op.BV_AND)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvxor), op.BV_XOR)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvadd), op.BV_ADD)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvsub), op.BV_SUB)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvmul), op.BV_MUL)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvudiv), op.BV_UDIV)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvurem), op.BV_UREM)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvshl), op.BV_LSHL)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvlshr), op.BV_LSHR)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvsdiv), op.BV_SDIV)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvsrem), op.BV_SREM)
self.set_function(p_(self.walk_binary, z3.Z3_mk_bvashr), op.BV_ASHR)
self.set_function(self.walk_quantifier, *op.QUANTIFIERS)
# Back Conversion
self._back_fun = {
z3.Z3_OP_AND: lambda args, expr: self.mgr.And(args),
z3.Z3_OP_OR: lambda args, expr: self.mgr.Or(args),
z3.Z3_OP_MUL: lambda args, expr: self.mgr.Times(args),
z3.Z3_OP_ADD: lambda args, expr: self.mgr.Plus(args),
z3.Z3_OP_DIV: lambda args, expr: self.mgr.Div(args[0], args[1]),
z3.Z3_OP_IFF: lambda args, expr: self.mgr.Iff(args[0], args[1]),
z3.Z3_OP_XOR: lambda args, expr: self.mgr.Xor(args[0], args[1]),
z3.Z3_OP_FALSE: lambda args, expr: self.mgr.FALSE(),
z3.Z3_OP_TRUE: lambda args, expr: self.mgr.TRUE(),
z3.Z3_OP_GT: lambda args, expr: self.mgr.GT(args[0], args[1]),
z3.Z3_OP_GE: lambda args, expr: self.mgr.GE(args[0], args[1]),
z3.Z3_OP_LT: lambda args, expr: self.mgr.LT(args[0], args[1]),
z3.Z3_OP_LE: lambda args, expr: self.mgr.LE(args[0], args[1]),
z3.Z3_OP_SUB: lambda args, expr: self.mgr.Minus(args[0], args[1]),
z3.Z3_OP_NOT: lambda args, expr: self.mgr.Not(args[0]),
z3.Z3_OP_IMPLIES: lambda args, expr: self.mgr.Implies(args[0], args[1]),
z3.Z3_OP_ITE: lambda args, expr: self.mgr.Ite(args[0], args[1], args[2]),
z3.Z3_OP_TO_REAL: lambda args, expr: self.mgr.ToReal(args[0]),
z3.Z3_OP_BAND : lambda args, expr: self.mgr.BVAnd(args[0], args[1]),
z3.Z3_OP_BOR : lambda args, expr: self.mgr.BVOr(args[0], args[1]),
z3.Z3_OP_BXOR : lambda args, expr: self.mgr.BVXor(args[0], args[1]),
z3.Z3_OP_BNOT : lambda args, expr: self.mgr.BVNot(args[0]),
z3.Z3_OP_BNEG : lambda args, expr: self.mgr.BVNeg(args[0]),
z3.Z3_OP_CONCAT : lambda args, expr: self.mgr.BVConcat(args[0], args[1]),
z3.Z3_OP_ULT : lambda args, expr: self.mgr.BVULT(args[0], args[1]),
z3.Z3_OP_ULEQ : lambda args, expr: self.mgr.BVULE(args[0], args[1]),
z3.Z3_OP_SLT : lambda args, expr: self.mgr.BVSLT(args[0], args[1]),
z3.Z3_OP_SLEQ : lambda args, expr: self.mgr.BVSLE(args[0], args[1]),
z3.Z3_OP_UGT : lambda args, expr: self.mgr.BVUGT(args[0], args[1]),
z3.Z3_OP_UGEQ : lambda args, expr: self.mgr.BVUGE(args[0], args[1]),
z3.Z3_OP_SGT : lambda args, expr: self.mgr.BVSGT(args[0], args[1]),
z3.Z3_OP_SGEQ : lambda args, expr: self.mgr.BVSGE(args[0], args[1]),
z3.Z3_OP_BADD : lambda args, expr: self.mgr.BVAdd(args[0], args[1]),
z3.Z3_OP_BMUL : lambda args, expr: self.mgr.BVMul(args[0], args[1]),
z3.Z3_OP_BUDIV : lambda args, expr: self.mgr.BVUDiv(args[0], args[1]),
z3.Z3_OP_BSDIV : lambda args, expr: self.mgr.BVSDiv(args[0], args[1]),
z3.Z3_OP_BUREM : lambda args, expr: self.mgr.BVURem(args[0], args[1]),
z3.Z3_OP_BSREM : lambda args, expr: self.mgr.BVSRem(args[0], args[1]),
z3.Z3_OP_BSHL : lambda args, expr: self.mgr.BVLShl(args[0], args[1]),
z3.Z3_OP_BLSHR : lambda args, expr: self.mgr.BVLShr(args[0], args[1]),
z3.Z3_OP_BASHR : lambda args, expr: self.mgr.BVAShr(args[0], args[1]),
z3.Z3_OP_BSUB : lambda args, expr: self.mgr.BVSub(args[0], args[1]),
z3.Z3_OP_EXT_ROTATE_LEFT : lambda args, expr: self.mgr.BVRol(args[0], args[1].bv_unsigned_value()),
z3.Z3_OP_EXT_ROTATE_RIGHT: lambda args, expr: self.mgr.BVRor(args[0], args[1].bv_unsigned_value()),
z3.Z3_OP_POWER : lambda args, expr: self.mgr.Pow(args[0], args[1]),
z3.Z3_OP_SELECT : lambda args, expr: self.mgr.Select(args[0], args[1]),
z3.Z3_OP_STORE : lambda args, expr: self.mgr.Store(args[0], args[1], args[2]),
# Actually use both args, expr
z3.Z3_OP_SIGN_EXT: lambda args, expr: self.mgr.BVSExt(args[0], z3.get_payload(expr, 0)),
z3.Z3_OP_ZERO_EXT: lambda args, expr: self.mgr.BVZExt(args[0], z3.get_payload(expr, 0)),
z3.Z3_OP_ROTATE_LEFT: lambda args, expr: self.mgr.BVRol(args[0], z3.get_payload(expr, 0)),
z3.Z3_OP_ROTATE_RIGHT: lambda args, expr: self.mgr.BVRor(args[0], z3.get_payload(expr, 0)),
z3.Z3_OP_EXTRACT: lambda args, expr: self.mgr.BVExtract(args[0],
z3.get_payload(expr, 1),
z3.get_payload(expr, 0)),
# Complex Back Translation
z3.Z3_OP_EQ : self._back_z3_eq,
z3.Z3_OP_UMINUS : self._back_z3_uminus,
z3.Z3_OP_CONST_ARRAY : self._back_z3_const_array,
}
# Unique reference to Sorts
self.z3RealSort = z3.RealSort(self.ctx)
self.z3BoolSort = z3.BoolSort(self.ctx)
self.z3IntSort = z3.IntSort(self.ctx)
self.z3ArraySorts = {}
self._z3BitVecSorts = {}
# Unique reference to Function Declaration
self._z3_func_decl_cache = {}
return
def __init__(self, environment):
DagWalker.__init__(self, environment)
self.mgr = environment.formula_manager
self._get_type = environment.stc.get_type
self._back_memoization = {}
return
