def example_analysis_02(): path = stormpy.examples.files.prism_dtmc_die prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=7 & d=2]" properties = stormpy.parse_properties(formula_str, prism_program) model = stormpy.build_symbolic_model(prism_program, properties) result = stormpy.model_checking(model, properties[0]) filter = stormpy.create_filter_initial_states_symbolic(model) result.filter(filter) assert result.min == result.max print(result.min) # Create an auxiliary mapping to build expressions that matches some state. variables = dict() for m in prism_program.modules: for v in m.integer_variables: variables[v.name] = v.expression_variable.get_expression() expr_manager = prism_program.expression_manager expr_for_state_1 = Expression.Conjunction([ Expression.Eq(variables["s"], expr_manager.create_integer(1)), Expression.Eq(variables["d"], expr_manager.create_integer(0)) ]) expr_for_state_2 = Expression.And( Expression.Eq(variables["s"], expr_manager.create_integer(4)), Expression.Eq(variables["d"], expr_manager.create_integer(0))) result = stormpy.model_checking(model, properties[0]) cached_res = result.clone() cached_res.filter(stormpy.create_filter_symbolic(model, expr_for_state_1)) print(cached_res.min) result.filter(stormpy.create_filter_symbolic(model, expr_for_state_2)) assert result.min == result.max print(result.min)
def test_build_dtmc_from_prism_program(self): program = stormpy.parse_prism_program(get_example_path("dtmc", "die.pm")) model = stormpy.build_symbolic_model(program) assert model.nr_states == 13 assert model.nr_transitions == 20 assert model.model_type == stormpy.ModelType.DTMC assert not model.supports_parameters assert type(model) is stormpy.SymbolicSylvanDtmc
def test_build_mdp(self): program = stormpy.parse_prism_program(get_example_path("mdp", "two_dice.nm")) formulas = stormpy.parse_properties_for_prism_program("P=? [ F \"two\" ]", program) model = stormpy.build_symbolic_model(program, formulas) assert model.nr_states == 169 assert model.nr_transitions == 435 assert model.model_type == stormpy.ModelType.MDP assert not model.supports_parameters assert type(model) is stormpy.SymbolicSylvanMdp
def test_build_ctmc(self): program = stormpy.parse_prism_program(get_example_path("ctmc", "polling2.sm"), True) formulas = stormpy.parse_properties_for_prism_program("P=? [ F<=3 \"target\" ]", program) model = stormpy.build_symbolic_model(program, formulas) assert model.nr_states == 12 assert model.nr_transitions == 21 assert model.model_type == stormpy.ModelType.CTMC assert not model.supports_parameters assert type(model) is stormpy.SymbolicSylvanCtmc
def test_reduce_to_state_based_rewards(self): program = stormpy.parse_prism_program(get_example_path("dtmc", "die.pm")) prop = "R=? [F \"done\"]" properties = stormpy.parse_properties_for_prism_program(prop, program, None) model = stormpy.build_symbolic_model(program, properties) model.reduce_to_state_based_rewards() assert len(model.reward_models) == 1 assert model.reward_models["coin_flips"].has_state_rewards assert not model.reward_models["coin_flips"].has_state_action_rewards assert not model.reward_models["coin_flips"].has_transition_rewards
def test_build_dtmc_from_jani_model(self): jani_model, properties = stormpy.parse_jani_model(get_example_path("dtmc", "brp.jani")) description = stormpy.SymbolicModelDescription(jani_model) constant_definitions = description.parse_constant_definitions("N=16, MAX=2") instantiated_jani_model = description.instantiate_constants(constant_definitions).as_jani_model() model = stormpy.build_symbolic_model(instantiated_jani_model) assert model.nr_states == 677 assert model.nr_transitions == 867 assert model.model_type == stormpy.ModelType.DTMC assert not model.supports_parameters assert type(model) is stormpy.SymbolicSylvanDtmc
def test_build_dtmc_from_prism_program_formulas(self): program = stormpy.parse_prism_program(get_example_path("dtmc", "die.pm")) prop = "P=? [F \"one\"]" properties = stormpy.parse_properties_for_prism_program(prop, program, None) model = stormpy.build_symbolic_model(program, properties) assert model.nr_states == 13 assert model.nr_transitions == 20 assert model.model_type == stormpy.ModelType.DTMC assert len(model.reward_models) == 0 assert not model.supports_parameters assert type(model) is stormpy.SymbolicSylvanDtmc
def test_model_checking_prism_hybrid_dtmc(self): program = stormpy.parse_prism_program(get_example_path("dtmc", "die.pm")) formulas = stormpy.parse_properties_for_prism_program("P=? [ F \"one\" ]", program) model = stormpy.build_symbolic_model(program, formulas) assert model.nr_states == 13 assert model.nr_transitions == 20 result = stormpy.check_model_hybrid(model, formulas[0]) assert type(result) is stormpy.HybridQuantitativeCheckResult values = result.get_values() assert len(values) == 3 assert math.isclose(values[0], 1 / 6)
def example_analysis_02(): path = stormpy.examples.files.prism_dtmc_die prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=7 & d=2]" properties = stormpy.parse_properties(formula_str, prism_program) model = stormpy.build_symbolic_model(prism_program, properties) result = stormpy.model_checking(model, properties[0]) filter = stormpy.create_filter_initial_states_symbolic(model) result.filter(filter) assert result.min == result.max print(result.min)
def test_model_checking_prism_dd_dtmc(self): program = stormpy.parse_prism_program(get_example_path("dtmc", "die.pm")) formulas = stormpy.parse_properties_for_prism_program("P=? [ F \"one\" ]", program) model = stormpy.build_symbolic_model(program, formulas) assert model.nr_states == 13 assert model.nr_transitions == 20 result = stormpy.check_model_dd(model, formulas[0]) assert type(result) is stormpy.SymbolicQuantitativeCheckResult filter = stormpy.create_filter_initial_states_symbolic(model) result.filter(filter) assert result.min == result.max assert math.isclose(result.min, 1 / 6, rel_tol=1e-6)
def initialize(self): logger.debug("Initialize oracle...") formula_str = "Pmax=? [F \"goal\"]" properties = stormpy.parse_properties(formula_str, self._get_prism_program()) logger.debug("...building model...") self._model = stormpy.build_symbolic_model(self._get_prism_program(), properties) env = stormpy.Environment() env.solver_environment.set_linear_equation_solver_type(stormpy.EquationSolverType.native) env.solver_environment.native_solver_environment.method = stormpy.NativeLinearEquationSolverMethod.power_iteration env.solver_environment.native_solver_environment.maximum_iterations = 100 logger.debug("...doing model checking...") self._mc_result = stormpy.model_checking(self._model, properties[0], environment=env) logger.debug("Initialization done.")
def test_transform_symbolic_dtmc_to_sparse(self): program = stormpy.parse_prism_program( get_example_path("dtmc", "crowds5_5.pm")) symbolic_model = stormpy.build_symbolic_model(program) assert symbolic_model.nr_states == 8607 assert symbolic_model.nr_transitions == 15113 assert symbolic_model.model_type == stormpy.ModelType.DTMC assert not symbolic_model.supports_parameters assert type(symbolic_model) is stormpy.SymbolicSylvanDtmc sparse_model = stormpy.transform_to_sparse_model(symbolic_model) assert sparse_model.nr_states == 8607 assert sparse_model.nr_transitions == 15113 assert sparse_model.model_type == stormpy.ModelType.DTMC assert not sparse_model.supports_parameters assert type(sparse_model) is stormpy.SparseDtmc
def test_symbolic_bisimulation(self): program = stormpy.parse_prism_program( get_example_path("dtmc", "crowds5_5.pm")) prop = "P=? [F \"observe0Greater1\"]" properties = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_symbolic_model(program, properties) assert model.nr_states == 7403 assert model.nr_transitions == 13041 assert model.model_type == stormpy.ModelType.DTMC assert not model.supports_parameters model_bisim = stormpy.perform_symbolic_bisimulation(model, properties) assert model_bisim.nr_states == 65 assert model_bisim.nr_transitions == 105 assert model_bisim.model_type == stormpy.ModelType.DTMC assert not model_bisim.supports_parameters
def build_symbolic_model(self, jani_program, formulae, alt_formulae): if self._model: logger.warning("Rebuilding a model...") logger.info("Build model (with dd engine)...") self._formulae = formulae self._alt_formulae = alt_formulae self._expression_manager = jani_program.expression_manager jani_program.substitute_functions() result = stormpy.build_symbolic_model(jani_program, self._formulae) logger.info( "done. Model has {} states, {} actions and {} transitions".format( result.nr_states, result.nr_choices, result.nr_transitions)) self._model = result self._submodel = result return self._model
def example_analysis_03(): path = stormpy.examples.files.prism_dtmc_die prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=7 & d=2]" properties = stormpy.parse_properties(formula_str, prism_program) model = stormpy.build_model(prism_program, properties) env = stormpy.Environment() env.solver_environment.set_linear_equation_solver_type(stormpy.EquationSolverType.native) env.solver_environment.native_solver_environment.method = stormpy.NativeLinearEquationSolverMethod.power_iteration env.solver_environment.native_solver_environment.maximum_iterations = 2 result = stormpy.model_checking(model, properties[0], environment=env) print(result.at(model.initial_states[0])) dd_model = stormpy.build_symbolic_model(prism_program, properties) result = stormpy.model_checking(dd_model, properties[0], environment=env) filter = stormpy.create_filter_initial_states_symbolic(dd_model) result.filter(filter) assert result.min == result.max print(result.min)
def compute_model_parameters(program, props, compute_prob0_expressions=True): model = stormpy.build_symbolic_model( program.substitute_nonstandard_predicates(), props) model_depth = model.compute_depth() raw_formula_copy = props[0].raw_formula.clone() if raw_formula_copy.has_bound: raise NotImplementedError("Not implemented") else: raw_formula_copy.set_bound( stormpy.logic.ComparisonType.LEQ, program.expression_manager.create_rational(0)) qualitative_prop = stormpy.Property("prob0", raw_formula_copy) result = stormpy.model_checking( model, qualitative_prop, only_initial_states=False).get_truth_values() expressions, mapping = result.to_expression(program.expression_manager) expr_manager = program.expression_manager subst = dict() for k in result.meta_variables: if model.dd_manager.get_meta_variable( k).type == stormpy.DdMetaVariableType.Bool: assert len( model.dd_manager.get_meta_variable(k).compute_indices()) == 1 idx = model.dd_manager.get_meta_variable(k).compute_indices()[0] if idx not in mapping: continue subst[mapping[idx]] = expr_manager.get_variable( model.dd_manager.get_meta_variable(k).name).get_expression() elif model.dd_manager.get_meta_variable( k).type == stormpy.DdMetaVariableType.Int: max_offset = len( model.dd_manager.get_meta_variable(k).compute_indices()) for offset, idx in enumerate( model.dd_manager.get_meta_variable(k).compute_indices()): if idx not in mapping: continue pow = int(math.pow(2, max_offset - offset - 1)) expr = stormpy.storage.Expression.Modulo( stormpy.storage.Expression.Divide( stormpy.storage.Expression.Minus( expr_manager.get_variable( model.dd_manager.get_meta_variable( k).name).get_expression(), expr_manager.create_integer( model.dd_manager.get_meta_variable( k).lowest_value)), expr_manager.create_integer(pow)), expr_manager.create_integer(2)) subst[mapping[idx]] = stormpy.storage.Expression.Eq( expr, expr_manager.create_integer(1)).simplify() else: assert False for k, v in subst.items(): print("{} -> {}".format(k.name, v)) if compute_prob0_expressions: prob0expressions = [] final_res = None for expr in expressions: expr = expr.substitute(subst) if expr.is_variable(): final_res = expr elif expr.get_operand(0).is_variable(): prob0expressions.append( (expr.get_operand(0), expr.get_operand(1))) elif expr.get_operand(1).is_variable(): prob0expressions.append( (expr.get_operand(1), expr.get_operand(0))) prob0expressions.append(final_res) else: prob0expressions = ["false"] return model_depth, prob0expressions
def test_build_ma(self): program = stormpy.parse_prism_program(get_example_path("ma", "simple.ma")) formulas = stormpy.parse_properties_for_prism_program("P=? [ F<=2 s=2 ]", program) with pytest.raises(Exception): model = stormpy.build_symbolic_model(program, formulas)