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))