def to_smtlib(self):
"""Return a SMT_LIB string representation of the formula."""
sc.reset_env()
i_f = sc.And(*[bv2pysmt(a) for a in self.inner_problem.assertions])
o_f = sc.And(*[bv2pysmt(a) for a in self.outer_problem.assertions])
pysmt_formula = sc.And(i_f, o_f)
return sc.to_smtlib(pysmt_formula, daggify=False)
def execute_script_fname(smtfile, logic, expected_result):
"""Read and call a Solver to solve the instance"""
reset_env()
Solver = get_env().factory.Solver
parser = SmtLibParser()
script = parser.get_script_fname(smtfile)
try:
solver = Solver(logic=logic, incremental=False, generate_models=False)
if logic == QF_UF and type(solver).__name__ == 'CVC4Solver':
warnings.warn(
"Test (%s, %s) skipped because CVC4 can't handle QF_UF." %
(logic, smtfile))
return
if logic == QF_UF and type(solver).__name__ == 'BoolectorSolver':
warnings.warn(
"Test (%s, %s) skipped because Boolector can't handle QF_UF." %
(logic, smtfile))
return
log = script.evaluate(solver)
except NoSolverAvailableError:
raise SkipTest("No solver for logic %s." % logic)
except SolverReturnedUnknownResultError:
if not logic.quantifier_free:
warnings.warn(
"Test (%s, %s) could not be solved due to quantifiers." %
(logic, smtfile))
return
raise
res = check_sat_filter(log)
assert expected_result == res
def to_smtlib(self):
"""Return a SMT_LIB string representation of the formula.
>>> from arxpy.bitvector.function import Function
>>> from arxpy.diffcrypt.difference import XorDiff, DiffVar
>>> from arxpy.diffcrypt.characteristic import Characteristic
>>> from arxpy.diffcrypt.smt import SmtProblem
>>> class MyFunction(Function):
... input_widths = [8, 8, 8]
... output_widths = [8, 8]
... @classmethod
... def eval(cls, x, y, k):
... return (y + k, (y + k) ^ x)
>>> x, y, k = DiffVar("x", 8), DiffVar("y", 8), DiffVar("k", 8)
>>> ch = Characteristic(MyFunction, XorDiff, [x, y, k])
>>> smt_problem = SmtProblem(ch, 0)
>>> print(smt_problem.to_smtlib()) # doctest:+ELLIPSIS
(and (not (= #b000000000000000000000000 (concat (concat x y) k))) ...
Note that a more human-readable from can be obtained by
printing the SmtProblem directly (print(smt_problem)).
"""
sc.reset_env()
pysmt_formula = sc.And(*[bv2pysmt(a) for a in self.assertions])
return sc.to_smtlib(pysmt_formula, daggify=False)
def parse(self, file_id):
fname = SMTLIB_FILE_PATTERN % file_id
reset_env()
parser = SmtLibParser()
script = parser.get_script_fname(fname)
self.assertIsNotNone(script)
return script
def scan(full_dir, root_dir):
matches = []
for root, dir_names, file_names in os.walk(full_dir):
for filename in fnmatch.filter(file_names, '*.smt2'):
full_path = os.path.abspath(os.path.join(root, filename))
matches.append(re.match("{r}{s}(.*)".format(s=os.path.sep, r=root_dir), full_path).group(1))
for match in matches:
print(match)
flat = load()
problems = flat["files"]
counter = 0
for match in matches:
if match not in problems:
print("Importing {}".format(match))
smt_file = os.path.join(root_dir, match)
if os.path.getsize(smt_file) / 1024 <= 100:
imported_problem = import_problem(match, smt_file)
problems[match] = {
"loaded": True,
"var_count": len(imported_problem.domain.variables),
"file_size": os.path.getsize(match)
}
smt.reset_env()
else:
problems[match] = {"loaded": False, "reason": "size", "file_size": os.path.getsize(match)}
counter += 1
if counter >= 1:
dump(flat)
counter = 0
if counter != 0:
dump(flat)
def execute_script_fname(smtfile, logic, expected_result):
"""Read and call a Solver to solve the instance"""
reset_env()
Solver = get_env().factory.Solver
parser = SmtLibParser()
script = parser.get_script_fname(smtfile)
try:
log = script.evaluate(
Solver(logic=logic, incremental=False, generate_models=False))
except NoSolverAvailableError:
raise SkipTest("No solver for logic %s." % logic)
except SolverReturnedUnknownResultError:
if not logic.quantifier_free:
warnings.warn(
"Test (%s, %s) could not be solver due to quantifiers." %
(logic, smtfile))
return
raise
res = check_sat_filter(log)
if res:
assert expected_result == "sat"
else:
assert expected_result == "unsat"
def parse(self, file_id):
fname = SMTLIB_FILE_PATTERN % file_id
reset_env()
parser = SmtLibParser()
script = parser.get_script_fname(fname)
self.assertIsNotNone(script)
return script
def run_translation(path):
reset_env()
status = True
if "-boolean" in path:
boolean = True
else:
boolean = False
models = list([x for x in list(os.walk(path))
if COSADIR not in x[0]])[-1][-1]
j_files = [
"%s/%s" % (path, f) for f in models if f.split(".")[1] == "json"
]
s_files = [
"%s/%s" % (path, f) for f in models
if f.split(".")[1] in ["sts", "ets"]
]
v_files = [
"%s/%s[%s]" % (path, f, f.split(".")[0]) for f in models
if f.split(".")[1] in ["v"]
]
if os.path.isfile("%s/assumptions.txt" % path):
assumptions = "%s/assumptions.txt" % path
else:
assumptions = None
if os.path.isfile("%s/properties.txt" % path):
properties = "%s/properties.txt" % path
else:
properties = None
if os.path.isfile("%s/lemmas.txt" % path):
lemmas = "%s/lemmas.txt" % path
else:
lemmas = None
problems_manager = cosa_option_manager.get_default_problem_manager(
verbosity=3,
boolean=boolean,
translate=path + GENERATED,
printer='SMV',
model_files=",".join(j_files + s_files + v_files))
problems_manager.add_problem(
solver_name='msat',
verification='safety' if properties is not None else "simulation",
prove=True if properties is not None else False,
assumptions=assumptions,
properties=properties,
lemmas=lemmas)
run_problems(problems_manager)
# status = files_eq(path+EXPECTED, path+GENERATED)
# assert status
return status
def pysmt_formula_size(self):
"""The size of the underlying bit-vector formula according to pySMT."""
sc.reset_env()
i_f = sc.And(*[bv2pysmt(a) for a in self.inner_problem.assertions])
o_f = sc.And(*[bv2pysmt(a) for a in self.outer_problem.assertions])
pysmt_formula = sc.And(i_f, o_f)
return sc.get_formula_size(pysmt_formula)
def execute_script_fname(smtfile):
"""Read and call a Solver to solve the instance"""
print(smtfile)
reset_env()
assert os.path.exists(smtfile)
start = time.clock()
read_smtlib(smtfile)
end = time.clock()
return ( (end - start), smtfile)
def execute_script_fname(smtfile):
"""Read and call a Solver to solve the instance"""
print(smtfile)
reset_env()
assert os.path.exists(smtfile)
start = time.clock()
read_smtlib(smtfile)
end = time.clock()
return ((end - start), smtfile)
def run_translation(path):
reset_env()
config = Config()
status = True
config.verbosity = 3
config.solver_name = "msat"
config.prove = True
config.translate = path + GENERATED
config.printer = "SMV"
config.deterministic = True
if "-boolean" in path:
config.boolean = True
if os.path.isfile("%s/assumptions.txt" % path):
config.assumptions = "%s/assumptions.txt" % path
if os.path.isfile("%s/properties.txt" % path):
config.properties = "%s/properties.txt" % path
if os.path.isfile("%s/lemmas.txt" % path):
config.lemmas = "%s/lemmas.txt" % path
models = list(os.walk(path))[-1][-1]
j_files = [
"%s/%s" % (path, f) for f in models if f.split(".")[1] == "json"
]
s_files = [
"%s/%s" % (path, f) for f in models
if f.split(".")[1] in ["sts", "ets"]
]
config.strfiles = ",".join(j_files + s_files)
parsing_defs = [config.properties, config.lemmas, config.assumptions]
for i in range(len(parsing_defs)):
if parsing_defs[i] is not None:
if os.path.isfile(parsing_defs[i]):
with open(parsing_defs[i]) as f:
parsing_defs[i] = [
p.strip() for p in f.read().strip().split("\n")
]
else:
parsing_defs[i] = [
p.strip() for p in parsing_defs[i].split(",")
]
[config.properties, config.lemmas, config.assumptions] = parsing_defs
run_verification(config)
# status = files_eq(path+EXPECTED, path+GENERATED)
# assert status
return status
def formulas_from_smtlib_test_set(logics=None):
"""Returns a generator over the test-set of SMT-LIB files.
Note: This resets the Environment at each call.
"""
for (logic, fname, expected_result) in SMTLIB_TEST_FILES:
if logics is not None and logic not in logics:
continue
reset_env()
smtfile = os.path.join(SMTLIB_DIR, fname)
formula = get_formula_fname(smtfile)
yield (logic, fname, formula, expected_result)
def formulas_from_smtlib_test_set(logics=None):
"""Returns a generator over the test-set of SMT-LIB files.
Note: This resets the Environment at each call.
"""
for (logic, fname, expected_result) in SMTLIB_TEST_FILES:
if logics is not None and logic not in logics:
continue
reset_env()
smtfile = os.path.join(SMTLIB_DIR, fname)
formula = get_formula_fname(smtfile)
yield (logic, fname, formula, expected_result)
def execute_script_fname(smtfile):
"""Read and print the formula in HR Format."""
reset_env()
assert os.path.exists(smtfile)
smtlib_start = time.clock()
f = read_smtlib(smtfile)
smtlib_end = time.clock()
start = time.clock()
s = f.serialize()
end = time.clock()
assert s is not None
#print(smtfile, (smtlib_end-smtlib_start), (end-start))
return (smtfile, (end - start))
def solve(self, solver_name=None, get_assignment=False):
"""Solve the SMT problem.
Return whether the decision problem is satisfiable. If get_assignment
is set to True, solve() returns an assignment of the variables
that makes the SMT problem satisfiable (if the problem is
unsatisfiable, None is returned).
This assignment is returned as a dictionary with the following entries:
- differences: an ordered dictionary containing the sequence of
differences.
- weight: the weight of the characteristic.
- op_weights: the weights of each operation with non-deterministic
propagation.
>>> from arxpy.bitvector.function import Function
>>> from arxpy.diffcrypt.difference import XorDiff, DiffVar
>>> from arxpy.diffcrypt.characteristic import Characteristic
>>> from arxpy.diffcrypt.smt import SmtProblem
>>> class MyFunction(Function):
... input_widths = [8, 8, 8]
... output_widths = [8, 8]
... @classmethod
... def eval(cls, x, y, k):
... return (y + k, (y + k) ^ x)
>>> x, y, k = DiffVar("x", 8), DiffVar("y", 8), DiffVar("k", 8)
>>> ch = Characteristic(MyFunction, XorDiff, [x, y, k])
>>> smt_problem = SmtProblem(ch, 0)
>>> smt_problem.solve()
True
>>> smt_problem.solve(get_assignment=True) # doctest:+NORMALIZE_WHITESPACE
{'differences': OrderedDict([(x, 0x80), (y, 0x00), (k, 0x80),
(d0, 0x80), (d1, 0x00)]), 'weight': 0,
'op_weights': OrderedDict([(w_ky_d0, 0)])}
"""
sc.reset_env()
pysmt_formula = sc.And(*[bv2pysmt(a) for a in self.assertions])
if not get_assignment:
return sc.is_sat(pysmt_formula, solver_name, logic=logics.QF_BV)
else:
model = sc.get_model(pysmt_formula,
solver_name,
logic=logics.QF_BV)
if model is None:
return None
else:
return self._get_assignment(model)
def _smtlib_cnf(self, filename, logic, res_is_sat):
reset_env()
conv = CNFizer()
smtfile = os.path.join(SMTLIB_DIR, filename)
assert os.path.exists(smtfile)
expr = get_formula_fname(smtfile)
if not logic.quantifier_free:
with self.assertRaises(NotImplementedError):
conv.convert_as_formula(expr)
return
cnf = conv.convert_as_formula(expr)
self.assertValid(Implies(cnf, expr), logic=logic)
res = is_sat(cnf, logic=logic)
self.assertEqual(res, res_is_sat)
def _smtlib_cnf(self, filename, logic, res_is_sat):
reset_env()
conv = CNFizer()
smtfile = os.path.join(SMTLIB_DIR, filename)
assert os.path.exists(smtfile)
expr = get_formula_fname(smtfile)
if not logic.quantifier_free:
with self.assertRaises(NotImplementedError):
conv.convert_as_formula(expr)
return
cnf = conv.convert_as_formula(expr)
self.assertValid(Implies(cnf, expr), logic=logic)
res = is_sat(cnf, logic=logic)
self.assertEqual(res, res_is_sat)
def test_smtlib_multi_msat(self):
from pysmt.test.smtlib.parser_utils import SMTLIB_TEST_FILES, SMTLIB_DIR
# On some platforms (Windows x64) the internal pickling process requires
# quite a lot of recursion...
old_recursion_limit = sys.getrecursionlimit()
sys.setrecursionlimit(999999)
for (logic, f, expected_result) in SMTLIB_TEST_FILES:
smtfile = os.path.join(SMTLIB_DIR, f)
if logic <= QF_UFLIRA:
env = reset_env()
formula = get_formula_fname(smtfile, env)
# Simplifying the formula to reduce its depth to avoid errors on some
# platforms until issue #455 for details.
formula = formula.simplify()
with Portfolio([("msat", {
"random_seed": 1
}), ("msat", {
"random_seed": 17
}), ("msat", {
"random_seed": 42
})],
logic=logic,
environment=env,
incremental=False,
generate_models=False) as s:
res = s.is_sat(formula)
self.assertEqual(expected_result, res, smtfile)
#reset recursion limit
sys.setrecursionlimit(old_recursion_limit)
def runtest(example):
reset_env()
config = Config()
config.safety = True
config.verbosity = 3
config.solver_name = "msat"
config.prove = True
config.vcd = True
config.force_expected = True
status = run_problems("%s/problem.txt" % example, config)
assert status == 0
return status
def test_smtlib_multi_msat(self):
from pysmt.test.smtlib.parser_utils import SMTLIB_TEST_FILES, SMTLIB_DIR
# On some platforms (Windows x64) the internal pickling process requires
# quite a lot of recursion...
old_recursion_limit = sys.getrecursionlimit()
sys.setrecursionlimit(999999)
for (logic, f, expected_result) in SMTLIB_TEST_FILES:
smtfile = os.path.join(SMTLIB_DIR, f)
if logic <= QF_UFLIRA:
env = reset_env()
formula = get_formula_fname(smtfile, env)
# Simplifying the formula to reduce its depth to avoid errors on some
# platforms until issue #455 for details.
formula = formula.simplify()
with Portfolio([("msat", {"random_seed": 1}),
("msat", {"random_seed": 17}),
("msat", {"random_seed": 42})],
logic=logic,
environment=env,
incremental=False,
generate_models=False) as s:
res = s.is_sat(formula)
self.assertEqual(expected_result, res, smtfile)
#reset recursion limit
sys.setrecursionlimit(old_recursion_limit)
def execute_script_fname(smtfile):
"""Read and call a Solver to solve the instance"""
print(smtfile)
reset_env()
assert os.path.exists(smtfile)
parser = SmtLibParser()
solver = NoopSolver(get_env())
start = time.clock()
script = parser.get_script_fname(smtfile)
end = time.clock()
script.evaluate(solver)
res = solver.get_asserted_formula()
assert res is not None
return (smtfile, (end - start))
def execute_script_fname(smtfile, logic, expected_result):
"""Read and call a Solver to solve the instance"""
reset_env()
assert os.path.exists(smtfile), smtfile
parser = SmtLibParser()
script = parser.get_script_fname(smtfile)
try:
log = script.evaluate(Solver(logic=logic))
except NoSolverAvailableError:
raise unittest.SkipTest("No solver for logic %s." % logic)
res = check_sat_filter(log)
if res:
assert expected_result == "sat"
else:
assert expected_result == "unsat"
def execute_script_fname(smtfile, logic, expected_result):
"""Read and call a Solver to solve the instance"""
reset_env()
assert os.path.exists(smtfile), smtfile
parser = SmtLibParser()
script = parser.get_script_fname(smtfile)
try:
log = script.evaluate(Solver(logic=logic))
except NoSolverAvailableError:
raise SkipTest("No solver for logic %s." % logic)
res = check_sat_filter(log)
if res:
assert expected_result == "sat"
else:
assert expected_result == "unsat"
def run_smtlib(self, smtfile, logic, expected_result):
env = reset_env()
formula = get_formula_fname(smtfile, env)
with Portfolio(["cvc4", "msat", "yices"],
logic=logic,
environment=env,
incremental=False,
generate_models=False) as s:
res = s.is_sat(formula)
self.assertEqual(expected_result, res, smtfile)
def run_smtlib(self, smtfile, logic, expected_result):
env = reset_env()
formula = get_formula_fname(smtfile, env)
with Portfolio(["cvc4", "msat", "yices"],
logic=logic,
environment=env,
incremental=False,
generate_models=False) as s:
res = s.is_sat(formula)
self.assertEqual(expected_result, res, smtfile)
def execute_script_fname(smtfile, logic, expected_result):
"""Read and call a Solver to solve the instance"""
reset_env()
Solver = get_env().factory.Solver
parser = SmtLibParser()
script = parser.get_script_fname(smtfile)
try:
log = script.evaluate(Solver(logic=logic, incremental=False,
generate_models=False))
except NoSolverAvailableError:
raise SkipTest("No solver for logic %s." % logic)
except SolverReturnedUnknownResultError:
if not logic.quantifier_free:
warnings.warn("Test (%s, %s) could not be solver due to quantifiers." % (logic, smtfile))
return
raise
res = check_sat_filter(log)
assert expected_result == res
def run_problems(problems, config):
reset_env()
Logger.verbosity = config.verbosity
pbms = Problems()
psol = ProblemSolver()
pbms.load_problems(problems)
psol.solve_problems(pbms, config)
global_status = 0
Logger.log("\n*** SUMMARY ***", 0)
for pbm in pbms.problems:
unk_k = "" if pbm.status != VerificationStatus.UNK else "\nBMC depth: %s" % pbm.bmc_length
Logger.log("\n** Problem %s **" % (pbm.name), 0)
Logger.log("Description: %s" % (pbm.description), 0)
Logger.log("Result: %s%s" % (pbm.status, unk_k), 0)
if (pbm.expected is not None):
expected = VerificationStatus.convert(pbm.expected) == pbm.status
Logger.log("Expected: %s" % ("OK" if expected else "WRONG"), 0)
if not expected:
global_status = 1
assert not (config.force_expected and (pbm.expected is None))
prefix = config.prefix if config.prefix is not None else pbm.trace_prefix
if (pbm.verification != VerificationType.SIMULATION) and (
pbm.status == VerificationStatus.FALSE):
print_trace("Counterexample", pbm.trace, pbm.name, prefix)
if (pbm.verification == VerificationType.SIMULATION) and (
pbm.status == VerificationStatus.TRUE):
print_trace("Execution", pbm.trace, pbm.name, prefix)
if pbm.time:
Logger.log("Time: %.2f sec" % (pbm.time), 0)
return global_status
def test_vmt(self):
reset_env()
parser = SmtLibParser()
fname = os.path.join(SMTLIB_DIR, "small_set/vmt/c432_0f.vmt")
script = parser.get_script_fname(fname)
ann = script.annotations
self.assertIn("A_1__AT0 ->", str(ann))
a1 = Symbol("A_1__AT0")
self.assertIn(a1, ann)
self.assertTrue(ann.has_annotation(a1, "next"))
self.assertFalse(ann.has_annotation(a1, "non-existent"))
self.assertTrue(ann.has_annotation(a1, "next", "A_1__AT1"))
self.assertFalse(ann.has_annotation(a1, "next", "non-existent"))
self.assertIn("A_1__AT1", ann.annotations(a1)["next"])
curr_a1 = ann.all_annotated_formulae("next", "A_1__AT1")
self.assertEqual(curr_a1, set([a1]))
def test_vmt(self):
reset_env()
parser = SmtLibParser()
fname = os.path.join(SMTLIB_DIR, "small_set/vmt/c432_0f.vmt")
script = parser.get_script_fname(fname)
ann = script.annotations
self.assertIn("A_1__AT0 ->", str(ann))
a1 = Symbol("A_1__AT0")
self.assertIn(a1, ann)
self.assertTrue(ann.has_annotation(a1, "next"))
self.assertFalse(ann.has_annotation(a1, "non-existent"))
self.assertTrue(ann.has_annotation(a1, "next", "A_1__AT1"))
self.assertFalse(ann.has_annotation(a1, "next", "non-existent"))
self.assertIn("A_1__AT1", ann.annotations(a1)["next"])
self.assertIn("A_1__AT1", ann[a1]["next"])
curr_a1 = ann.all_annotated_formulae("next", "A_1__AT1")
self.assertEqual(curr_a1, set([a1]))
def test_smtlib_multi_msat(self):
from pysmt.test.smtlib.parser_utils import SMTLIB_TEST_FILES, SMTLIB_DIR
for (logic, f, expected_result) in SMTLIB_TEST_FILES:
smtfile = os.path.join(SMTLIB_DIR, f)
if logic <= QF_UFLIRA:
env = reset_env()
formula = get_formula_fname(smtfile, env)
with Portfolio([("msat", {"random_seed": 1}),
("msat", {"random_seed": 17}),
("msat", {"random_seed": 42})],
logic=logic,
environment=env,
incremental=False,
generate_models=False) as s:
res = s.is_sat(formula)
result = "sat" if res else "unsat"
self.assertEqual(expected_result, result, smtfile)
def test_smtlib_multi_msat(self):
from pysmt.test.smtlib.parser_utils import SMTLIB_TEST_FILES, SMTLIB_DIR
for (logic, f, expected_result) in SMTLIB_TEST_FILES:
smtfile = os.path.join(SMTLIB_DIR, f)
if logic <= QF_UFLIRA:
env = reset_env()
formula = get_formula_fname(smtfile, env)
with Portfolio([("msat", {
"random_seed": 1
}), ("msat", {
"random_seed": 17
}), ("msat", {
"random_seed": 42
})],
logic=logic,
environment=env,
incremental=False,
generate_models=False) as s:
res = s.is_sat(formula)
self.assertEqual(expected_result, res, smtfile)
def pysmt_formula_size(self):
"""The size of the underlying bit-vector formula according to pySMT."""
sc.reset_env()
pysmt_formula = sc.And(*[bv2pysmt(a) for a in self.assertions])
return sc.get_formula_size(pysmt_formula)
def test_new_node_type(self):
old = list(all_types())
idx = new_node_type(node_str="xor")
self.assertIsNotNone(idx)
self.assertNotIn(idx, old)
with self.assertRaises(AssertionError):
new_node_type(idx)
XOR = idx
# Ad-hoc method to handle printing of the new node
def hrprinter_walk_xor(self, formula):
self.stream.write("(")
yield formula.arg(0)
self.stream.write(" *+* ")
yield formula.arg(1)
self.stream.write(")")
SimpleTypeChecker.walk_xor = SimpleTypeChecker.walk_bool_to_bool
HRPrinter.walk_xor = hrprinter_walk_xor
# Reset the env to recreate the TypeChecker and HRPrinter
reset_env()
# Shortcuts for function in env
create_node = get_env().formula_manager.create_node
# Create a test node (This implicitly calls the Type-checker)
x = Symbol("x")
f1 = create_node(node_type=XOR, args=(x,x))
self.assertIsNotNone(f1)
# String conversion should use the function defined above.
s_f1 = str(f1)
self.assertEqual(s_f1, "(x *+* x)")
# We did not define an implementation for the Simplifier
with self.assertRaises(UnsupportedOperatorError):
f1.simplify()
# Clean-up
del SimpleTypeChecker.walk_xor
del HRPrinter.walk_xor
class MySimpleTypeChecker(SimpleTypeChecker):
walk_xor = SimpleTypeChecker.walk_bool_to_bool
class MyHRPrinter(HRPrinter):
def walk_xor(self, formula):
return self.walk_nary(formula, " *+* ")
class MyHRSerializer(HRSerializer):
PrinterClass = MyHRPrinter
class MyEnv(Environment):
TypeCheckerClass = MySimpleTypeChecker
HRSerializerClass = MyHRSerializer
with MyEnv() as myenv:
create_node = myenv.formula_manager.create_node
# Create a test node (This implicitly calls the Type-checker)
x = Symbol("x")
f1 = create_node(node_type=XOR, args=(x,x))
self.assertIsNotNone(f1)
# String conversion should use the function defined above.
s_f1 = str(f1)
self.assertEqual(s_f1, "(x *+* x)")
# We did not define an implementation for the Simplifier
with self.assertRaises(UnsupportedOperatorError):
f1.simplify()
return
def setUp(self):
self.env = reset_env()
def parse(self, fname):
reset_env()
parser = SmtLibParser()
script = parser.get_script_fname(fname)
self.assertIsNotNone(script)
return script
def run_verification(config):
reset_env()
Logger.verbosity = config.verbosity
coreir_parser = None
ets_parser = None
sts_parser = None
if config.ltl:
ltl_reset_env()
hts = HTS("Top level")
if config.strfiles[0][-4:] != ".pkl":
ps = ProblemSolver()
(hts, invar_props,
ltl_props) = ps.parse_model("./",
config.strfiles,
config.abstract_clock,
config.symbolic_init,
deterministic=config.deterministic,
boolean=config.boolean,
no_clock=config.no_clock)
config.parser = ps.parser
if config.pickle_file:
Logger.msg("Pickling model to %s\n" % (config.pickle_file), 1)
sys.setrecursionlimit(50000)
with open(config.pickle_file, "wb") as f:
pickle.dump(hts, f)
else:
if config.pickle_file:
raise RuntimeError("Don't need to re-pickle the input file %s" %
(config.strfile))
Logger.msg("Loading pickle file %s\n" % (config.strfile), 0)
with open(config.pickle_file, "rb") as f:
hts = pickle.load(f)
Logger.log("DONE", 0)
printsmv = True
mc_config = MCConfig()
sparser = StringParser()
sparser.remap_or2an = config.parser.remap_or2an
ltlparser = LTLParser()
# if equivalence checking wait to add assumptions to combined system
if config.assumptions is not None and config.equivalence is None:
Logger.log("Adding %d assumptions... " % len(config.assumptions), 1)
assumps = [t[1] for t in sparser.parse_formulae(config.assumptions)]
hts.assumptions = assumps
lemmas = None
if config.lemmas is not None:
Logger.log("Adding %d lemmas... " % len(config.lemmas), 1)
parsed_formulae = sparser.parse_formulae(config.lemmas)
if list(set([t[2] for t in parsed_formulae]))[0][0] != False:
Logger.error("Lemmas do not support \"next\" operators")
lemmas = [t[1] for t in parsed_formulae]
hts.lemmas = lemmas
mc_config.smt2file = config.smt2file
mc_config.full_trace = config.full_trace
mc_config.trace_vars_change = config.trace_vars_change
mc_config.trace_all_vars = config.trace_all_vars
mc_config.prefix = config.prefix
mc_config.strategy = config.strategy
mc_config.skip_solving = config.skip_solving
mc_config.map_function = config.parser.remap_an2or
mc_config.solver_name = config.solver_name
mc_config.vcd_trace = config.vcd
mc_config.prove = config.prove
mc_config.incremental = config.incremental
if config.ltl:
bmc_ltl = BMCLTL(hts, mc_config)
else:
bmc_safety = BMCSafety(hts, mc_config)
if config.translate:
Logger.log("Writing system to \"%s\"" % (config.translate), 0)
printer = PrintersFactory.printer_by_name(config.printer)
props = []
if config.ltl:
props += ltlparser.parse_formulae(config.properties)
props += [(str(p), p, None) for p in ltl_props]
else:
props += sparser.parse_formulae(config.properties)
props += [(str(p), p, None) for p in invar_props]
with open(config.translate, "w") as f:
f.write(printer.print_hts(hts, props))
if config.simulate:
count = 0
if config.properties is None:
props = [("True", TRUE(), None)]
else:
props = sparser.parse_formulae(config.properties)
for (strprop, prop, _) in props:
Logger.log("Simulation for property \"%s\":" % (strprop), 0)
res, trace = bmc_safety.simulate(prop, config.bmc_length)
if res == VerificationStatus.TRUE:
count += 1
print_trace("Execution", trace, count, config.prefix)
else:
Logger.log("No execution found", 0)
if config.safety:
count = 0
props = sparser.parse_formulae(config.properties)
props += [(str(p), p, None) for p in invar_props]
if len(props) == 0:
Logger.warning("Safety verification requires at least a property")
for (strprop, prop, _) in props:
Logger.log("Safety verification for property \"%s\":" % (strprop),
0)
res, trace, t = bmc_safety.safety(prop, config.bmc_length,
config.bmc_length_min)
Logger.log("\nProperty is %s" % res, 0)
if res == VerificationStatus.FALSE:
count += 1
print_trace("Counterexample", trace, count, config.prefix)
return 0
if config.equivalence or config.fsm_check:
if config.equivalence:
parser2 = CoreIRParser(config.abstract_clock, config.symbolic_init,
config.run_passes)
Logger.msg("Parsing file \"%s\"... " % (config.equivalence), 0)
hts2 = parser2.parse_file(config.equivalence)
Logger.log("DONE", 0)
symb = " (symbolic init)" if config.symbolic_init else ""
Logger.log(
"Equivalence checking%s with k=%s:" %
(symb, config.bmc_length), 0)
if Logger.level(1):
print(hts2.print_statistics("System 2", Logger.level(2)))
else:
hts2 = hts
# TODO: Make incremental solving optional
htseq, miter_out = Miter.combine_systems(hts, hts2, config.bmc_length,
config.symbolic_init,
config.properties, True)
if config.assumptions is not None:
Logger.log(
"Adding %d assumptions to combined system... " %
len(config.assumptions), 1)
assumps = [
t[1] for t in sparser.parse_formulae(config.assumptions)
]
htseq.assumptions = assumps
# create bmc object for combined system
bmcseq = BMC(htseq, mc_config)
res, trace, t = bmcseq.safety(miter_out, config.bmc_length,
config.bmc_length_min)
msg = "Systems are %s equivalent" if config.equivalence else "System is%s deterministic"
if res == VerificationStatus.FALSE:
Logger.log(msg % (" not"), 0)
print_trace("Counterexample", trace, 1, config.prefix)
elif res == VerificationStatus.UNK:
if config.symbolic_init:
# strong equivalence with symbolic initial state
Logger.log(msg % (""), 0)
else:
Logger.log(msg % ("") + " up to k=%i" % t, 0)
else:
Logger.log(msg % ("") + " up to k=%i" % t, 0)
if config.ltl:
count = 0
props = ltlparser.parse_formulae(config.properties)
props += [(str(p), p, None) for p in ltl_props]
if len(props) == 0:
Logger.warning("LTL verification requires at least a property")
for (strprop, prop, _) in props:
Logger.log("LTL verification for property \"%s\":" % (strprop), 0)
res, trace, t = bmc_ltl.ltl(prop, config.bmc_length,
config.bmc_length_min)
Logger.log("\nProperty is %s" % res, 0)
if res == VerificationStatus.FALSE:
count += 1
print_trace("Counterexample", trace, count, config.prefix)
return 0
def solve(self, solver_name=None, get_assignment=False):
"""Solve the pair of SMT problems simultaneously.
Return whether the pair of decision problems are satisfiable.
If get_assignment is set to True, solve() returns an assignment of
the variables that makes the pair of SMT problems satisfiable
(if one of the problems is unsatisfiable, None is returned).
This assignment is returned as a pair of dictionaries, where
the first dictionary is the assignment of the inner SMT problem
and the second dictionary is the assignment of the outer SMT problem.
>>> from arxpy.bitvector.operation import RotateLeft
>>> from arxpy.bitvector.function import Function, CompositeFunction
>>> from arxpy.diffcrypt.difference import XorDiff, DiffVar
>>> from arxpy.diffcrypt.characteristic import Characteristic, CompositeCh
>>> class MyInner(Function):
... input_widths = [8]
... output_widths = [8, 8]
... @classmethod
... def eval(cls, k):
... return (k, RotateLeft(k, 1))
>>> class MyOuter(Function):
... input_widths = [8, 8, 8, 8]
... output_widths = [8, 8]
... @classmethod
... def eval(cls, x, y, k0, k1):
... for ki in [k0, k1]:
... x, y = y + ki, (y + ki) ^ x
... return x, y
>>> class MyComposite(CompositeFunction):
... input_widths = [8, 8, 8]
... output_widths = [8, 8]
... inner_func = MyInner
... outer_func = MyOuter
>>> x, y, k = DiffVar("x", 8), DiffVar("y", 8), DiffVar("k", 8)
>>> ch = CompositeCh(MyComposite, XorDiff, [x, y, k])
>>> smt_problem = CompositeSmtProblem(ch, [1, 1])
>>> smt_problem.solve()
True
>>> inner_assig, outer_assig = smt_problem.solve(get_assignment=True)
>>> inner_assig # doctest:+NORMALIZE_WHITESPACE
{'differences': OrderedDict([(k, 0x40), (i0, 0x80)]),
'weight': 0, 'op_weights': OrderedDict()}
>>> outer_assig # doctest:+NORMALIZE_WHITESPACE
{'differences': OrderedDict([(x, 0x40), (y, 0x00), (k, 0x40),
(i0, 0x80), (o0, 0x40), (o1, 0x00), (o2, 0x80), (o3, 0xc0)]),
'weight': 1, 'op_weights': OrderedDict([(w_ky_o0, 1),
(w_i0o1_o2, 0)])}
"""
sc.reset_env()
i_f = sc.And(*[bv2pysmt(a) for a in self.inner_problem.assertions])
o_f = sc.And(*[bv2pysmt(a) for a in self.outer_problem.assertions])
pysmt_formula = sc.And(i_f, o_f)
if not get_assignment:
return sc.is_sat(pysmt_formula, solver_name, logic=logics.QF_BV)
else:
model = sc.get_model(pysmt_formula,
solver_name,
logic=logics.QF_BV)
if model is None:
return None
else:
inner_assig = self.inner_problem._get_assignment(model)
outer_assig = self.outer_problem._get_assignment(model)
return inner_assig, outer_assig
def parse(self, fname):
reset_env()
parser = SmtLibParser()
script = parser.get_script_fname(fname)
self.assertIsNotNone(script)
