def test_warp_solvermodel(self):
x, y, z = [FreshSymbol() for _ in xrange(3)]
with Solver(name='z3') as solver:
solver.add_assertion(And(x,y,z))
solver.solve()
z3_model = solver.get_model()
eager_model = EagerModel(z3_model)
for var, value in eager_model:
self.assertIn(var, [x,y,z])
self.assertEqual(value, TRUE())
def test_examples_solving(self):
for example in EXAMPLE_FORMULAS:
if example.logic != pysmt.logics.BOOL:
continue
solver = Solver(logic=pysmt.logics.BOOL, name='bdd')
solver.add_assertion(example.expr)
if example.is_sat:
self.assertTrue(solver.solve())
else:
self.assertFalse(solver.solve())
def test_msat_back_not_identical(self):
msat = Solver(name="msat", logic=QF_UFLIRA)
r, s = FreshSymbol(REAL), FreshSymbol(REAL)
# r + 1 > s + 1
f = GT(Plus(r, Real(1)), Plus(s, Real(1)))
term = msat.converter.convert(f)
res = msat.converter.back(term)
self.assertFalse(f == res)
def test_boolector_assumptions(self):
with Solver(name='btor') as solver:
x = Symbol('x')
y = Symbol('y')
solver.add_assertion(Or(x, y))
solver.solve([Not(x), Not(y)])
btor_notx = solver.converter.convert(Not(x))
btor_noty = solver.converter.convert(Not(y))
self.assertEqual(solver.btor.Failed(btor_notx, btor_noty),
[True, True])
def test_btor_options(self):
for (f, _, sat, logic) in get_example_formulae():
if logic == QF_BV:
solver = Solver(name="btor",
solver_options={"rewrite-level":0,
"fun:dual-prop":1,
"eliminate-slices":1})
solver.add_assertion(f)
res = solver.solve()
self.assertTrue(res == sat)
def test_yices_push(self):
with Solver(name="yices") as solver:
solver.add_assertion(FALSE())
res = solver.solve()
self.assertFalse(res)
solver.push()
solver.add_assertion(TRUE())
res = solver.solve()
self.assertFalse(res)
solver.pop()
def test_msat(self):
self.solver = Solver(name="msat")
conv = self.solver.converter
self.solver_simplify = lambda x: conv.back(conv.convert(x))
# Run the tests
self.all_unary()
self.all_binary()
self.all_special()
self.extract()
self.concat_different_length()
def test_examples_solving(self):
for example in get_example_formulae():
if example.logic != BOOL:
continue
solver = Solver(logic=BOOL, name='bdd')
solver.add_assertion(example.expr)
if example.is_sat:
self.assertTrue(solver.solve())
else:
self.assertFalse(solver.solve())
def test_add_assertion(self):
r = FreshSymbol(REAL)
f1 = Plus(r, r)
f2 = GT(r, r)
for sname in get_env().factory.all_solvers(logic=QF_LRA):
with Solver(name=sname) as solver:
with self.assertRaises(PysmtTypeError):
solver.add_assertion(f1)
self.assertIsNone(solver.add_assertion(f2))
def test_initial_ordering(self):
with Solver(name="bdd",
logic=BOOL,
solver_options={
'static_ordering': [self.x, self.y],
'dynamic_reordering': True
}) as s:
s.add_assertion(self.big_tree)
self.assertTrue(s.solve())
self.assertNotEquals(s.ddmanager.ReorderingStatus()[1], 0)
def test_irrational(self):
x = FreshSymbol(REAL)
f = Equals(Times(x, x), Real(2))
with Solver(name="z3") as s:
self.assertTrue(s.is_sat(f))
model = s.get_model()
xval = model[x]
self.assertTrue(xval.is_algebraic_constant())
approx = Fraction(-3109888511975, 2199023255552)
self.assertEqual(xval.algebraic_approx_value(), approx)
def test_add_assertions(self):
varA = Symbol("A", BOOL)
varB = Symbol("B", BOOL)
varC = Symbol("C", BOOL)
assertions = [varA, Implies(varA, varB), Implies(varB, varC)]
for name in get_env().factory.all_solvers(logic=QF_BOOL):
with Solver(name) as solver:
solver.add_assertions(assertions)
solver.solve()
self.assertTrue(solver.get_py_value(And(assertions)))
def setUp(self):
self.x, self.y = Symbol("x"), Symbol("y")
self.bdd_solver = Solver(logic=pysmt.logics.BOOL, name='bdd')
self.bdd_converter = self.bdd_solver.converter
trail = [And, Or, And, Or]
f = And(self.x, self.y)
for op in trail:
f = op(f, f)
self.big_tree = f
def test_generic_wrapper_enable_debug(self):
a = Symbol("A", BOOL)
f = And(a, Not(a))
for n in self.all_solvers:
with Solver(name=n,
logic=QF_BOOL,
solver_options={'debug_interaction': True}) as s:
s.add_assertion(f)
res = s.solve()
self.assertFalse(res)
def test_msat_partial_model(self):
msat = Solver(name="msat")
x, y = Symbol("x"), Symbol("y")
msat.add_assertion(x)
c = msat.solve()
self.assertTrue(c)
model = msat.get_model()
self.assertNotIn(y, model)
self.assertIn(x, model)
msat.exit()
def test_z3_nary_back(self):
from z3 import Tactic
r = Symbol("r", REAL)
s = Symbol("s", REAL)
t = Symbol("t", REAL)
f = Equals(Times(r,s,t), Real(0))
with Solver(name="z3") as solver:
z3_f = solver.converter.convert(f)
z3_f = Tactic('simplify', solver.z3.ctx)(z3_f).as_expr()
fp = solver.converter.back(z3_f)
self.assertValid(Iff(f, fp), (f, fp))
def test_reordering_algorithms(self):
from pysmt.solvers.bdd import BddOptions
for algo in BddOptions.CUDD_ALL_REORDERING_ALGORITHMS:
with Solver(name="bdd",
logic=BOOL,
solver_options={
'dynamic_reordering': True,
'reordering_algorithm': algo
}) as s:
s.add_assertion(self.big_tree)
self.assertTrue(s.solve())
self.assertEqual(algo, s.ddmanager.ReorderingStatus()[1])
def test_custom_types(self):
A = Type("A", 0)
a, b = Symbol("a", A), Symbol("b", A)
p = Symbol("p", INT)
fun = Symbol("g", FunctionType(A, [INT, A]))
app = Function(fun, [p, b])
f_a = Equals(a, app)
for n in self.all_solvers:
with Solver(name=n, logic=QF_UFLIA) as s:
s.add_assertion(f_a)
res = s.solve()
self.assertTrue(res)
def test_clear_pop_smtlibsolver(self):
for n in self.all_solvers:
with Solver(name=n, logic=QF_LRA) as s:
x1, x2 = [Symbol(var, REAL) for var in ["x1", "x2"]]
init = LT(Plus(x1, Real(-1), x2), Real(Fraction(1, 4)))
invar = TRUE()
safe = LT(Plus(x1, x2), Real(8))
invar_init = And(invar, init)
iv_imp = Implies(invar, safe)
self.assertFalse(s.is_unsat(invar_init))
self.assertFalse(s.is_valid(iv_imp))
def solve(formula, n, max_models=None, solver="msat"):
s = Solver(name=solver)
st = s.is_sat(formula)
if st:
vs = [x for xs in variables(n) for x in xs]
k = 0
s.add_assertion(formula)
while s.solve() and ((not max_models) or k < max_models):
k = k + 1
model = s.get_model()
s.add_assertion(Not(And([EqualsOrIff(v, model[v]) for v in vs])))
yield to_bn(model, n)
def __init__(self, solver_name, name, logic, incremental, solver_options, basename=None):
self.solver_name = solver_name
self.name = name
self.logic = logic
self.incremental = incremental
self.solver_options = solver_options
self.basename = basename
self.smt2vars = set([])
self.solver = Solver(name=solver_name, logic=logic, incremental=incremental, solver_options=solver_options)
self.smt2vars_inc = []
if basename is not None:
self.trace_file = "%s-%s.smt2"%(basename, name)
def get_value():
solver = Solver('z3')
parser = SmtLibParser()
script = parser.get_script_fname("get_value.smt2")
#result = script.evaluate(Solver('z3'))
exprs = []
for get_val_cmd in script.filter_by_command_name("get-value"):
exprs.extend(get_val_cmd.args)
formula = script.get_last_formula()
solver.add_assertion(formula)
result1 = solver.solve()
result2 = solver.get_values(exprs)
def test_msat_preferred_variable(self):
a, b, c = [Symbol(x) for x in "abc"]
na, nb, nc = [Not(Symbol(x)) for x in "abc"]
f = And(Implies(a, And(b, c)), Implies(na, And(nb, nc)))
s1 = Solver("msat")
s1.add_assertion(f)
s1.set_preferred_var(a, True)
self.assertTrue(s1.solve())
self.assertTrue(s1.get_value(a).is_true())
s2 = Solver("msat")
s2.add_assertion(f)
s2.set_preferred_var(a, False)
self.assertTrue(s2.solve())
self.assertTrue(s2.get_value(a).is_false())
# Show that calling without polarity still works
# This case is harder to test, because we only say
# that the split will occur on that variable first.
s1.set_preferred_var(a)
def test_eager_model_iterator(self):
x, y, z = [Symbol(s) for s in "xyz"]
with Solver(logic=QF_BOOL) as s:
s.add_assertion(And(x, y))
assert s.solve()
d = {}
d[x] = s.get_value(x)
d[y] = s.get_value(y)
m = EagerModel(assignment=d)
# The model does not talk about 'z'
for (k, _) in m:
self.assertFalse(k == z)
def test_generic_wrapper_model(self):
a = Symbol("A", BOOL)
b = Symbol("B", BOOL)
f = And(a, Not(b))
for n in self.all_solvers:
with Solver(name=n, logic=QF_BOOL) as s:
s.add_assertion(f)
res = s.solve()
self.assertTrue(res)
self.assertFalse(s.get_py_value(b))
self.assertTrue(s.get_py_value(a))
def test_integer(self):
x = FreshSymbol(INT)
f = Equals(Times(x, x), Int(2))
with Solver(name="z3") as s:
self.assertFalse(s.is_sat(f))
# f = Equals(Times(Int(4), Pow(x, Int(-1))), Int(2))
# self.assertTrue(is_sat(f, solver_name="z3"))
f = Equals(Div(Int(4), x), Int(2))
self.assertTrue(is_sat(f, solver_name="z3"))
f = Equals(Times(x, x), Int(16))
self.assertTrue(is_sat(f))
def test_get_value_of_function(self):
"""get_value on a function should raise an exception."""
h = Symbol("h", FunctionType(REAL, [REAL, REAL]))
h_0_0 = Function(h, (Real(0), Real(1)))
f = GT(h_0_0, Real(0))
for sname in get_env().factory.all_solvers(logic=QF_UFLIRA):
with Solver(name=sname) as solver:
solver.add_assertion(f)
res = solver.solve()
self.assertTrue(res)
with self.assertRaises(PysmtTypeError):
solver.get_value(h)
self.assertIsNotNone(solver.get_value(h_0_0))
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 implies(term1, term2):
with Solver() as solver:
solver.add_assertion(term1 & ~term2)
solver.solve()
try:
solver.get_model()
return False
except InternalSolverError:
return True
except Exception as e:
if "Z3Exception" in e.__class__.__name__:
return True
else:
raise
def solve_soduku_model(model):
solver = Solver()
solver.add_assertion(model.extractConstraints())
if solver.solve(): # solution found
solution = tabletools.generateEmptyTable(model.n)
for y in range(0, model.n): # retrive the values from the sloved model
for x in range(0, model.n):
solution[y][x] = solver.get_value(model.getSymbol(x, y))
return solution
else:
return None # couldn't solve model :(
