def export_rules(self, formula):
ex = self.export_expr
uvars, formula = self.extract_universal(formula)
precondition = None
if formula.is_implies():
precondition = formula.arg(0)
formula = formula.arg(1)
if formula.is_equals() or formula.is_iff():
if uvars:
re = {v: self._qvar_from_symbol(v) for v in uvars}
formula = formula.substitute(re)
uvars = re.values()
uvars = set(uvars)
fv = lambda phi: get_free_variables(phi) & uvars
lhs, rhs = formula.args()
for lhs, rhs in [(lhs, rhs), (rhs, lhs)]:
if ((lhs not in uvars) and # avoid e.g. x => x + 0
fv(lhs) >= fv(rhs)):
if precondition is not None:
yield SExpression([
'=>',
self._fresh('rule%d'),
ex(Implies(precondition, formula))
])
else:
yield SExpression(
['=>',
self._fresh('rule%d'),
ex(lhs),
ex(rhs)])
elif not (formula.is_not()
and self.extract_universal(formula.args()[0])[0]):
# this is either a not exp or an expr
if uvars:
re = {v: self._qvar_from_symbol(v) for v in uvars}
formula = formula.substitute(re)
uvars = re.values()
uvars = set(uvars)
equals_to = TRUE()
if formula.is_not():
formula = formula.args()[0]
equals_to = FALSE()
op = '<=>'
if uvars:
op = '=>'
if precondition is not None:
yield SExpression([
op,
self._fresh('rule%d'),
ex(Implies(precondition, Iff(formula, equals_to)))
])
else:
yield SExpression(
[op, self._fresh('rule%d'),
ex(formula),
ex(equals_to)])
def test_get_free_vars(self):
x, y = Symbol("x"), Symbol("y")
f = Implies(x, And(y, Not(x)))
s = get_free_variables(f)
self.assertEqual(set([x, y]), s)
def test_get_free_vars(self):
x, y = Symbol("x"), Symbol("y")
f = Implies(x, And(y, Not(x)))
s = get_free_variables(f)
self.assertEqual(set([x, y]), s)
def solve_problems(self, problems_config: ProblemsManager) -> None:
general_config = problems_config.general_config
model_extension = general_config.model_extension
assume_if_true = general_config.assume_if_true
self.sparser = StringParser(general_config)
self.lparser = LTLParser()
self.coi = ConeOfInfluence()
modifier = None
if general_config.model_extension is not None:
modifier = lambda hts: ModelExtension.extend(
hts,
ModelModifiersFactory.modifier_by_name(general_config.
model_extension))
# generate main system system
hts, invar_props, ltl_props = self.parse_model(
general_config.model_files, problems_config.relative_path,
general_config, "System 1", modifier)
# Generate second models if any are necessary
for problem in problems_config.problems:
if problem.verification == VerificationType.EQUIVALENCE:
if problem.equal_to is None:
raise RuntimeError(
"No second model for equivalence "
"checking provided for problem {}".format(
problem.name))
hts2, _, _ = self.parse_model(problem.equal_to,
problems_config.relative_path,
general_config, "System 2",
modifier)
problems_config.add_second_model(problem, hts2)
# TODO : contain these types of passes in functions
# they should be registered as passes
if general_config.init is not None:
iparser = InitParser()
init_hts, inv_a, ltl_a = iparser.parse_file(
general_config.init, general_config)
assert inv_a is None and ltl_a is None, "Not expecting assertions from init state file"
# remove old inits
for ts in hts.tss:
ts.init = TRUE()
hts.combine(init_hts)
hts.single_init(rebuild=True)
# set default bit-wise initial values (0 or 1)
if general_config.default_initial_value is not None:
def_init_val = int(general_config.default_initial_value)
try:
if int(def_init_val) not in {0, 1}:
raise RuntimeError
except:
raise RuntimeError(
"Expecting 0 or 1 for default_initial_value,"
"but received {}".format(def_init_val))
def_init_ts = TS("Default initial values")
new_init = []
initialized_vars = get_free_variables(hts.single_init())
state_vars = hts.state_vars
num_def_init_vars = 0
num_state_vars = len(state_vars)
const_arr_supported = True
if hts.logic == L_ABV:
for p in problems_config.problems:
if p.solver_name not in CONST_ARRAYS_SUPPORT:
const_arr_supported = False
Logger.warning(
"Using default_initial_value with arrays, "
"but one of the selected solvers, "
"{} does not support constant arrays. "
"Any assumptions on initial array values will "
"have to be done manually".format(
problem.solver_name))
break
for sv in state_vars - initialized_vars:
if sv.get_type().is_bv_type():
width = sv.get_type().width
if int(def_init_val) == 1:
val = BV((2**width) - 1, width)
else:
val = BV(0, width)
num_def_init_vars += 1
elif sv.get_type().is_array_type() and \
sv.get_type().elem_type.is_bv_type() and \
const_arr_supported:
svtype = sv.get_type()
width = svtype.elem_type.width
if int(def_init_val) == 1:
val = BV((2**width) - 1, width)
else:
val = BV(0, width)
# create a constant array with a default value
val = Array(svtype.index_type, val)
else:
continue
def_init_ts.add_state_var(sv)
new_init.append(EqualsOrIff(sv, val))
def_init_ts.set_behavior(simplify(And(new_init)), TRUE(), TRUE())
hts.add_ts(def_init_ts)
Logger.msg(
"Set {}/{} state elements to zero "
"in initial state\n".format(num_def_init_vars, num_state_vars),
1)
problems_config.hts = hts
# TODO: Update this so that we can control whether embedded assertions are solved automatically
if not general_config.skip_embedded:
for invar_prop in invar_props:
problems_config.add_problem(
verification=VerificationType.SAFETY,
name=invar_prop[0],
description=invar_prop[1],
properties=invar_prop[2])
self.properties.append(invar_prop[2])
for ltl_prop in ltl_props:
problems_config.add_problem(verification=VerificationType.LTL,
name=invar_prop[0],
description=invar_prop[1],
properties=invar_prop[2])
self.properties.append(ltl_prop[2])
Logger.log(
"Solving with abstract_clock=%s, add_clock=%s" %
(general_config.abstract_clock, general_config.add_clock), 2)
# ensure the miter_out variable exists
miter_out = None
for problem in problems_config.problems:
if problem.name is not None:
Logger.log(
"\n*** Analyzing problem \"%s\" ***" % (problem.name), 1)
Logger.msg("Solving \"%s\" " % problem.name, 0,
not (Logger.level(1)))
# apply parametric behaviors (such as toggling the clock)
# Note: This is supposed to be *before* creating the combined system for equivalence checking
# we want this assumption to be applied to both copies of the clock
problem_hts = ParametricBehavior.apply_to_problem(
problems_config.hts, problem, general_config, self.model_info)
if problem.verification == VerificationType.EQUIVALENCE:
hts2 = problems_config.get_second_model(problem)
problem_hts, miter_out = Miter.combine_systems(
hts, hts2, problem.bmc_length,
general_config.symbolic_init, problem.properties, True)
try:
# convert the formulas to PySMT FNodes
# lemmas, assumptions and precondition always use the regular parser
lemmas, assumptions, precondition = self.convert_formulae(
[
problem.lemmas, problem.assumptions,
problem.precondition
],
parser=self.sparser,
relative_path=problems_config.relative_path)
if problem.verification != VerificationType.LTL:
parser = self.sparser
else:
parser = self.lparser
prop = None
if problem.properties is not None:
prop = self.convert_formula(
problem.properties,
relative_path=problems_config.relative_path,
parser=parser)
assert len(prop) == 1, "Properties should already have been split into " \
"multiple problems but found {} properties here".format(len(prop))
prop = prop[0]
self.properties.append(prop)
else:
if problem.verification == VerificationType.SIMULATION:
prop = TRUE()
elif (problem.verification
is not None) and (problem.verification !=
VerificationType.EQUIVALENCE):
Logger.error(
"Property not provided for problem {}".format(
problem.name))
if problem.verification == VerificationType.EQUIVALENCE:
assert miter_out is not None
# set property to be the miter output
# if user provided a different equivalence property, this has already
# been incorporated in the miter_out
prop = miter_out
# reset the miter output
miter_out = None
if precondition:
assert len(precondition
) == 1, "There should only be one precondition"
prop = Implies(precondition[0], prop)
# TODO: keep assumptions separate from the hts
# IMPORTANT: CLEAR ANY PREVIOUS ASSUMPTIONS AND LEMMAS
# This was previously done in __solve_problem and has been moved here
# during the frontend refactor in April 2019
# this is necessary because the problem hts is just a reference to the
# overall (shared) HTS
problem_hts.assumptions = None
problem_hts.lemmas = None
# Compute the Cone Of Influence
# Returns a *new* hts (not pointing to the original one anymore)
if problem.coi:
if Logger.level(2):
timer = Logger.start_timer("COI")
hts = self.coi.compute(hts, prop)
if Logger.level(2):
Logger.get_timer(timer)
if general_config.time:
timer_solve = Logger.start_timer(
"Problem %s" % problem.name, False)
status, trace, traces, region = self.__solve_problem(
problem_hts, prop, lemmas, assumptions, problem)
# set status for this problem
problems_config.set_problem_status(problem, status)
# TODO: Determine whether we need both trace and traces
assert trace is None or traces is None, "Expecting either a trace or a list of traces"
if trace is not None:
problem_traces = self.__process_trace(
hts, trace, general_config, problem)
problems_config.set_problem_traces(problem, problem_traces)
if traces is not None:
traces_to_add = []
for trace in traces:
problem_trace = self.__process_trace(
hts, trace, general_config, problem)
for pt in problem_trace:
traces_to_add.append(pt)
problems_config.set_problem_traces(problem, traces_to_add)
if problem.verification == VerificationType.PARAMETRIC:
assert region is not None
problems_config.set_problem_region(problem, region)
if status is not None:
Logger.msg(" %s\n" % status, 0, not (Logger.level(1)))
if (assume_if_true) and \
(status == VerificationStatus.TRUE) and \
(problem.assumptions == None) and \
(problem.verification == VerificationType.SAFETY):
# TODO: relax the assumption on problem.assumptions
# can still add it, just need to make it an implication
ass_ts = TS("Previous assumption from property")
if TS.has_next(prop):
ass_ts.trans = prop
else:
ass_ts.invar = prop
# add assumptions to main system
problem_hts.reset_formulae()
problem_hts.add_ts(ass_ts)
if general_config.time:
problems_config.set_problem_time(
problem, Logger.get_timer(timer_solve, False))
except KeyboardInterrupt as e:
Logger.msg("\b\b Skipped!\n", 0)
def iter_used_symbols(self):
for cmd in self.script:
if cmd.name == 'assert':
for v in get_free_variables(cmd.args[0]):
yield v
