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)
