def test_propagate_toplevel(self):
x = Symbol("x", REAL)
y = Symbol("y", REAL)
f = And(LT(Real(4), Times(x, x)), Equals(Real(1), x))
fp = propagate_toplevel(f)
self.assertTrue(fp.is_false())
if self.env.factory.has_solvers(logic=QF_NRA):
try:
ok = is_valid(Iff(f, fp))
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
f = And(LT(Real(4), Times(x, x)), Equals(y, x), Equals(y, Real(1)))
fp = propagate_toplevel(f)
self.assertTrue(fp.is_false())
if self.env.factory.has_solvers(logic=QF_NRA):
try:
ok = is_valid(Iff(f, fp))
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
f = And(Equals(Real(4), x), Equals(y, x), Equals(y, Real(0)))
fp = propagate_toplevel(f)
self.assertTrue(fp.is_false())
fp = propagate_toplevel(f, preserve_equivalence=False)
self.assertTrue(fp.is_false())
fp = propagate_toplevel(f, preserve_equivalence=False, do_simplify=False)
self.assertTrue(fp.is_false())
f = Equals(Real(4), Real(5))
fp = propagate_toplevel(f, do_simplify=False)
self.assertTrue(fp.is_false())
def test_conversion_of_fractions_in_z3(self):
self.assertTrue(
is_valid(Equals(Real(Fraction(1, 9)), Div(Real(1), Real(9))),
solver_name="msat"))
self.assertTrue(
is_valid(Equals(Real(Fraction(1, 9)), Div(Real(1), Real(9))),
solver_name="z3"))
def test_examples_z3(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
v = is_valid(f, solver_name='z3', logic=logic)
s = is_sat(f, solver_name='z3', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def _validate(self, old, new):
if self.validate_simplifications:
Iff = self.env.formula_manager.Iff
is_valid = self.env.factory.is_valid
sname = self._validation_sname
assert is_valid(Iff(old, new), solver_name=sname ), \
"Was: %s \n Obtained: %s\n" % (str(old), str(new))
def _validate(self, old, new):
if self.validate_simplifications:
Iff = self.env.formula_manager.Iff
is_valid = self.env.factory.is_valid
sname = self._validation_sname
assert is_valid(Iff(old, new), solver_name=sname ), \
"Was: %s \n Obtained: %s\n" % (str(old), str(new))
def test_examples_z3(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
v = is_valid(f, solver_name='z3', logic=logic)
s = is_sat(f, solver_name='z3', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def test_examples_by_logic(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if len(get_env().factory.all_solvers(logic=logic)) > 0:
v = is_valid(f, logic=logic)
s = is_sat(f, logic=logic)
self.assertEqual(validity, v, f.serialize())
self.assertEqual(satisfiability, s, f.serialize())
def test_examples_yices(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.quantifier_free: continue
v = is_valid(f, solver_name='yices', logic=logic)
s = is_sat(f, solver_name='yices', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def test_examples_by_logic(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if len(get_env().factory.all_solvers(logic=logic)) > 0:
v = is_valid(f, logic=logic)
s = is_sat(f, logic=logic)
self.assertEqual(validity, v, f.serialize())
self.assertEqual(satisfiability, s, f.serialize())
def test_examples_yices(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.quantifier_free: continue
v = is_valid(f, solver_name='yices', logic=logic)
s = is_sat(f, solver_name='yices', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def test_nnf_examples(self):
for (f, _, _, logic) in get_example_formulae():
if get_env().factory.has_solvers(logic=logic):
rf = nnf(f)
try:
ok = is_valid(Iff(f, rf), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
def _std_examples(self, qe, target_logic):
for (f, validity, satisfiability, logic) in get_example_formulae():
if logic != target_logic: continue
qf = qe.eliminate_quantifiers(f)
s = is_sat(qf)
v = is_valid(qf)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def _std_examples(self, qe, target_logic):
for (f, validity, satisfiability, logic) in get_example_formulae():
if logic != target_logic: continue
qf = qe.eliminate_quantifiers(f)
s = is_sat(qf)
v = is_valid(qf)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def test_disj_partitioning(self):
for (f, _, _, logic) in get_example_formulae():
if self.env.factory.has_solvers(logic=logic):
disjuncts = list(disjunctive_partition(f))
try:
ok = is_valid(Iff(f, Or(disjuncts)), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
def test_conj_partitioning(self):
for (f, _, _, logic) in get_example_formulae():
if get_env().factory.has_solvers(logic=logic):
conjuncts = list(conjunctive_partition(f))
try:
ok = is_valid(Iff(f, And(conjuncts)), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
def test_aig_examples(self):
for (f, _, _, logic) in get_example_formulae():
if self.env.factory.has_solvers(logic=logic):
f_aig = aig(f)
try:
ok = is_valid(Iff(f, f_aig), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok, "Was: %s\n Got:%s" % (f, f_aig))
def test_propagate_toplevel_examples(self):
for (f, _, _, logic) in get_example_formulae():
if self.env.factory.has_solvers(logic=logic):
rwf = propagate_toplevel(f)
try:
ok = is_valid(Iff(f, rwf), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
def test_nnf_examples(self):
for (f, _, _, logic) in get_example_formulae():
if get_env().factory.has_solvers(logic=logic):
rf = nnf(f)
try:
ok = is_valid(Iff(f, rf), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
def test_prenex_examples(self):
for (f, _, _, logic) in get_example_formulae():
if self.env.factory.has_solvers(logic=logic):
prenex = prenex_normal_form(f)
try:
ok = is_valid(Iff(f, prenex), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
def test_prenex_examples(self):
for (f, _, _, logic) in get_example_formulae():
if self.env.factory.has_solvers(logic=logic):
prenex = prenex_normal_form(f)
try:
ok = is_valid(Iff(f, prenex), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
def test_aig_examples(self):
for (f, _, _, logic) in get_example_formulae():
if get_env().factory.has_solvers(logic=logic):
f_aig = aig(f)
try:
ok = is_valid(Iff(f, f_aig), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok, "Was: %s\n Got:%s" % (f, f_aig))
def test_propagate_toplevel_examples(self):
for (f, _, _, logic) in get_example_formulae():
if self.env.factory.has_solvers(logic=logic):
rwf = propagate_toplevel(f)
try:
ok = is_valid(Iff(f, rwf), logic=logic)
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
def test_examples_btor(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.quantifier_free: continue
try:
v = is_valid(f, solver_name='btor', logic=logic)
s = is_sat(f, solver_name='btor', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
except NoSolverAvailableError:
pass #Skip tests for unsupported logic
def test_examples_msat(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.quantifier_free: continue
if not logic.theory.linear: continue
if logic.theory.strings: continue
v = is_valid(f, solver_name='msat', logic=logic)
s = is_sat(f, solver_name='msat', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def test_examples_msat(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.quantifier_free: continue
if not logic.theory.linear: continue
if logic.theory.strings: continue
v = is_valid(f, solver_name='msat', logic=logic)
s = is_sat(f, solver_name='msat', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def test_examples_btor(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.quantifier_free: continue
try:
v = is_valid(f, solver_name='btor', logic=logic)
s = is_sat(f, solver_name='btor', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
except NoSolverAvailableError:
pass #Skip tests for unsupported logic
def test_examples_btor(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.quantifier_free: continue
if logic.theory.strings: continue
if logic.theory.integer_arithmetic: continue
if logic.theory.real_arithmetic: continue
if logic.theory.custom_type: continue
v = is_valid(f, solver_name='btor', logic=logic)
s = is_sat(f, solver_name='btor', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def test_simplify_qf_msat(self):
""" Test simplifier on quantifier free random formula using MathSAT"""
for i in xrange(MANY_ITERATIONS):
f = build_random_qf_formula(10, 20, 4, 0.1, seed=i)
sf = f.simplify()
test = Iff(f, sf)
res = is_valid(test, solver_name='msat')
self.assertTrue(
res, "Simplification of formula %d " % i +
"did not provide equivalent " + "result:\n f= %s\n sf = %s" %
(f, sf))
def test_examples_z3(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
try:
v = is_valid(f, solver_name='z3', logic=logic)
s = is_sat(f, solver_name='z3', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
except NoSolverAvailableError:
# Trying to solve a logic that mathsat does not support
theory = logic.theory
assert theory.strings
def test_examples_z3(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
try:
v = is_valid(f, solver_name='z3', logic=logic)
s = is_sat(f, solver_name='z3', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
except NoSolverAvailableError:
# Trying to solve a logic that mathsat does not support
theory = logic.theory
assert theory.strings
def test_examples_btor(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.quantifier_free: continue
if logic.theory.strings: continue
if logic.theory.integer_arithmetic: continue
if logic.theory.real_arithmetic: continue
if logic.theory.custom_type: continue
v = is_valid(f, solver_name='btor', logic=logic)
s = is_sat(f, solver_name='btor', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def test_msat_back_formulae(self):
from pysmt.solvers.msat import MathSAT5Solver, MSatConverter
env = get_env()
msat = MathSAT5Solver(environment=env, logic=QF_UFLIRA)
new_converter = MSatConverter(env, msat.msat_env)
for formula, _, _, logic in get_example_formulae():
if logic.quantifier_free:
term = new_converter.convert(formula)
res = new_converter.back(term)
self.assertTrue(is_valid(Iff(formula, res), logic=QF_UFLIRA))
def test_plus_converts_correctly_n_ary_functions(self):
"""Handling of Plus n-ary functionality.
Only the first two elements were translated to the solver
"""
a = Symbol("a", REAL)
b = Symbol("b", REAL)
c = Symbol("c", REAL)
p1 = Plus(
a,
Real((1, 6)),
b,
c,
)
p2 = Plus(a, b, c, Real((1, 6)))
self.assertTrue(is_valid(Equals(p1, p2)))
self.assertTrue(is_valid(Equals(p1, p2), solver_name='z3'))
self.assertTrue(is_valid(Equals(p1, p2), solver_name='msat'))
def test_examples_cvc4(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
try:
if not logic.quantifier_free: continue
v = is_valid(f, solver_name='cvc4', logic=logic)
s = is_sat(f, solver_name='cvc4', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
except SolverReturnedUnknownResultError:
# CVC4 does not handle quantifiers in a complete way
self.assertFalse(logic.quantifier_free)
def test_encode_vars(self):
fmwk_over = TestGrounding._get_fmwkov("", "cb", False)
trace = CTrace()
fmwk_over_cb = TestGrounding._get_fmwkov("", "cb", False)
fmwk_over_cb1 = TestGrounding._get_fmwkov("", "cb1", False)
cb = CCallback(1, 1, "", "cb", [], None, [fmwk_over_cb])
cb1 = CCallback(1, 1, "", "cb1", [], None, [fmwk_over_cb1])
ci = CCallin(1, 1, "", "ci", [], None)
cb.add_msg(cb1)
cb1.add_msg(ci)
trace.add_msg(cb)
cb = CCallback(1, 1, "", "cb", [], None, [fmwk_over_cb])
cb1 = CCallback(1, 1, "", "cb1", [], None, [fmwk_over_cb1])
ci = CCallin(1, 1, "", "ci", [], None)
cb.add_msg(cb1)
cb1.add_msg(ci)
trace.add_msg(cb)
ts_enc = TSEncoder(trace, [])
ts_var = ts_enc._encode_vars()
self.assertTrue(len(ts_var.state_vars) == 6)
trans = TRUE()
l = [cb, cb1, ci]
for m in l:
for entry in [TSEncoder.ENTRY, TSEncoder.EXIT]:
var = TSEncoder._get_state_var(
TSEncoder.get_key_from_msg(m, entry))
ivar = ts_enc.r2a.get_msg_eq(
TSEncoder.get_key_from_msg(m, entry))
trans = And(trans, Implies(ivar, var))
self.assertTrue(is_valid(Iff(ts_var.init, TRUE())))
self.assertTrue(is_valid(Iff(ts_var.trans, trans)))
def test_examples_cvc4(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
try:
if not logic.quantifier_free: continue
v = is_valid(f, solver_name='cvc4', logic=logic)
s = is_sat(f, solver_name='cvc4', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
except SolverReturnedUnknownResultError:
# CVC4 does not handle quantifiers in a complete way
self.assertFalse(logic.quantifier_free)
def test_examples(self):
for n in self.all_solvers:
with Solver(name=n) as solver:
for (f, validity, satisfiability, logic) in \
get_example_formulae():
try:
get_closer_logic(solver.LOGICS, logic)
except NoLogicAvailableError:
continue
v = is_valid(f, solver_name=n, logic=logic)
s = is_sat(f, solver_name=n, logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def test_examples_by_logic(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if len(get_env().factory.all_solvers(logic=logic)) > 0:
try:
v = is_valid(f, logic=logic)
s = is_sat(f, logic=logic)
self.assertEqual(validity, v, f.serialize())
self.assertEqual(satisfiability, s, f.serialize())
except SolverReturnedUnknownResultError:
s = Solver(logic=logic)
print(s, logic, f.serialize())
self.assertFalse(logic.quantifier_free,
"Unkown result are accepted only on "\
"Quantified formulae")
def test_examples_by_logic(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if len(get_env().factory.all_solvers(logic=logic)) > 0:
try:
v = is_valid(f, logic=logic)
s = is_sat(f, logic=logic)
self.assertEqual(validity, v, f.serialize())
self.assertEqual(satisfiability, s, f.serialize())
except SolverReturnedUnknownResultError:
s = Solver(logic=logic)
print(s, logic, f)
self.assertFalse(logic.quantifier_free,
"Unkown result are accepted only on "\
"Quantified formulae")
def test_propagate_toplevel(self):
x = Symbol("x", REAL)
y = Symbol("y", REAL)
f = And(LT(Real(4), Times(x, x)), Equals(Real(1), x))
fp = propagate_toplevel(f)
self.assertTrue(fp.is_false())
if self.env.factory.has_solvers(logic=QF_NRA):
try:
ok = is_valid(Iff(f, fp))
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
f = And(LT(Real(4), Times(x, x)), Equals(y, x), Equals(y, Real(1)))
fp = propagate_toplevel(f)
self.assertTrue(fp.is_false())
if self.env.factory.has_solvers(logic=QF_NRA):
try:
ok = is_valid(Iff(f, fp))
except SolverReturnedUnknownResultError:
ok = not logic.quantifier_free
self.assertTrue(ok)
f = And(Equals(Real(4), x), Equals(y, x), Equals(y, Real(0)))
fp = propagate_toplevel(f)
self.assertTrue(fp.is_false())
fp = propagate_toplevel(f, preserve_equivalence=False)
self.assertTrue(fp.is_false())
fp = propagate_toplevel(f,
preserve_equivalence=False,
do_simplify=False)
self.assertTrue(fp.is_false())
f = Equals(Real(4), Real(5))
fp = propagate_toplevel(f, do_simplify=False)
self.assertTrue(fp.is_false())
def test_examples_cvc4(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.theory.linear: continue
if logic.theory.arrays_const: continue
try:
v = is_valid(f, solver_name='cvc4', logic=logic)
s = is_sat(f, solver_name='cvc4', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
except SolverReturnedUnknownResultError:
# CVC4 does not handle quantifiers in a complete way
self.assertFalse(logic.quantifier_free)
except NoSolverAvailableError:
# Logic is not supported by CVC4
pass
def test_examples_cvc4(self):
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.theory.linear: continue
if logic.theory.arrays_const: continue
try:
v = is_valid(f, solver_name='cvc4', logic=logic)
s = is_sat(f, solver_name='cvc4', logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
except SolverReturnedUnknownResultError:
# CVC4 does not handle quantifiers in a complete way
self.assertFalse(logic.quantifier_free)
except NoSolverAvailableError:
# Logic is not supported by CVC4
pass
def test_examples(self):
for n in self.all_solvers:
with Solver(name=n) as solver:
print("Solver %s : %s" % (n, solver.LOGICS))
for (f, validity, satisfiability, logic) in \
get_example_formulae():
try:
get_closer_logic(solver.LOGICS, logic)
except NoLogicAvailableError:
continue
print(f)
v = is_valid(f, solver_name=n, logic=logic)
s = is_sat(f, solver_name=n, logic=logic)
self.assertEqual(validity, v, f)
self.assertEqual(satisfiability, s, f)
def walk_debug(self, formula, **kwargs):
from pysmt.shortcuts import Equals, Iff, get_type, is_valid
from pysmt.typing import BOOL
if formula in self.memoization:
return self.memoization[formula]
args = [self.walk(s, **kwargs) for s in formula.get_sons()]
f = self.functions[formula.node_type()]
res = f(formula, args, **kwargs)
ltype = get_type(formula)
rtype = get_type(res)
test = Equals(formula, res) if ltype != BOOL else Iff(formula, res)
assert (ltype == rtype) and is_valid(test, solver_name="z3"), \
("Was: %s \n Obtained: %s\n" % (str(formula), str(res)))
return res
def walk_debug(self, formula, **kwargs):
from pysmt.shortcuts import Equals, Iff, get_type, is_valid
from pysmt.typing import BOOL
if formula in self.memoization:
return self.memoization[formula]
args = [self.walk(s, **kwargs) for s in formula.args()]
f = self.functions[formula.node_type()]
res = f(formula, args=args, **kwargs)
ltype = get_type(formula)
rtype = get_type(res)
test = Equals(formula, res) if ltype != BOOL else Iff(formula, res)
assert (ltype == rtype) and is_valid(test, solver_name="z3"), \
("Was: %s \n Obtained: %s\n" % (str(formula), str(res)))
return res
def test_examples(self):
for name in self.all_solvers:
for example in get_example_formulae():
f = example.expr
try:
v = is_valid(f, solver_name=name)
s = is_sat(f, solver_name=name)
self.assertEqual(example.is_valid, v, f)
self.assertEqual(example.is_sat, s, f)
except NoSolverAvailableError:
# The solver does not support the specified logic
continue
except UnknownSolverAnswerError:
# MathSAT does not deal with UF with boolean args.
# This is handled via the native API, but not via the
# SMT-LIB Wrapper
self.assertTrue(name == "mathsat.solver.sh", name)
def test_simplify_qf_hard(self):
"""Test simplifier on random formula.
This version of the test forces the simplifier to validate
each simplification step, therefore it is slow, and we run it
only on few sample formulas.
"""
for i in xrange(FEW_ITERATIONS):
f = build_random_qf_formula(10, 20, 5, 0.1, seed=i)
get_env().simplifier.validate_simplifications = True
sf = f.simplify()
get_env().simplifier.validate_simplifications = False
res = is_valid(Iff(f, sf), solver_name='z3')
self.assertTrue(
res, "Simplification did not provide equivalent " +
"result:\n f= %s\n sf = %s" % (f, sf))
def test_examples(self):
for name in self.all_solvers:
for example in get_example_formulae():
f = example.expr
try:
v = is_valid(f, solver_name=name)
s = is_sat(f, solver_name=name)
self.assertEqual(example.is_valid, v, f)
self.assertEqual(example.is_sat, s, f)
except NoSolverAvailableError:
# The solver does not support the specified logic
continue
except UnknownSolverAnswerError:
# MathSAT does not deal with UF with boolean args.
# This is handled via the native API, but not via the
# SMT-LIB Wrapper
self.assertTrue(name == "mathsat.solver.sh", name)
def test_msat_back_simple(self):
from pysmt.solvers.msat import MathSAT5Solver, MSatConverter
env = get_env()
msat = MathSAT5Solver(environment=env, logic=QF_UFLIRA)
new_converter = MSatConverter(env, msat.msat_env)
r, s = FreshSymbol(REAL), FreshSymbol(INT)
f1 = GT(r, Real(1))
f2 = LE(Plus(s, Int(2)), Int(3))
f3 = LE(Int(2), Int(3))
f = And(f1, f2, f3)
term = new_converter.convert(f)
res = new_converter.back(term)
# Checking equality is not enough: MathSAT can change the
# shape of the formula into a logically equivalent form.
self.assertTrue(is_valid(Iff(f, res), logic=QF_UFLIRA))
def test_tactics_z3(self):
from z3 import Tactic, Then
from pysmt.shortcuts import Iff
my_tactic = Then(Tactic('simplify'), Tactic('propagate-values'),
Tactic('elim-uncnstr'))
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.theory.linear: continue
if not logic.quantifier_free: continue
if logic.theory.bit_vectors: continue
s = Solver(name='z3')
z3_f = s.converter.convert(f)
simp_z3_f = my_tactic(z3_f)
simp_f = s.converter.back(simp_z3_f.as_expr())
v = is_valid(simp_f)
s = is_sat(simp_f)
self.assertEqual(v, validity, (f, simp_f))
self.assertEqual(s, satisfiability, (f, simp_f))
def test_tactics_z3(self):
from z3 import Tactic, Then
from pysmt.shortcuts import Iff
my_tactic = Then(Tactic('simplify'), Tactic('propagate-values'),
Tactic('elim-uncnstr'))
for (f, validity, satisfiability, logic) in get_example_formulae():
if not logic.theory.linear: continue
if not logic.quantifier_free: continue
if logic.theory.bit_vectors: continue
s = Solver(name='z3')
z3_f = s.converter.convert(f)
simp_z3_f = my_tactic(z3_f)
simp_f = s.converter.back(simp_z3_f.as_expr())
v = is_valid(simp_f)
s = is_sat(simp_f)
self.assertEqual(v, validity, (f, simp_f))
self.assertEqual(s, satisfiability, (f, simp_f))
# Verify the correctness of a rewriting using Bit-Vectors
#
# The following expression computes the xor of y and x:
# (((y & x)*-2) + (y + x)
#
# We verify that this is indeed the case
#
# Source: https://yurichev.com/writings/SAT_SMT_draft-EN.pdf
#
from pysmt.shortcuts import SBV, Symbol, is_valid, Equals
from pysmt.typing import BV16
# X and Y are BV of width 16
x = Symbol("x", BV16)
y = Symbol("y", BV16)
r1 = y + x # add r1,ry,rx
r2 = y & x # and r2,ry,rx
r3 = r2 * SBV(-2, 16) # mul r3,r2,-2
r4 = r3 + r1 # add r4,r3,r1
# x xor y == r4
real_xor = x ^ y
assert is_valid(real_xor.Equals(r4))
def safeRL_callSMT(action, start_pos_x, start_pos_y, dynamical_parameters,
image, bird_param):
flapup_paths = None
godown_paths = None
smt_result = 0
path_depth = 8
if (action == 1):
#==========================================================================================================
# properties for safe flap up action
#----------------------------------------------------------------------------------------------------------
#property 1: safe_upper_height is the safe max altitude of the bird, depending upon the game
safe_max_height = 70
safety_prop_1 = GE(Int(dynamical_parameters['pos_y']),
Int(safe_max_height))
#property 2:if there is no escape path if it takes action flap, then do not take it.
# number_of_ states to check for safe movement depends upon the game speed, bird vel etc.
path_list = []
temp_dynamical_parameters = {}
temp_dynamical_parameters['pos_x'], temp_dynamical_parameters[
'pos_y'], temp_dynamical_parameters['vel_y'] = predict_next_steps(
dynamical_parameters['pos_x'], dynamical_parameters['pos_y'],
dynamical_parameters['vel_y'], action, dynamical_parameters)
path = [(temp_dynamical_parameters['pos_x'],
temp_dynamical_parameters['pos_y'])]
action_ctr = 1
flapup_paths = recursive_path_generator(
temp_dynamical_parameters['pos_x'],
temp_dynamical_parameters['pos_y'],
temp_dynamical_parameters['vel_y'],
action_ctr,
dynamical_parameters,
path_list,
path_depth,
path=path)
is_flap_up_path_clear = is_path_safe(image, flapup_paths,
bird_param['w'], bird_param['h'],
action)
safety_prop_2 = (Bool(is_flap_up_path_clear))
#----------------------------------------------------------------------------------------------------------
#property 3: Safe vertical distance of bird from pipe - when it goes through the pipe
# min distance between pipe and bird.
safe_v_pipe_dist = 15
bird_epsilon = 10
is_upper_pipe_far = is_safe_from_upper_pipe(
image, start_pos_x, start_pos_y, (bird_param['w'] + bird_epsilon),
(bird_param['h'] + bird_epsilon), safe_v_pipe_dist)
safety_prop_3 = (Bool(is_upper_pipe_far))
#----------------------------------------------------------------------------------------------------------
#print(" Before smt ", datetime.datetime.now().strftime("%H:%M:%S.%f")[:-3])
properties_for_flap_action = And(safety_prop_1, safety_prop_2,
safety_prop_3)
res = is_valid(properties_for_flap_action, solver_name="z3")
#print("flap :", properties_for_flap_action, " " , res)
if res:
smt_result = 1
if (action == 0):
#----------------------------------------------------------------------------------------------------------
# properties for safe no action
#----------------------------------------------------------------------------------------------------------
#property : safe_min_height is the min altitude of the bird
#safe_min_height value depends on the game. Its hardcoded to 500 for this game.
safe_min_height = 300
safety_prop_10 = LE(Int(dynamical_parameters['pos_y']),
Int(safe_min_height))
#property :if there is no escape path if it takes action no flap, then do not take it.
# number_of_ states to check for safe movement depends upon the game speed, bird vel etc.
#next_possible_actions = down_action_sequence_for_path(path_depth)
#godown_paths = path_generator (start_pos_x, start_pos_y + 20,dynamical_parameters, next_possible_actions)
path_list = []
temp_dynamical_parameters = {}
temp_dynamical_parameters['pos_x'], temp_dynamical_parameters[
'pos_y'], temp_dynamical_parameters['vel_y'] = predict_next_steps(
dynamical_parameters['pos_x'], dynamical_parameters['pos_y'],
dynamical_parameters['vel_y'], action, dynamical_parameters)
path = [(temp_dynamical_parameters['pos_x'],
temp_dynamical_parameters['pos_y'])]
action_ctr = 1
godown_paths = recursive_path_generator(
temp_dynamical_parameters['pos_x'],
temp_dynamical_parameters['pos_y'],
temp_dynamical_parameters['vel_y'],
action_ctr,
dynamical_parameters,
path_list,
path_depth,
path=path)
#print(" godown_paths : ", godown_paths)
is_go_down_clear = is_path_safe(image, godown_paths, bird_param['w'],
bird_param['h'], action)
safety_prop_11 = (Bool(is_go_down_clear))
#----------------------------------------------------------------------------------------------------------
#property 3: Safe vertical distance of bird from pipe - when it goes through the pipe
# min distance between pipe and bird.
safe_v_pipe_dist = 15
bird_epsilon = 10
is_lower_pipe_far = is_safe_from_lower_pipe(
image, start_pos_x, start_pos_y, (bird_param['w'] + bird_epsilon),
(bird_param['h'] + bird_epsilon), safe_v_pipe_dist)
safety_prop_12 = (Bool(is_lower_pipe_far))
#----------------------------------------------------------------------------------------------------------
properties_for_no_action = And(safety_prop_10, safety_prop_11,
safety_prop_12)
res = is_valid(properties_for_no_action, solver_name="z3")
#print("down :", properties_for_no_action, " " , res)
if res:
smt_result = 2
return smt_result, flapup_paths, godown_paths
def test_bv(self):
mgr = self.env.formula_manager
BV = mgr.BV
# Constants
one = BV(1, 32)
zero = BV(0, 32)
big = BV(127, 128)
binary = BV("111")
binary2 = BV("#b111")
binary3 = BV(0b111, 3) # In this case we need to explicit the width
self.assertEqual(binary, binary2)
self.assertEqual(binary2, binary3)
self.assertEqual(one, mgr.BVOne(32))
self.assertEqual(zero, mgr.BVZero(32))
# Type Equality
self.assertTrue(BV32 != BV128)
self.assertFalse(BV32 != BV32)
self.assertFalse(BV32 == BV128)
self.assertTrue(BV32 == BV32)
with self.assertRaises(PysmtValueError):
# Negative numbers are not supported
BV(-1, 10)
with self.assertRaises(PysmtValueError):
# Number should fit in the width
BV(10, 2)
# Variables
b128 = Symbol("b", BV128) # BV1, BV8 etc. are defined in pysmt.typing
b32 = Symbol("b32", BV32)
hexample = BV(0x10, 32)
bcustom = Symbol("bc", BVType(42))
self.assertIsNotNone(hexample)
self.assertIsNotNone(bcustom)
self.assertEqual(bcustom.bv_width(), 42)
self.assertEqual(hexample.constant_value(), 16)
not_zero32 = mgr.BVNot(zero)
not_b128 = mgr.BVNot(b128)
self.assertTrue(not_b128.is_bv_not())
f1 = Equals(not_zero32, b32)
f2 = Equals(not_b128, big)
self.assertTrue(is_sat(f1, logic=QF_BV))
self.assertTrue(is_sat(f2, logic=QF_BV))
zero_and_one = mgr.BVAnd(zero, one)
self.assertTrue(zero_and_one.is_bv_and())
zero_or_one = mgr.BVOr(zero, one)
self.assertTrue(zero_or_one.is_bv_or())
zero_xor_one = mgr.BVXor(zero, one)
self.assertTrue(zero_xor_one.is_bv_xor())
zero_xor_one.simplify()
self.assertTrue(zero_xor_one.is_bv_op())
f1 = Equals(zero_and_one, b32)
f2 = Equals(zero_or_one, b32)
f3 = Equals(zero_xor_one, b32)
f4 = Equals(zero_xor_one, one)
self.assertTrue(is_sat(f1, logic=QF_BV), f1)
self.assertTrue(is_sat(f2, logic=QF_BV), f2)
self.assertTrue(is_sat(f3, logic=QF_BV), f3)
self.assertTrue(is_valid(f4, logic=QF_BV), f4)
with self.assertRaises(PysmtTypeError):
mgr.BVAnd(b128, zero)
f = mgr.BVAnd(b32, zero)
f = mgr.BVOr(f, b32)
f = mgr.BVXor(f, b32)
f = Equals(f, zero)
self.assertTrue(is_sat(f, logic=QF_BV), f)
zero_one_64 = mgr.BVConcat(zero, one)
one_zero_64 = mgr.BVConcat(one, zero)
one_one_64 = mgr.BVConcat(one, one)
self.assertTrue(one_one_64.is_bv_concat())
self.assertFalse(one_one_64.is_bv_and())
self.assertTrue(zero_one_64.bv_width() == 64)
f1 = Equals(mgr.BVXor(one_zero_64, zero_one_64),
one_one_64)
self.assertTrue(is_sat(f1, logic=QF_BV), f1)
# MG: BV indexes grow to the left.
# This is confusing and we should address this.
extraction = mgr.BVExtract(zero_one_64, 32, 63)
self.assertTrue(is_valid(Equals(extraction, zero)))
ult = mgr.BVULT(zero, one)
self.assertTrue(ult.is_bv_ult())
neg = mgr.BVNeg(one)
self.assertTrue(neg.is_bv_neg())
self.assertTrue(is_valid(ult, logic=QF_BV), ult)
test_eq = Equals(neg, one)
self.assertTrue(is_unsat(test_eq, logic=QF_BV))
f = zero
addition = mgr.BVAdd(f, one)
self.assertTrue(addition.is_bv_add())
multiplication = mgr.BVMul(f, one)
self.assertTrue(multiplication.is_bv_mul())
udiv = mgr.BVUDiv(f, one)
self.assertTrue(udiv.is_bv_udiv())
self.assertTrue(is_valid(Equals(addition, one), logic=QF_BV), addition)
self.assertTrue(is_valid(Equals(multiplication, zero), logic=QF_BV), multiplication)
self.assertTrue(is_valid(Equals(udiv, zero), logic=QF_BV), udiv)
three = mgr.BV(3, 32)
two = mgr.BV(2, 32)
self.assertEqual(3, three.bv2nat())
reminder = mgr.BVURem(three, two)
self.assertTrue(reminder.is_bv_urem())
shift_l_a = mgr.BVLShl(one, one)
self.assertTrue(shift_l_a.is_bv_lshl())
shift_l_b = mgr.BVLShl(one, 1)
self.assertTrue(is_valid(Equals(reminder, one)), reminder)
self.assertEqual(shift_l_a, shift_l_b)
self.assertTrue(is_valid(Equals(shift_l_a, two)))
shift_r_a = mgr.BVLShr(one, one)
self.assertTrue(shift_r_a.is_bv_lshr())
shift_r_b = mgr.BVLShr(one, 1)
self.assertEqual(shift_r_a, shift_r_b)
self.assertTrue(is_valid(Equals(shift_r_a, zero)))
ashift_r_a = mgr.BVAShr(one, one)
ashift_r_b = mgr.BVAShr(one, 1)
self.assertEqual(ashift_r_a, ashift_r_b)
self.assertTrue(ashift_r_a.is_bv_ashr())
rotate_l = mgr.BVRol(one, 3)
self.assertTrue(rotate_l.is_bv_rol())
rotate_r = mgr.BVRor(rotate_l, 3)
self.assertTrue(rotate_r.is_bv_ror())
self.assertTrue(is_valid(Equals(one, rotate_r)))
zero_ext = mgr.BVZExt(one, 64)
self.assertTrue(zero_ext.is_bv_zext())
signed_ext = mgr.BVSExt(one, 64)
self.assertTrue(signed_ext.is_bv_sext())
signed_ext2 = mgr.BVSExt(mgr.BVNeg(one), 64)
self.assertNotEqual(signed_ext2, signed_ext)
self.assertTrue(is_valid(Equals(zero_ext, signed_ext), logic=QF_BV))
x = Symbol("x")
g = And(x, mgr.BVULT(zero, one))
res = is_sat(g, logic=QF_BV)
self.assertTrue(res)
model = get_model(g, logic=QF_BV)
self.assertTrue(model[x] == TRUE())
gt_1 = mgr.BVUGT(zero, one)
gt_2 = mgr.BVULT(one, zero)
self.assertEqual(gt_1, gt_2)
gte_1 = mgr.BVULE(zero, one)
gte_2 = mgr.BVUGE(one, zero)
self.assertEqual(gte_1, gte_2)
self.assertTrue(is_valid(gte_2, logic=QF_BV))
ide = Equals(mgr.BVNeg(BV(10, 32)), mgr.SBV(-10, 32))
self.assertValid(ide, logic=QF_BV)
# These should work without exceptions
mgr.SBV(-2, 2)
mgr.SBV(-1, 2)
mgr.SBV(0, 2)
mgr.SBV(1, 2)
# Overflow and Underflow
with self.assertRaises(PysmtValueError):
mgr.SBV(2, 2)
with self.assertRaises(PysmtValueError):
mgr.SBV(-3, 2)
# These should work without exceptions
mgr.BV(0, 2)
mgr.BV(1, 2)
mgr.BV(2, 2)
mgr.BV(3, 2)
# Overflow
with self.assertRaises(PysmtValueError):
mgr.BV(4, 2)
# No negative number allowed
with self.assertRaises(PysmtValueError):
mgr.BV(-1, 2)
# SBV should behave as BV for positive numbers
self.assertEqual(mgr.SBV(10, 16), mgr.BV(10, 16))
# Additional is_bv_* tests
f = mgr.BVSub(one, one)
self.assertTrue(f.is_bv_sub())
f = mgr.BVSLT(one, one)
self.assertTrue(f.is_bv_slt())
f = mgr.BVSLE(one, one)
self.assertTrue(f.is_bv_sle())
f = mgr.BVComp(one, one)
self.assertTrue(f.is_bv_comp())
f = mgr.BVSDiv(one, one)
self.assertTrue(f.is_bv_sdiv())
f = mgr.BVSRem(one, one)
self.assertTrue(f.is_bv_srem())
f = mgr.BVULE(one, one)
self.assertTrue(f.is_bv_ule())
def check_validity_and_test(args):
"""Checks expression and compare the outcome against a known value."""
expr, expected = args # IMPORTANT: Unpack args !!!
local_res = is_valid(expr)
return local_res == expected
