def and_properties(properties) -> SpecProperty:
property_expressions = [
BinOp('->', and_expressions(p.assumptions),
and_expressions(p.guarantees)) for p in properties
]
return SpecProperty([Bool(True)], [and_expressions(property_expressions)])
def and_properties(properties) -> SpecProperty:
property_expressions = [BinOp('->',
and_expressions(p.assumptions),
and_expressions(p.guarantees))
for p in properties]
return SpecProperty([Bool(True)], [and_expressions(property_expressions)])
def instantiate_property(self, prop, cutoff):
'''
Instantiates the given property
:param prop: See ``properties`` in :func:`instantiate_properties`
:param cutoff:
'''
# extract assumptions and guarantees
assumptions, guarantee = prop[:2]
LOG.debug(prop)
# there is no special cut-off for architecture guarantees
# and architecture properties
use_default_cutoff = len(prop) <= 2 or prop[3]
guarantee_cutoff = cutoff if use_default_cutoff else prop[2]
# avoid using a cut-off that requires more instances than we want
if use_default_cutoff:
LOG.info("Ignore cut-off for property %s because %s > %s",
str(prop[0]) + " -> " + str(prop[1]), prop[2], cutoff)
ast_visitor = ASTInstantiateFormulaVisitor(self.spec)
assumption_guarantee_instances_dict = \
{i: range(guarantee_cutoff[i])
for i in range(len(guarantee_cutoff))}
assumption_instances_dict = assumption_guarantee_instances_dict
# instantiate guarantees
guarantee_instances_dict = assumption_guarantee_instances_dict
if not isinstance(guarantee, ArchitectureGuarantee) \
and not use_default_cutoff:
# get instance dict for guarantee according to cut-off
guarantee_instances_dict = \
self.arch.determine_guarantee_instances_dict(guarantee)
instantiated_guarantees = and_expressions(
[conjunct for conjunct in
ast_visitor.visit(guarantee, guarantee_instances_dict)])
LOG.debug("Guarantees instantiated: %s", instantiated_guarantees)
instantiated_assumptions = None
if len(assumptions) and \
self.is_liveness_property(instantiated_guarantees):
# instantiate assumptions
instantiated_assumptions = \
and_expressions([conjunct for formula in assumptions
for conjunct in
ast_visitor.visit(formula,
assumption_instances_dict)])
LOG.debug("Assumptions instantiated: %s", instantiated_assumptions)
# return implication or just guarantees
if instantiated_assumptions is not None:
return BinOp('->', instantiated_assumptions,
instantiated_guarantees)
else:
return instantiated_guarantees
def to_boolean_nusmv(lts: LTS, specification: SpecProperty) -> str:
nof_state_bits = int(max(1, math.ceil(math.log(len(lts.states), 2))))
bits_by_state = dict((state, bin_fixed_list(i, nof_state_bits))
for (i, state) in enumerate(sorted(lts.states)))
state_bits = lmap(_ith_state_bit, range(nof_state_bits))
_assert_no_intersection(state_bits,
list(lts.input_signals) + lts.output_signals)
dot_lines = StrAwareList()
dot_lines += 'MODULE main'
dot_lines += 'IVAR'
dot_lines += [
' {signal} : boolean;'.format(signal=s.name)
for s in lts.input_signals
]
dot_lines += 'VAR'
dot_lines += [' {si} : boolean;'.format(si=si) for si in state_bits]
dot_lines += 'DEFINE'
dot_lines += [
' {out_name} := {formula} ;'.format(out_name=out_name,
formula=_get_formula(
out_name, out_model,
bits_by_state))
for (out_name, out_model) in lts.model_by_name.items()
]
dot_lines += 'ASSIGN'
for i, sb in enumerate(state_bits):
sb_init = str(bits_by_state[list(lts.init_states)[0]][i]).upper()
dot_lines += ' init({sb}) := {init_sb};'.format(sb=sb,
init_sb=sb_init)
dot_lines += ' next({sb}) := '.format(sb=sb)
dot_lines += ' case'
for (label, next_state) in lts.tau_model.items():
sb_next = str(bits_by_state[next_state][i]).upper()
dot_lines += ' {formula} : {next_state};'.format(
formula=_clause_to_formula(label, bits_by_state),
next_state=sb_next)
dot_lines += ' TRUE : FALSE;' # default: unreachable states, don't care
dot_lines += ' esac;'
expr = BinOp('->', and_expressions(specification.assumptions),
and_expressions(specification.guarantees))
expr = WeakToUntilConverterVisitor().dispatch(
expr) # SMV does not have Weak until
dot_lines += 'LTLSPEC ' + AstToSmvProperty().dispatch(expr)
return '\n'.join(dot_lines)
def to_boolean_nusmv(lts:LTS, specification:SpecProperty) -> str:
nof_state_bits = int(max(1, math.ceil(math.log(len(lts.states), 2))))
bits_by_state = dict((state, bin_fixed_list(i, nof_state_bits))
for (i,state) in enumerate(sorted(lts.states)))
state_bits = lmap(_ith_state_bit, range(nof_state_bits))
_assert_no_intersection(state_bits, list(lts.input_signals) + lts.output_signals)
dot_lines = StrAwareList()
dot_lines += 'MODULE main'
dot_lines += 'IVAR'
dot_lines += [' {signal} : boolean;'.format(signal=s.name) for s in lts.input_signals]
dot_lines += 'VAR'
dot_lines += [' {si} : boolean;'.format(si=si) for si in state_bits]
dot_lines += 'DEFINE'
dot_lines += [' {out_name} := {formula} ;'.format(out_name=out_name,
formula=_get_formula(out_name, out_model, bits_by_state))
for (out_name,out_model) in lts.model_by_name.items()]
dot_lines += 'ASSIGN'
for i,sb in enumerate(state_bits):
sb_init = str(bits_by_state[list(lts.init_states)[0]][i]).upper()
dot_lines += ' init({sb}) := {init_sb};'.format(sb=sb, init_sb=sb_init)
dot_lines += ' next({sb}) := '.format(sb=sb)
dot_lines += ' case'
for (label,next_state) in lts.tau_model.items():
sb_next = str(bits_by_state[next_state][i]).upper()
dot_lines += ' {formula} : {next_state};'.format(formula=_clause_to_formula(label, bits_by_state),
next_state=sb_next)
dot_lines += ' TRUE : FALSE;' # default: unreachable states, don't care
dot_lines += ' esac;'
expr = BinOp('->', and_expressions(specification.assumptions), and_expressions(specification.guarantees))
expr = WeakToUntilConverterVisitor().dispatch(expr) # SMV does not have Weak until
dot_lines += 'LTLSPEC ' + AstToSmvProperty().dispatch(expr)
return '\n'.join(dot_lines)
def _get_log_encoded_expr(signal:QuantifiedSignal, new_sched_signal_name:str, cutoff:int) -> Expr:
assert len(signal.binding_indices) == 1
proc_index = signal.binding_indices[0]
nof_sched_bits = int(max(1, math.ceil(math.log(cutoff, 2))))
bits = bin_fixed_list(proc_index, nof_sched_bits)
#TODO: use quantified signal or signal?
conjuncts = [BinOp('=',
QuantifiedSignal(new_sched_signal_name, bit_index),
Number(1 if bit_value else 0))
for bit_index, bit_value in enumerate(bits)]
conjunction = and_expressions(conjuncts)
return conjunction
def _instantiate_expr(expr:Expr, cutoff: int, forbid_zero_index:bool) -> Expr:
return and_expressions(_instantiate_expr2(expr, cutoff, forbid_zero_index))
def _convert_conjunction_to_str(property: SpecProperty) -> str:
result_str = _get_sorted_conjuncts_str(and_expressions(property.assumptions)) + _get_sorted_conjuncts_str(
and_expressions(property.guarantees)
)
return result_str
def expr_from_property(property: SpecProperty) -> Expr:
return BinOp('->', and_expressions(property.assumptions),
and_expressions(property.guarantees))
def to_expr(spec_property: SpecProperty) -> Expr:
return BinOp('->', and_expressions(spec_property.assumptions),
and_expressions(spec_property.guarantees))
def _convert_conjunction_to_str(property: SpecProperty) -> str:
result_str = _get_sorted_conjuncts_str(and_expressions(property.assumptions)) + \
_get_sorted_conjuncts_str(and_expressions(property.guarantees))
return result_str
def expr_from_property(property:SpecProperty) -> Expr:
return BinOp('->', and_expressions(property.assumptions),
and_expressions(property.guarantees))
def to_expr(spec_property:SpecProperty) -> Expr:
return BinOp('->', and_expressions(spec_property.assumptions),
and_expressions(spec_property.guarantees))
