def mk_inps_from_models(self, models, inp_decls, exe, n_inps=0): if not models: if n_inps > 0: return exe.gen_rand_inps(n_inps) else: return Inps() else: assert isinstance(models, list), models if all(isinstance(m, z3.ModelRef) for m in models): ms, _ = Z3.extract(models) else: ms = [{x: sage.all.sage_eval(str(v)) for (x, v) in model} for model in models] s = set() rand_inps = [] for m in ms: inp = [] for v in inp_decls.names: if v in m: inp.append(m[v]) else: if not rand_inps: rand_inps = exe.gen_rand_inps(len(ms)) mlog.debug("rand_inps: {} - {}\n{}".format( len(ms), len(rand_inps), rand_inps)) rand_inp = rand_inps.pop() d = dict(zip(rand_inp.ss, rand_inp.vs)) inp.append(sage.all.sage_eval(str(d[v]))) s.add(tuple(inp)) inps = Inps() inps.merge(s, inp_decls.names) return inps
def expr(self, use_reals): """ cannot make this as property because z3 expr is ctype, not compat with multiprocessing Queue also, cannot save this to sel._expr """ return Z3.parse(str(self.inv), use_reals)
def expr(self, use_reals): """ # sage: x, y, z = sage.all.var('x y z') # sage: mp = MPInv.mk_max_ieq((x-10, y-3), (y, 5)) # sage: mp.expr(use_reals=False) # If(x + -10 >= y + -3, If(y >= 5, x + -10 <= y, x + -10 <= 5), # If(y >= 5, y + -3 <= y, y + -3 <= 5)) # sage: MPInv.mk_max_ieq((x,), (y,z,0)).expr(use_reals=False) # If(And(y >= z, y >= 0), x <= y, If(z >= 0, x <= z, x <= 0)) """ a = tuple(Z3.parse(str(x), use_reals) for x in self.term.a) b = tuple(Z3.parse(str(x), use_reals) for x in self.term.b) expr = self.mp2df_expr(a, b, 0, self.term.is_max, self.is_ieq) return expr
def _imply(js, i): iexpr = myinvs_exprs[i] # don't consider/remove equality if iexpr.decl().kind() == z3.Z3_OP_EQ: ret = False else: jexprs = [myinvs_exprs[j] for j in js] ret = Z3._imply(jexprs, iexpr, is_conj) # if ret: # print '{} => {}'.format(jexprs, iexpr) return ret
def get_models(self, f, k, inp_decls=None, using_random_seed=False): if not using_random_seed: return Z3.get_models(f, k) def is_z3_assertions(f): return z3.is_expr(f) or isinstance(f, z3.AstVector) assert is_z3_assertions(f) or isinstance( f, logic.ZFormula), '{}: {}'.format(type(f), f) assert k >= 1, k if is_z3_assertions(f): fe = f else: fe = f.expr() is_nla = False fe_terms = self.get_mul_terms(fe) fe_nonlinear_terms = list( itertools.filterfalse(lambda t: not self.is_nonlinear_mul_term(t), fe_terms)) if fe_nonlinear_terms: is_nla = True # mlog.debug("is_nla: {}".format(is_nla)) # solver = Z3.create_solver() solver = self.mk(is_nla) # solver = z3.SolverFor('QF_NRA') pushed_labeled_conjs = False labeled_conjs = {} if isinstance(f, logic.ZConj): # solver.push() # pushed_labeled_conjs = True # solver.set(unsat_core=True) # solver.set(':core.minimize', True) for conj in f: if isinstance(conj, logic.LabeledExpr): if conj.label: conj_label = conj.label else: conj_label = 'c_' + str(self._get_expr_id(conj.expr)) # mlog.debug("conj: {}:{}".format(conj.expr, conj_label)) # solver.assert_and_track(conj.expr, conj_label) labeled_conjs[conj_label] = conj.expr else: solver.add(conj) else: solver.add(fe) if labeled_conjs: solver.push() pushed_labeled_conjs = True solver.add([conj for _, conj in labeled_conjs.items()]) # stat = solver.check() # psolver = PySMT() # stat, _ = PySMT.check_sat(solver) stat, _ = self.check_sat(solver, is_nla) unsat_core = None # mlog.debug("stat: {}".format(stat)) if stat == z3.unknown: # mlog.debug("reason_unknown: {}".format(solver.reason_unknown())) rs = None elif stat == z3.unsat: if pushed_labeled_conjs: # unsat_core = solver.unsat_core() # mlog.debug("unsat_core: {}".format(unsat_core)) pushed_labeled_conj = False solver.pop() soft_labeled_constraints = [ (lbl, conj) for (lbl, conj) in labeled_conjs.items() ] unsat_core = self._get_unsat_core(solver, is_nla, soft_labeled_constraints) rs = False else: # sat, get k models if pushed_labeled_conjs: pushed_labeled_conjs = False # solver.pop() # solver.add([conj for _, conj in labeled_conjs.items()]) range_constrs = [] if inp_decls: inp_ranges = list(dig_prog.Prog._get_inp_ranges( len(inp_decls))) random.shuffle(inp_ranges) # mlog.debug("inp_ranges ({}): {}".format(len(inp_ranges), inp_ranges)) inp_exprs = inp_decls.exprs(settings.use_reals) for inp_range in inp_ranges: range_constr = z3.And([ z3.And(ir[0] <= v, v <= ir[1]) for v, ir in zip(inp_exprs, inp_range) ]) # mlog.debug("range_constr: {}".format(range_constr)) range_constrs.append(range_constr) models = [] model_stat = {} i = 0 # while solver.check() == z3.sat and i < k: while i < k: # mlog.debug("{} -> {}".format(i, k)) chk, m = self.check_sat_and_get_rand_model( solver, is_nla, range_constrs) # mlog.debug("chk: {}".format(chk)) # mlog.debug("m: {}".format(m)) if chk != z3.sat or not m: break i = i + 1 models.append(m) block_cs = [] for (x, v) in m: model_stat.setdefault(x, {}) if isinstance(v, (int, float)): c = model_stat[x].setdefault(v, 0) model_stat[x][v] = c + 1 block_cs.append(z3.Int(x) == v) # mlog.debug("model {}: {}".format(i, m)) # create new constraint to block the current model if block_cs: block_c = z3.Not(z3.And(block_cs)) solver.add(block_c) for (x, v) in m: if model_stat[x][v] / k > 0.1: # block_x = z3.Int(x) != v block_x = z3.Not(z3.Int(x) == v) # mlog.debug("block_x: {}".format(block_x)) solver.add(block_x) # mlog.debug("models: {}".format(models)) if models: rs = models else: rs = None stat = z3.unknown assert not (isinstance(rs, list) and not rs), rs return rs, stat, unsat_core
def f(mps): return [ mp for mp in mps if not Z3._imply(conj, mp.expr(use_reals)) ]
def expr(self, use_reals): try: return self._expr except AttributeError: self._expr = Z3.parse(str(self.sageExpr), use_reals) return self._expr
def simplify(self): return Z3.simplify(self.expr())
def is_unsat(self): models, _ = Z3.get_models(self.expr(), k=1) return models is False
def implies(self, conseq): fante = self.expr() fconseq = conseq.expr() models, _ = Z3.get_models(z3.Not(z3.Implies(fante, fconseq)), k=1) return models is False