def test_env_default_arguments(self):
"""Test use global env"""
x = FreshSymbol()
d = {x: TRUE()}
model = EagerModel(d)
self.assertEqual(model.get_value(x), TRUE())
def test_env_default_arguments(self):
"""Test use global env"""
x = FreshSymbol()
d = {x: TRUE()}
model = EagerModel(d)
self.assertEqual(model.get_value(x), TRUE())
def test_construction(self):
"""Build an eager model out of a dictionary"""
x, y = FreshSymbol(), FreshSymbol()
d = {x: TRUE(), y: FALSE()}
model = EagerModel(assignment=d)
self.assertEqual(model.get_value(x), TRUE())
self.assertEqual(model.get_value(y), FALSE())
self.assertEqual(model.get_value(And(x, y)), FALSE())
def test_construction(self):
"""Build an eager model out of a dictionary"""
x, y = FreshSymbol(), FreshSymbol()
d = {x: TRUE(), y: FALSE()}
model = EagerModel(assignment=d)
self.assertEqual(model.get_value(x), TRUE())
self.assertEqual(model.get_value(y), FALSE())
self.assertEqual(model.get_value(And(x,y)), FALSE())
def get_model(self):
assignment = {}
for s in self.environment.formula_manager.get_all_symbols():
if s.is_term():
v = self.get_value(s)
assignment[s] = v
return EagerModel(assignment=assignment, environment=self.environment)
def get_model(self):
assignment = {}
for s in self.declared_vars[-1]:
if s.is_term():
v = self.get_value(s)
assignment[s] = v
return EagerModel(assignment=assignment, environment=self.environment)
def get_model(self):
assignment = {}
for var, vid in self._var_ids.items():
v = picosat.picosat_deref(self.pico, vid)
assert v != 0, "Error when translating variable."
value = self.mgr.Bool(v == 1)
assignment[var] = value
return EagerModel(assignment=assignment, environment=self.environment)
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 get_model(self):
assignment = {}
for var, vid in iteritems(self._var_ids):
v = picosat.picosat_deref(self.pico, vid)
if v == 0:
assert False
value = self.mgr.Bool(v == 1)
assignment[var] = value
return EagerModel(assignment=assignment, environment=self.environment)
def get_model(self):
assignment = {}
# MG: This iteration is probelmatic, since it assumes that all
# defined symbols have a type that is compatible with this
# solver. In this case, the problem occurs with Arrays and
# Strings that are not supported.
for s in self.environment.formula_manager.get_all_symbols():
if s.is_term():
if s.symbol_type().is_array_type(): continue
v = self.get_value(s)
assignment[s] = v
return EagerModel(assignment=assignment, environment=self.environment)
def test_result_is_const(self):
"""The result of get_value is a constant"""
x, y = FreshSymbol(), FreshSymbol()
d = {x: TRUE()}
model = EagerModel(assignment=d)
with self.assertRaises(PysmtTypeError):
model.get_value(And(x, y), model_completion=False)
d2 = {x: TRUE(), y: x}
model = EagerModel(assignment=d2)
with self.assertRaises(PysmtTypeError):
model.get_value(And(x, y))
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 get_model(self):
assignment = {}
msat_iterator = mathsat.msat_create_model_iterator(self.msat_env)
while mathsat.msat_model_iterator_has_next(msat_iterator):
term, value = mathsat.msat_model_iterator_next(msat_iterator)
pysmt_term = self.converter.back(term)
pysmt_value = self.converter.back(value)
if self.environment.stc.get_type(pysmt_term).is_real_type() and \
pysmt_value.is_int_constant():
pysmt_value = self.mgr.Real(pysmt_value.constant_value())
assignment[pysmt_term] = pysmt_value
mathsat.msat_destroy_model_iterator(msat_iterator)
return EagerModel(assignment=assignment, environment=self.environment)
def get_model(self):
from pysmt.solvers.eager import EagerModel
if not self._ext_solver:
raise ValueError("No SAT model")
self._ctrl_pipe.send("get_model")
# Contextualize the result within the calling process
_normalize = self.environment.formula_manager.normalize
model_list = self._ctrl_pipe.recv()
model = {}
for k, v in model_list:
_k, _v = _normalize(k), _normalize(v)
model[_k] = _v
return EagerModel(model)
def test_result_is_const(self):
"""The result of get_value is a constant"""
x, y = FreshSymbol(), FreshSymbol()
d = {x:TRUE()}
model = EagerModel(assignment=d)
with self.assertRaises(TypeError):
model.get_value(And(x,y), model_completion=False)
d2 = {x:TRUE(), y:x}
model = EagerModel(assignment=d2)
with self.assertRaises(TypeError):
model.get_value(And(x,y))
def get_model(self):
# TODO: We could provide a more sophisticated Model class,
# that would contain the current Bdd and a copy of the
# DdManager. This would make it possible to apply other
# operations on the model (e.g., enumeration) in a simple way.
if self.latest_model is None:
_, current_state = self.assertions_stack[-1]
assert current_state is not None, "solve() should be called before get_model()"
# Build ddArray of variables
var_array = self.converter.get_all_vars_array()
minterm_set = self.ddmanager.PickOneMinterm(
current_state, var_array, len(var_array))
minterm = next(
repycudd.ForeachCubeIterator(self.ddmanager, minterm_set))
assignment = {}
for i, node in enumerate(var_array):
value = self.mgr.Bool(minterm[i] == 1)
key = self.converter.idx2var[node.NodeReadIndex()]
assignment[key] = value
self.latest_model = EagerModel(assignment=assignment,
environment=self.environment)
return self.latest_model
def get_model(self):
assignment = {}
for s, _ in self.converter.declared_vars.items():
assignment[s] = self.get_value(s)
return EagerModel(assignment=assignment, environment=self.environment)
def test_contains(self):
x, y, z = [FreshSymbol() for _ in xrange(3)]
d = {x: TRUE(), y: FALSE()}
model = EagerModel(assignment=d)
self.assertTrue(x in model)
self.assertFalse(z in model)
def test_complete_model(self):
"""Given a partial assignment, we can make a total model."""
x, y = FreshSymbol(), FreshSymbol()
r = FreshSymbol(REAL)
p = FreshSymbol(INT)
d = {x: TRUE()}
model = EagerModel(assignment=d)
self.assertEqual(model.get_value(x), TRUE())
self.assertEqual(model.get_value(Or(x, y)), TRUE())
self.assertTrue(model.get_value(p).is_constant(INT))
self.assertTrue(model.get_value(r).is_constant(REAL))
self.assertEqual(model.get_value(x, model_completion=False), TRUE())
with self.assertRaises(PysmtTypeError):
model.get_value(And(x, y), model_completion=False)
with self.assertRaises(PysmtTypeError):
model.get_value(p, model_completion=False)
with self.assertRaises(PysmtTypeError):
model.get_value(r, model_completion=False)
def test_complete_model(self):
"""Given a partial assignment, we can make a total model."""
x, y = FreshSymbol(), FreshSymbol()
r = FreshSymbol(REAL)
p = FreshSymbol(INT)
d = {x:TRUE()}
model = EagerModel(assignment=d)
self.assertEqual(model.get_value(x), TRUE())
self.assertEqual(model.get_value(Or(x,y)), TRUE())
self.assertTrue(model.get_value(p).is_constant(INT))
self.assertTrue(model.get_value(r).is_constant(REAL))
self.assertEqual(model.get_value(x, model_completion=False), TRUE())
with self.assertRaises(TypeError):
model.get_value(And(x,y), model_completion=False)
with self.assertRaises(TypeError):
model.get_value(p, model_completion=False)
with self.assertRaises(TypeError):
model.get_value(r, model_completion=False)
def get_model(self):
assignment = {}
for s in self.converter.declared_vars:
v = self.get_value(s)
assignment[s] = v
return EagerModel(assignment=assignment, environment=self.environment)