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