def __init__(self,rule): """ unpacks a rule of the kind (I) z3.Forall(variables, head) or (II) z3.Forall(variables, z3.Implies(z3.And([tail,children]),head)) """ self.rule = rule # original rule self.variables = None # quantified variables self.predicate = None # predicate declaration: name(pc,...) self.tail = None # body predicate self.children = None # other body elements self.head = None # head predicate # the rule is a z3 quantifier if z3.is_quantifier(rule): # quantified variables self.variables = list() for i in range(rule.num_vars()): sort = self.var_sort(rule,i).kind() if sort == z3.Z3_INT_SORT: self.variables.append(z3.Int(self.var_name(rule,i))) elif sort == z3.Z3_BOOL_SORT: self.variables.append(z3.Bool(self.var_name(rule,i))) else: raise ValueError('unsopported sort:',sort) # unpacks the rule body head = rule.body() if z3.is_app_of(head,z3.Z3_OP_IMPLIES): # the rule is of kind (II) body = head.arg(0) # z3.Implies body if z3.is_app_of(body,z3.Z3_OP_AND): # unpacks the other body elements # (assumes single uninterpreted predicate in body) self.children = list() for c in body.children(): child = z3.substitute_vars(c,*self.variables) # unpacks the body predicate if z3.is_app_of(child,z3.Z3_OP_UNINTERPRETED) \ and self.tail is None: self.tail = child # body predicate else: self.children.append(child) else: raise ValueError('unsupported implication body:',body) head = head.arg(1) # z3.Implies head if z3.is_app_of(head,z3.Z3_OP_UNINTERPRETED): # the rule is of kind (I) name = head.decl().name() # predicate name parameters = list() # predicate parameters arguments = list() # predicate arguments for i in range(head.num_args()): arg = head.arg(i) parameters.append(arg.sort()) arguments.append(z3.substitute_vars(arg,*self.variables)) parameters.append(z3.BoolSort()) self.predicate = z3.Function(name,*parameters) self.head = self.predicate(*arguments) # head predicate else: raise ValueError('unsupported rule body:',body)
def __init__(self, rule): """ unpacks a rule of the kind (I) z3.Forall(variables, head) or (II) z3.Forall(variables, z3.Implies(z3.And([tail,children]),head)) """ self.rule = rule # original rule self.variables = None # quantified variables self.predicate = None # predicate declaration: name(pc,...) self.tail = None # body predicate self.children = None # other body elements self.head = None # head predicate # the rule is a z3 quantifier if z3.is_quantifier(rule): # quantified variables self.variables = list() for i in range(rule.num_vars()): sort = self.var_sort(rule, i).kind() if sort == z3.Z3_INT_SORT: self.variables.append(z3.Int(self.var_name(rule, i))) elif sort == z3.Z3_BOOL_SORT: self.variables.append(z3.Bool(self.var_name(rule, i))) else: raise ValueError("unsopported sort:", sort) # unpacks the rule body head = rule.body() if z3.is_app_of(head, z3.Z3_OP_IMPLIES): # the rule is of kind (II) body = head.arg(0) # z3.Implies body if z3.is_app_of(body, z3.Z3_OP_AND): # unpacks the other body elements # (assumes single uninterpreted predicate in body) self.children = list() for c in body.children(): child = z3.substitute_vars(c, *self.variables) # unpacks the body predicate if z3.is_app_of(child, z3.Z3_OP_UNINTERPRETED) and self.tail is None: self.tail = child # body predicate else: self.children.append(child) else: raise ValueError("unsupported implication body:", body) head = head.arg(1) # z3.Implies head if z3.is_app_of(head, z3.Z3_OP_UNINTERPRETED): # the rule is of kind (I) name = head.decl().name() # predicate name parameters = list() # predicate parameters arguments = list() # predicate arguments for i in range(head.num_args()): arg = head.arg(i) parameters.append(arg.sort()) arguments.append(z3.substitute_vars(arg, *self.variables)) parameters.append(z3.BoolSort()) self.predicate = z3.Function(name, *parameters) self.head = self.predicate(*arguments) # head predicate else: raise ValueError("unsupported rule body:", body)
def f(_cache, e, seen): def f_cache(e): return _cache(f, e, seen) if z3.is_app_of(e, z3.Z3_OP_UMINUS): return f_cache((-1) * (e.arg(0))) elif z3.is_sub(e): return f_cache(e.arg(0) + (-1) * e.arg(1)) elif z3.is_app(e) and e.num_args() == 2: c1 = f_cache(e.arg(0)) c2 = f_cache(e.arg(1)) if z3.is_add(e): return c1 + c2 elif z3.is_mul(e): if z3.is_add(c1): c11 = c1.arg(0) c12 = c1.arg(1) return f_cache(c11 * c2 + c12 * c2) elif z3.is_add(c2): c21 = c2.arg(0) c22 = c2.arg(1) return f_cache(c1 * c21 + c1 * c22) else: return c1 * c2 else: return e else: return e
def predicates(expr): """Return a list of Z3 predicate names satisfied by expr. If expr is an application, the list will include the Z3_OP_* that expr is an application of. This is for debugging purposes. Real code should use the appropriate predicate functions directly. """ res = set() for pred_name in dir(z3): if not pred_name.startswith("is_"): continue if pred_name == "is_app_of": continue pred = getattr(z3, pred_name) if pred(expr): res.add(pred_name) if z3.is_app(expr): for op_name in dir(z3): if not op_name.startswith("Z3_OP_"): continue if z3.is_app_of(expr, getattr(z3, op_name)): res.add(op_name) return res
def collect_numerals(z3term): if z3.is_int_value(z3term) or z3.is_bv_value(z3term): yield z3term elif z3.is_app_of(z3term, z3.Z3_OP_ITE): for z in collect_numerals(z3term.arg(1)): yield z for z in collect_numerals(z3term.arg(2)): yield z
def process_eq(e1, e2): if z3.eq(e1, const): ret_val = z3.simplify(e2) else: assert z3.is_app(e1) if not (z3.is_app_of(e1, z3.Z3_OP_ADD) or z3.is_app_of(e1, z3.Z3_OP_SUB)): return None is_add = z3.is_app_of(e1, z3.Z3_OP_ADD) arg0 = e1.arg(0) arg1 = e1.arg(1) if z3.eq(arg1, const): if is_add: ret_val = z3.simplify(e2 - arg0) else: ret_val = z3.simplify(arg0 - e2) else: if is_add: ret_val = process_eq(arg0, e2 - arg1) else: ret_val = process_eq(arg0, e2 + arg1) return ret_val
def is_implies(a): """ Check if the input formula has an implication form, e.g. Imply(a ,b) Examples: >>> from z3 import * >>> a,b = Bools('a b') >>> is_implies(Or(Not(a), b)) False >>> is_implies(Implies(a, b)) True """ return is_app_of(a, Z3_OP_IMPLIES)
def __init__ (self, rule_exp): self.rule_exp = rule_exp self.qvars, self.matrix = z3u.strip_qblock (rule_exp) if z3.is_app_of (self.matrix, z3.Z3_OP_IMPLIES): self.body = self.matrix.arg (0) self.head = self.matrix.arg (1) else: self.body = None self.head = self.matrix # body stuff self.body_inst = self._get_first_pred_inst (self.body) self.body_decl = self._get_inst_decl (self.body_inst) # obtain head_decl self.head_decl = self.head.decl () # trans self.trans = self._get_trans (self.body)
def get_preds(fp): preds = dict() pred_keys = [] for rule_exp in fp.get_rules(): # rule_exp is a quantified formula representing the rule of the form: # Forall vars. body => head where head is a QF predicate instance # obtain the head unused_, matrix = strip_qblock(rule_exp) if z3.is_app_of(matrix, z3.Z3_OP_IMPLIES): head = matrix.arg(1) else: head = matrix assert head is not None # obtain head_decl head_decl = head.decl() # ensure head_decl is in preds head_key = exp_key(head_decl) if head_key in pred_keys: continue pred_keys.append(head_key) preds[head_decl.name()] = head_decl return preds
from pysmt.solvers.smtlib import SmtLibBasicSolver, SmtLibIgnoreMixin from pysmt.solvers.qelim import QuantifierEliminator from pysmt.solvers.interpolation import Interpolator from pysmt.walkers import DagWalker from pysmt.exceptions import (SolverReturnedUnknownResultError, SolverNotConfiguredForUnsatCoresError, SolverStatusError, ConvertExpressionError, UndefinedSymbolError, PysmtValueError) from pysmt.decorators import clear_pending_pop, catch_conversion_error from pysmt.logics import LRA, LIA, QF_UFLIA, QF_UFLRA, PYSMT_LOGICS from pysmt.oracles import get_logic from pysmt.constants import Fraction, Numeral, is_pysmt_integer, to_python_integer # patch z3api z3.is_ite = lambda x: z3.is_app_of(x, z3.Z3_OP_ITE) z3.is_function = lambda x: z3.is_app_of(x, z3.Z3_OP_UNINTERPRETED) z3.is_array_store = lambda x: z3.is_app_of(x, z3.Z3_OP_STORE) z3.get_payload = lambda node, i: z3.Z3_get_decl_int_parameter( node.ctx.ref(), node.decl().ast, i) class AstRefKey: def __init__(self, n): self.n = n def __hash__(self): return self.n.hash() def __eq__(self, other):
from pysmt.solvers.interpolation import Interpolator from pysmt.walkers import DagWalker from pysmt.exceptions import (SolverReturnedUnknownResultError, SolverNotConfiguredForUnsatCoresError, SolverStatusError, ConvertExpressionError, UndefinedSymbolError, PysmtValueError) from pysmt.decorators import clear_pending_pop, catch_conversion_error from pysmt.logics import LRA, LIA, QF_UFLIA, QF_UFLRA, PYSMT_LOGICS from pysmt.oracles import get_logic from pysmt.constants import Fraction, Numeral, is_pysmt_integer, to_python_integer # patch z3api z3.is_ite = lambda x: z3.is_app_of(x, z3.Z3_OP_ITE) z3.is_function = lambda x: z3.is_app_of(x, z3.Z3_OP_UNINTERPRETED) z3.is_array_store = lambda x: z3.is_app_of(x, z3.Z3_OP_STORE) z3.get_payload = lambda node,i : z3.Z3_get_decl_int_parameter(node.ctx.ref(), node.decl().ast, i) class AstRefKey: def __init__(self, n): self.n = n def __hash__(self): return self.n.hash() def __eq__(self, other): return self.n.eq(other.n) def askey(n): assert isinstance(n, z3.AstRef)
def collect_numerals(z3term): if z3.is_int_value(z3term) or z3.is_bv_value(z3term): yield z3term elif z3.is_app_of(z3term, z3.Z3_OP_ITE): yield collect_numerals(z3term.arg(1)) yield collect_numerals(z3term.arg(2))
def is_implies (expr): return z3.is_app_of (expr, z3.Z3_OP_IMPLIES)
from pysmt.solvers.smtlib import SmtLibBasicSolver, SmtLibIgnoreMixin from pysmt.solvers.qelim import QuantifierEliminator from pysmt.solvers.interpolation import Interpolator from pysmt.walkers import DagWalker from pysmt.exceptions import (SolverReturnedUnknownResultError, SolverNotConfiguredForUnsatCoresError, SolverStatusError, ConvertExpressionError) from pysmt.decorators import clear_pending_pop, catch_conversion_error from pysmt.logics import LRA, LIA, QF_UFLIA, QF_UFLRA, PYSMT_LOGICS from pysmt.oracles import get_logic # patch z3api z3.is_ite = lambda x: z3.is_app_of(x, z3.Z3_OP_ITE) z3.is_implies = lambda x: z3.is_app_of(x, z3.Z3_OP_IMPLIES) z3.is_function = lambda x: z3.is_app_of(x, z3.Z3_OP_UNINTERPRETED) z3.is_iff = lambda x: z3.is_app_of(x, z3.Z3_OP_IFF) z3.is_uminus = lambda x: z3.is_app_of(x, z3.Z3_OP_UMINUS) z3.is_xor = lambda x: z3.is_app_of(x, z3.Z3_OP_XOR) z3.is_bv_and = lambda x: z3.is_app_of(x, z3.Z3_OP_BAND) z3.is_bv_or = lambda x: z3.is_app_of(x, z3.Z3_OP_BOR) z3.is_bv_xor = lambda x: z3.is_app_of(x, z3.Z3_OP_BXOR) z3.is_bv_neg = lambda x: z3.is_app_of(x, z3.Z3_OP_BNEG) z3.is_bv_not = lambda x: z3.is_app_of(x, z3.Z3_OP_BNOT) z3.is_bv_concat = lambda x: z3.is_app_of(x, z3.Z3_OP_CONCAT) z3.is_bv_slt = lambda x: z3.is_app_of(x, z3.Z3_OP_SLT) z3.is_bv_sleq = lambda x: z3.is_app_of(x, z3.Z3_OP_SLEQ) z3.is_bv_ult = lambda x: z3.is_app_of(x, z3.Z3_OP_ULT)
def _is_pow_expr(cls, e): return z3.is_app_of(e, z3.Z3_OP_POWER)
from fractions import Fraction from six.moves import xrange from pysmt import typing as types from pysmt.solvers.solver import Solver, Model, Converter from pysmt.solvers.smtlib import SmtLibBasicSolver, SmtLibIgnoreMixin from pysmt.solvers.qelim import QuantifierEliminator from pysmt.walkers import DagWalker from pysmt.exceptions import SolverReturnedUnknownResultError from pysmt.decorators import clear_pending_pop import pysmt.logics # patch z3api z3.is_ite = lambda x: z3.is_app_of(x, z3.Z3_OP_ITE) class AstRefKey: def __init__(self, n): self.n = n def __hash__(self): return self.n.hash() def __eq__(self, other): return self.n.eq(other.n) def askey(n): assert isinstance(n, z3.AstRef)
def is_xor(exp): return z3.is_app_of(exp, z3.Z3_OP_XOR)
def is_ite(exp): return z3.is_app_of(exp, z3.Z3_OP_ITE)