def test_multiple_exit(self):
for sname in get_env().factory.all_solvers():
# Multiple exits should be ignored
s = Solver(name=sname)
s.exit()
s.exit()
self.assertTrue(True)
class TraceSolver(object):
solver_name = None
name = None
basename = None
trace_file = None
solver = None
smt2vars = None
smt2vars_inc = None
def __init__(self, solver_name, name, basename=None):
self.solver_name = solver_name
self.name = name
self.basename = basename
self.smt2vars = set([])
self.solver = Solver(name=solver_name, logic=QF_ABV)
self.smt2vars_inc = []
if basename is not None:
self.trace_file = "%s-%s.smt2" % (basename, name)
def clear(self):
self.solver.exit()
self.solver = Solver(name=self.solver_name, logic=QF_ABV)
def copy(self, name=None):
return TraceSolver(self.solver_name,
self.name if name is None else name, self.basename)
def test_multiple_exit(self):
for sname in get_env().factory.all_solvers():
# Multiple exits should be ignored
s = Solver(name=sname)
s.exit()
s.exit()
self.assertTrue(True)
class TraceSolver(object):
solver_name = None
name = None
logic = None
incremental = None
solver_options = None
basename = None
trace_file = None
solver = None
smt2vars = None
smt2vars_inc = None
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 clear(self):
self.solver.exit()
self.solver = Solver(name=self.solver_name, logic=self.logic, incremental=self.incremental, solver_options=self.solver_options)
def copy(self, name=None):
return TraceSolver(self.solver_name, self.name if name is None else name, self.logic, self.incremental, self.solver_options, self.basename)
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_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()
class PDR(object):
def __init__(self, system):
self.system = system
self.frames = [system.init]
self.solver = Solver()
self.prime_map = dict([(v, next_var(v))
for v in self.system.variables])
def check_property(self, prop):
"""Property Directed Reachability approach without optimizations."""
print("Checking property %s..." % prop)
while True:
cube = self.get_bad_state(prop)
if cube is not None:
# Blocking phase of a bad state
if self.recursive_block(cube):
print("--> Bug found at step %d" % (len(self.frames)))
break
else:
print(" [PDR] Cube blocked '%s'" % str(cube))
else:
# Checking if the last two frames are equivalent i.e., are inductive
if self.inductive():
print("--> The system is safe!")
break
else:
print(" [PDR] Adding frame %d..." % (len(self.frames)))
self.frames.append(TRUE())
def get_bad_state(self, prop):
"""Extracts a reachable state that intersects the negation
of the property and the last current frame"""
return self.solve(And(self.frames[-1], Not(prop)))
def solve(self, formula):
"""Provides a satisfiable assignment to the state variables that are consistent with the input formula"""
if self.solver.solve([formula]):
return And([
EqualsOrIff(v, self.solver.get_value(v))
for v in self.system.variables
])
return None
def recursive_block(self, cube):
"""Blocks the cube at each frame, if possible.
Returns True if the cube cannot be blocked.
"""
for i in range(len(self.frames) - 1, 0, -1):
cubeprime = cube.substitute(
dict([(v, next_var(v)) for v in self.system.variables]))
cubepre = self.solve(
And(self.frames[i - 1], self.system.trans, Not(cube),
cubeprime))
if cubepre is None:
for j in range(1, i + 1):
self.frames[j] = And(self.frames[j], Not(cube))
return False
cube = cubepre
return True
def inductive(self):
"""Checks if last two frames are equivalent """
if len(self.frames) > 1 and \
self.solve(Not(EqualsOrIff(self.frames[-1], self.frames[-2]))) is None:
return True
return False
def __del__(self):
self.solver.exit()
