def test_parameters(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) formulas = stormpy.parse_properties_for_prism_program( "P=? [F s=5]", program) model = stormpy.build_parametric_model(program, formulas) model_parameters = model.collect_probability_parameters() reward_parameters = model.collect_reward_parameters() all_parameters = model.collect_all_parameters() assert len(model_parameters) == 2 assert len(reward_parameters) == 0 assert len(all_parameters) == 2 program_reward = stormpy.parse_prism_program( get_example_path("pdtmc", "brp_rewards16_2.pm")) formulas_reward = stormpy.parse_properties_for_prism_program( "Rmin=? [ F \"target\" ]", program_reward) model = stormpy.build_parametric_model(program_reward, formulas_reward) model_parameters = model.collect_probability_parameters() reward_parameters = model.collect_reward_parameters() all_parameters = model.collect_all_parameters() assert len(model_parameters) == 2 assert len(reward_parameters) == 2 assert len(all_parameters) == 4 model = stormpy.build_symbolic_parametric_model(program, formulas) assert len(model.get_parameters()) == 4 model = stormpy.build_symbolic_parametric_model( program_reward, formulas_reward) assert len(model.get_parameters()) == 4
def test_parametric_bisimulation(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) assert program.nr_modules == 5 assert program.model_type == stormpy.PrismModelType.DTMC assert program.has_undefined_constants assert program.undefined_constants_are_graph_preserving prop = "P=? [F s=5]" properties = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, properties) assert model.nr_states == 613 assert model.nr_transitions == 803 assert model.model_type == stormpy.ModelType.DTMC assert model.has_parameters initial_state = model.initial_states[0] assert initial_state == 0 result = stormpy.model_checking(model, properties[0]) ratFunc = result.at(initial_state) model_bisim = stormpy.perform_bisimulation( model, properties, stormpy.BisimulationType.STRONG) assert model_bisim.nr_states == 324 assert model_bisim.nr_transitions == 452 assert model_bisim.model_type == stormpy.ModelType.DTMC assert model_bisim.has_parameters result_bisim = stormpy.model_checking(model_bisim, properties[0]) initial_state_bisim = model_bisim.initial_states[0] assert initial_state_bisim == 316 ratFunc_bisim = result_bisim.at(initial_state_bisim) assert ratFunc == ratFunc_bisim
def test_change_parametric_matrix_modelchecking(self): import stormpy.logic program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) formulas = stormpy.parse_properties_for_prism_program( "P=? [ F s=5 ]", program) model = stormpy.build_parametric_model(program, formulas) initial_state = model.initial_states[0] assert initial_state == 0 matrix = model.transition_matrix # Check matrix one_pol = stormpy.RationalRF(1) one_pol = stormpy.FactorizedPolynomial(one_pol) one = stormpy.FactorizedRationalFunction(one_pol, one_pol) for e in matrix: assert e.value() == one or len(e.value().gather_variables()) > 0 # First model checking result = stormpy.model_checking(model, formulas[0]) ratFunc = result.at(initial_state) assert len(ratFunc.gather_variables()) > 0 # Change probabilities two_pol = stormpy.RationalRF(2) two_pol = stormpy.FactorizedPolynomial(two_pol) new_val = stormpy.FactorizedRationalFunction(one_pol, two_pol) for e in matrix: if len(e.value().gather_variables()) > 0: e.set_value(new_val) for e in matrix: assert e.value() == new_val or e.value() == one # Second model checking result = stormpy.model_checking(model, formulas[0]) ratFunc = result.at(initial_state) assert len(ratFunc.gather_variables()) == 0
def test_pla(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P<=0.84 [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 613 assert model.nr_transitions == 803 assert model.model_type == stormpy.ModelType.DTMC assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.create_region_checker(env, model, formulas[0].raw_formula) parameters = model.collect_probability_parameters() assert len(parameters) == 2 region = stormpy.pars.ParameterRegion.create_from_string( "0.7<=pL<=0.9,0.75<=pK<=0.95", parameters, splitting_threshold=None) result = checker.check_region(env, region) assert result == stormpy.pars.RegionResult.ALLSAT region = stormpy.pars.ParameterRegion.create_from_string( "0.4<=pL<=0.65,0.75<=pK<=0.95", parameters, splitting_threshold=None) result = checker.check_region( env, region, stormpy.pars.RegionResultHypothesis.UNKNOWN, stormpy.pars.RegionResult.UNKNOWN, True) assert result == stormpy.pars.RegionResult.EXISTSBOTH region = stormpy.pars.ParameterRegion.create_from_string( "0.1<=pL<=0.73,0.2<=pK<=0.715", parameters, splitting_threshold=None) result = checker.check_region(env, region) assert result == stormpy.pars.RegionResult.ALLVIOLATED
def example_parametric_models_01(): # Check support for parameters if not config.storm_with_pars: print("Support parameters is missing. Try building storm-pars.") return import stormpy.pars path = stormpy.examples.files.prism_pdtmc_die prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=7 & d=3]" properties = stormpy.parse_properties_for_prism_program(formula_str, prism_program) model = stormpy.build_parametric_model(prism_program, properties) print("Model supports parameters: {}".format(model.supports_parameters)) parameters = model.collect_probability_parameters() assert len(parameters) == 2 instantiator = stormpy.pars.PDtmcInstantiator(model) point = dict() for x in parameters: print(x.name) point[x] = stormpy.RationalRF(0.0) instantiated_model = instantiator.instantiate(point) result = stormpy.model_checking(instantiated_model, properties[0]) print(result)
def example_parametric_models_02(): # Check support for parameters if not config.storm_with_pars: print("Support parameters is missing. Try building storm-pars.") return import stormpy.pars from pycarl.formula import FormulaType, Relation if stormpy.info.storm_ratfunc_use_cln(): import pycarl.cln.formula else: import pycarl.gmp.formula path = stormpy.examples.files.prism_pdtmc_die prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F s=7 & d=2]" properties = stormpy.parse_properties_for_prism_program(formula_str, prism_program) model = stormpy.build_parametric_model(prism_program, properties) initial_state = model.initial_states[0] result = stormpy.model_checking(model, properties[0]) print("Result: {}".format(result.at(initial_state))) collector = stormpy.ConstraintCollector(model) print("Well formed constraints:") for formula in collector.wellformed_constraints: print(formula.get_constraint()) print("Graph preserving constraints:") for formula in collector.graph_preserving_constraints: print(formula.get_constraint())
def test_mdp_simplification(self): program = stormpy.parse_prism_program(get_example_path("pmdp", "two_dice.nm")) formulas = stormpy.parse_properties_for_prism_program("Pmin=? [ F \"two\" ]", program) formula = formulas[0].raw_formula model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 169 assert model.nr_transitions == 435 model, formula = stormpy.pars.simplify_model(model, formula) assert model.nr_states == 17 assert model.nr_transitions == 50
def build_model(file, hybrid=False, sylvan_threads=1, sylvan_memory=4096): """ Build model from file and apply bisimulation. :param file: File. :param hybrid: If true, the model is built symbolically with BDDs and in the end converted to a sparse model. If false, the model is built as a sparse model from the beginning. :param sylvan_threads: Number of threads to use in Sylvan library. :param sylvan_memory: Memory available to Sylvan. :return: Tuple (sparse model, prism program, property, time (s) for building , time (s) for bisimulation). """ logging.debug("Build ({}) model for file {}".format("symbolic" if hybrid else "sparse", file)) # Build model build_start = time.time() program = stormpy.parse_prism_program(file) prop = "R=? [F \"stable\"]" properties = stormpy.parse_properties(prop, program) assert (len(properties) == 1) program, properties = stormpy.preprocess_prism_program(program, properties, "") program = program.as_prism_program() if hybrid: # Set number of Sylvan threads to use stormpy.set_settings(["--sylvan:threads", str(sylvan_threads)]) # Set memory for Sylvan stormpy.set_settings(["--sylvan:maxmem", str(sylvan_memory)]) model = stormpy.build_symbolic_parametric_model(program, properties) else: model = stormpy.build_parametric_model(program, properties) logging.info("Built ({}) model with {} states and {} transitions.".format("symbolic" if hybrid else "sparse", model.nr_states, model.nr_transitions)) build_end = time.time() time_build = build_end - build_start logging.info("Building model took {}s".format(time_build)) # Bisimulation if hybrid: # Extract bisimulation quotient as sparse model stormpy.set_settings(["--bisimulation:quot", "sparse"]) model = stormpy.perform_symbolic_bisimulation(model, properties) else: model = stormpy.perform_bisimulation(model, properties, stormpy.BisimulationType.STRONG) assert type(model) is stormpy.SparseParametricDtmc logging.info("Model after bisimulation: {} states and {} transitions.".format(model.nr_states, model.nr_transitions)) time_bisim = time.time() - build_end logging.info("Computing bisimulation quotient took {}s".format(time_bisim)) prop = properties[0] # Simplify model (by eliminating constant transitions) # Disabled for the moment as this leads to significantly more transitions in Herman if False: model, formula = stormpy.pars.simplify_model(model, prop.raw_formula) logging.info("Model after simplification: {} states and {} transitions.".format(model.nr_states, model.nr_transitions)) return model, program, prop, time_build, time_bisim
def test_build_parametric_mdp(self): program = stormpy.parse_prism_program( get_example_path("pmdp", "two_dice.nm")) formulas = stormpy.parse_properties_for_prism_program( "P=? [ F \"two\" ]", program) model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 169 assert model.nr_transitions == 435 assert model.model_type == stormpy.ModelType.MDP assert model.supports_parameters assert type(model) is stormpy.SparseParametricMdp
def test_dtmc_simplification(self): program = stormpy.parse_prism_program(get_example_path("pdtmc", "brp16_2.pm")) prop = "P<=0.84 [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) formula = formulas[0].raw_formula model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 613 assert model.nr_transitions == 803 model, formula = stormpy.pars.simplify_model(model, formula) assert model.nr_states == 193 assert model.nr_transitions == 383
def test_build_dtmc_supporting_parameters(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_parametric_model(program, formulas) assert model.nr_states == 13 assert model.nr_transitions == 20 assert model.model_type == stormpy.ModelType.DTMC assert model.supports_parameters assert not model.has_parameters assert type(model) is stormpy.SparseParametricDtmc
def test_build_parametric_dtmc(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) formulas = stormpy.parse_properties_for_prism_program( "P=? [ F s=5 ]", program) model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 613 assert model.nr_transitions == 803 assert model.model_type == stormpy.ModelType.DTMC assert model.supports_parameters assert model.has_parameters assert type(model) is stormpy.SparseParametricDtmc
def example_parametric_models_03(): path = stormpy.examples.files.prism_dtmc_brp prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [F \"target\"]" properties = stormpy.parse_properties_for_prism_program( formula_str, prism_program) model = stormpy.build_parametric_model(prism_program, properties) print(model.model_type) start = time.time() t = 0 for state in model.states: if state.id in model.initial_states: print(state) for action in state.actions: for transition in action.transitions: if transition.value().constant_part() == 1: t += 1 #print("From state {}, with probability {}, go to state {}".format(state, transition.value(), transition.column)) print(time.time() - start) print(t) t2 = 0 start = time.time() for row_group in range(model.nr_states): for row in range( model.transition_matrix.get_row_group_start(row_group), model.transition_matrix.get_row_group_end(row_group)): for entry in model.transition_matrix.get_row(row): if entry.value().constant_part() == 1: t2 += 1 print(time.time() - start) print(t2) states_and_transitions = [] for row_group in range(model.nr_states): states_and_transitions.append([]) for row in range( model.transition_matrix.get_row_group_start(row_group), model.transition_matrix.get_row_group_end(row_group)): for entry in model.transition_matrix.get_row(row): states_and_transitions[-1].append( (entry.value(), entry.column)) t3 = 0 start = time.time() for s in states_and_transitions: for (v, c) in s: if v.constant_part() == 1: t3 += 1 print(time.time() - start) print(t3)
def test_derivatives(self): program = stormpy.parse_prism_program(get_example_path("pdtmc", "brp16_2.pm")) prop = "P<=0.84 [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 613 assert model.nr_transitions == 803 assert model.model_type == stormpy.ModelType.DTMC assert model.has_parameters parameters = model.collect_probability_parameters() assert len(parameters) == 2 derivatives = stormpy.pars.gather_derivatives(model, list(parameters)[0]) assert len(derivatives) == 0
def test_parametric_model_checking_sparse(self): program = stormpy.parse_prism_program(get_example_path("pdtmc", "brp16_2.pm")) prop = "P=? [F s=5]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 613 assert model.nr_transitions == 803 assert model.model_type == stormpy.ModelType.DTMC assert model.has_parameters initial_state = model.initial_states[0] assert initial_state == 0 result = stormpy.model_checking(model, formulas[0]) func = result.at(initial_state) one = stormpy.FactorizedPolynomial(stormpy.RationalRF(1)) assert func.denominator == one
def test_build_parametric_dtmc_preprocess(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "herman5.pm")) formulas = stormpy.parse_properties_for_prism_program( "R=? [ F \"stable\" ]", program) trans_program, trans_formulas = stormpy.preprocess_symbolic_input( program, formulas, "") trans_prism = trans_program.as_prism_program() model = stormpy.build_parametric_model(trans_prism, trans_formulas) assert model.nr_states == 33 assert model.nr_transitions == 266 assert model.model_type == stormpy.ModelType.DTMC assert model.supports_parameters assert model.has_parameters assert type(model) is stormpy.SparseParametricDtmc
def test_parametric_transitions(self): program = stormpy.parse_prism_program( get_example_path("pmdp", "two_dice.nm")) model = stormpy.build_parametric_model(program) assert model.states[1].id == 1 one = stormpy.FactorizedPolynomial(stormpy.RationalRF(1)) i = 0 for state in model.states: assert state.id == i i += 1 j = 0 for action in state.actions: assert j == 0 or j == 1 j += 1 for transition in action.transitions: assert transition.value().denominator == one
def test_label_parametric(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) formulas = stormpy.parse_properties_for_prism_program( "P=? [ F s=5 ]", program) model = stormpy.build_parametric_model(program, formulas) labels = model.labeling.get_labels() assert len(labels) == 3 assert "init" in labels assert "(s = 5)" in labels assert "init" in model.labels_state(0) assert "(s = 5)" in model.labels_state(28) assert "(s = 5)" in model.labels_state(611) initial_states = model.initial_states assert len(initial_states) == 1 assert 0 in initial_states
def test_dynasty(self): program = stormpy.parse_prism_program( "/home/simon/School/DP/synthesis/workspace/simon/die/sketch.templ") prop = "P>=1/6 [F s=7 & d=1]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.MdpParameterLiftingModelChecker() checker.specify(env, model, formulas[0].raw_formula, True) parameters = model.collect_probability_parameters() assert len(parameters) == 1 region = stormpy.pars.ParameterRegion.create_from_string( "0.1<=p0<=0.62", parameters) minr = checker.get_bound(env, region, False) maxr = checker.get_bound(env, region, True) result = checker.check_region(env, region) assert True
def test_pla_manual(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P=? [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.DtmcParameterLiftingModelChecker() checker.specify(env, model, formulas[0].raw_formula) parameters = model.collect_probability_parameters() assert len(parameters) == 2 region = stormpy.pars.ParameterRegion.create_from_string( "0.7<=pL<=0.9,0.75<=pK<=0.95", parameters) result = checker.get_bound(env, region, True) assert math.isclose(float(result.constant_part()), 0.8369631383670559, rel_tol=1e-6)
def test_pla_region_valuation(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P<=0.84 [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.nr_states == 613 assert model.nr_transitions == 803 assert model.model_type == stormpy.ModelType.DTMC assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.create_region_checker(env, model, formulas[0].raw_formula) parameters = model.collect_probability_parameters() assert len(parameters) == 2 for par in parameters: if par.name == "pL": pL = par elif par.name == "pK": pK = par else: assert False region_valuation = dict() region_valuation[pL] = (stormpy.RationalRF(0.7), stormpy.RationalRF(0.9)) region_valuation[pK] = (stormpy.RationalRF(0.75), stormpy.RationalRF(0.95)) region = stormpy.pars.ParameterRegion(region_valuation) result = checker.check_region(env, region) assert result == stormpy.pars.RegionResult.ALLSAT region_valuation[pL] = (stormpy.RationalRF(0.4), stormpy.RationalRF(0.65)) region = stormpy.pars.ParameterRegion(region_valuation) result = checker.check_region( env, region, stormpy.pars.RegionResultHypothesis.UNKNOWN, stormpy.pars.RegionResult.UNKNOWN, True) assert result == stormpy.pars.RegionResult.EXISTSBOTH region_valuation[pK] = (stormpy.RationalRF(0.2), stormpy.RationalRF(0.715)) region_valuation[pL] = (stormpy.RationalRF(0.1), stormpy.RationalRF(0.73)) region = stormpy.pars.ParameterRegion(region_valuation) result = checker.check_region(env, region) assert result == stormpy.pars.RegionResult.ALLVIOLATED
def test_instantiate_dtmc(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) formulas = stormpy.parse_properties_for_prism_program( "P=? [ F s=5 ]", program) model = stormpy.build_parametric_model(program, formulas) parameters = model.collect_probability_parameters() assert len(parameters) == 2 instantiator = stormpy.pars.ModelInstantiator(model) point = {p: stormpy.RationalRF("0.4") for p in parameters} instantiated_model = instantiator.instantiate(point) assert instantiated_model.nr_states == model.nr_states assert not instantiated_model.has_parameters assert "0.4" in str(instantiated_model.transition_matrix[1]) point = {p: stormpy.RationalRF("0.5") for p in parameters} instantiated_model2 = instantiator.instantiate(point) assert "0.5" in str(instantiated_model2.transition_matrix[1])
def test_region(self): program = stormpy.parse_prism_program(get_example_path("pdtmc", "brp16_2.pm")) prop = "P<=0.84 [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) parameters = model.collect_probability_parameters() assert len(parameters) == 2 region = stormpy.pars.ParameterRegion.create_from_string("0.7<=pL<=0.9,0.75<=pK<=0.95", parameters) assert region.area == stormpy.RationalRF(1) / stormpy.RationalRF(25) for par in parameters: if par.name == "pL": pL = par elif par.name == "pK": pK = par else: assert False dec = stormpy.RationalRF(100) region_valuation = {pL: (stormpy.RationalRF(70) / dec, stormpy.RationalRF(90) / dec), pK: (stormpy.RationalRF(75) / dec, stormpy.RationalRF(95) / dec)} region = stormpy.pars.ParameterRegion(region_valuation) assert region.area == stormpy.RationalRF(1) / stormpy.RationalRF(25)
def test_pdtmc_exact_instantiation_checker(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "herman5.pm")) formulas = stormpy.parse_properties_for_prism_program( "R=? [F \"stable\"]", program) model = stormpy.build_parametric_model(program, formulas) parameters = model.collect_probability_parameters() inst_checker = stormpy.pars.PDtmcExactInstantiationChecker(model) inst_checker.specify_formula( stormpy.ParametricCheckTask(formulas[0].raw_formula, True)) inst_checker.set_graph_preserving(True) env = stormpy.Environment() point = {p: stormpy.RationalRF("1/2") for p in parameters} result = inst_checker.check(env, point) assert isinstance(result, stormpy.ExplicitExactQuantitativeCheckResult) res = result.at(model.initial_states[0]) assert isinstance(res, stormpy.Rational) assert res == stormpy.Rational("29/15")
def test_pla_bounds(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P=? [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.create_region_checker(env, model, formulas[0].raw_formula) parameters = model.collect_probability_parameters() assert len(parameters) == 2 region = stormpy.pars.ParameterRegion("0.7<=pL<=0.9,0.75<=pK<=0.95", parameters) result = checker.get_bound(env, region, True) assert math.isclose(float(result.constant_part()), 0.8369631383670559, rel_tol=1e-6) result_vec = checker.get_bound_all_states(env, region, True) result = result_vec.at(model.initial_states[0]) assert math.isclose(result, 0.8369631383670559, rel_tol=1e-6)
def test_constraints_collector(self): from pycarl.formula import FormulaType, Relation if stormpy.info.storm_ratfunc_use_cln(): import pycarl.cln.formula else: import pycarl.gmp.formula program = stormpy.parse_prism_program(get_example_path("pdtmc", "brp16_2.pm")) prop = "P=? [F s=5]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) collector = stormpy.ConstraintCollector(model) constraints_well_formed = collector.wellformed_constraints for formula in constraints_well_formed: assert formula.type == FormulaType.CONSTRAINT constraint = formula.get_constraint() assert constraint.relation == Relation.LEQ constraints_graph_preserving = collector.graph_preserving_constraints for formula in constraints_graph_preserving: assert formula.type == FormulaType.CONSTRAINT constraint = formula.get_constraint() assert constraint.relation == Relation.NEQ
def test_pla_state_bounds(self): program = stormpy.parse_prism_program( get_example_path("pdtmc", "brp16_2.pm")) prop = "P=? [F s=5 ]" formulas = stormpy.parse_properties_for_prism_program(prop, program) model = stormpy.build_parametric_model(program, formulas) assert model.has_parameters env = stormpy.Environment() checker = stormpy.pars.DtmcParameterLiftingModelChecker() checker.specify(env, model, formulas[0].raw_formula, allow_model_simplification=False) parameters = model.collect_probability_parameters() assert len(parameters) == 2 region = stormpy.pars.ParameterRegion.create_from_string( "0.7<=pL<=0.9,0.75<=pK<=0.95", parameters) result_vec = checker.get_bound_all_states(env, region, True) assert len(result_vec.get_values()) == model.nr_states assert math.isclose(result_vec.at(model.initial_states[0]), 0.836963056082918, rel_tol=1e-6)
def example_parametric_models_04(): # Check support for parameters if not config.storm_with_pars: print("Support parameters is missing. Try building storm-pars.") return import stormpy.pars path = stormpy.examples.files.prism_pdtmc_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_parametric_model(prism_program, properties) # Modify i = 0 for state in model.states: if state.id in model.initial_states: print(state) for action in state.actions: for transition in action.transitions: if len(transition.value().gather_variables()) > 0: new_var = pycarl.Variable("p{}".format(i)) i += 1 new_pol = stormpy.Polynomial(new_var) pol_in_right_format = stormpy.FactorizedPolynomial(new_pol, transition.value().numerator.cache()) new_factorized_ratfunc = stormpy.FactorizedRationalFunction(pol_in_right_format) transition.set_value(new_factorized_ratfunc) # Display for state in model.states: if state.id in model.initial_states: print(state) for action in state.actions: for transition in action.transitions: print("From state {}, with probability {}, go to state {}".format(state, transition.value(), transition.column))
def example_parametric_models_01(): # Check support for parameters if not config.storm_with_pars: print("Support parameters is missing. Try building storm-pars.") return import stormpy.pars from pycarl.formula import FormulaType, Relation if stormpy.info.storm_ratfunc_use_cln(): import pycarl.cln.formula else: import pycarl.gmp.formula # Prevent curious side effects from earlier runs (for tests only) pycarl.clear_pools() ### # How to apply an unknown FSC to obtain a pMC from a POMDP path = stormpy.examples.files.prism_pomdp_maze prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [\"goal\"]" properties = stormpy.parse_properties_for_prism_program( formula_str, prism_program) # construct the POMDP pomdp = stormpy.build_model(prism_program, properties) # make its representation canonic. pomdp = stormpy.pomdp.make_canonic(pomdp) # make the POMDP simple. This step is optional but often beneficial pomdp = stormpy.pomdp.make_simple(pomdp) # construct the memory for the FSC # in this case, a selective counter with two states memory_builder = stormpy.pomdp.PomdpMemoryBuilder() memory = memory_builder.build( stormpy.pomdp.PomdpMemoryPattern.selective_counter, 2) # apply the memory onto the POMDP to get the cartesian product pomdp = stormpy.pomdp.unfold_memory(pomdp, memory) # apply the memory onto the POMDP to get the cartesian product pmc = stormpy.pomdp.apply_unknown_fsc( pomdp, stormpy.pomdp.PomdpFscApplicationMode.simple_linear) #### # How to apply an unknown FSC to obtain a pMC from a pPOMDP path = stormpy.examples.files.prism_par_pomdp_maze prism_program = stormpy.parse_prism_program(path) formula_str = "P=? [\"goal\"]" properties = stormpy.parse_properties_for_prism_program( formula_str, prism_program) # construct the pPOMDP pomdp = stormpy.build_parametric_model(prism_program, properties) # make its representation canonic. pomdp = stormpy.pomdp.make_canonic(pomdp) # make the POMDP simple. This step is optional but often beneficial pomdp = stormpy.pomdp.make_simple(pomdp) # construct the memory for the FSC # in this case, a selective counter with two states memory_builder = stormpy.pomdp.PomdpMemoryBuilder() memory = memory_builder.build( stormpy.pomdp.PomdpMemoryPattern.selective_counter, 2) # apply the memory onto the POMDP to get the cartesian product pomdp = stormpy.pomdp.unfold_memory(pomdp, memory) # apply the unknown FSC to obtain a pmc from the POMDP pmc = stormpy.pomdp.apply_unknown_fsc( pomdp, stormpy.pomdp.PomdpFscApplicationMode.simple_linear) export_pmc = False # Set to True to export the pMC as drn. if export_pmc: export_options = stormpy.core.DirectEncodingOptions() export_options.allow_placeholders = False stormpy.export_parametric_to_drn(pmc, "test.out", export_options)
def test2(): t0 = time.time() #path = "collision_partial_obs_2d_upd_hobs_20_small.prism" path, interval_path, formula_str, threshold = input_files() prism_program = stormpy.parse_prism_program(path) #formula_str = "P=? [!\"bad\" U \"goal\"]" #formula_str = "P=? [F \"goal\"]" #interval_path="collision_partial_obs_2d_upd_hobs_20_small.intervals" opts = stormpy.DirectEncodingParserOptions() opts.build_choice_labels = True properties = stormpy.parse_properties_for_prism_program(formula_str, prism_program) # construct the pPOMDP import inspect print(inspect.getfullargspec(stormpy.build_parametric_model)) pomdp = stormpy.build_parametric_model(prism_program, properties) pomdp_parameters = pomdp.collect_probability_parameters() stormpy.export_parametric_to_drn(pomdp, "pomdp_ex") # make its representation canonic. pomdp = stormpy.pomdp.make_canonic(pomdp) #stormpy.export_parametric_to_drn(pomdp, "export_pomdp.drn") # construct the memory for the FSC # in this case, a selective counter with two states memory_builder = stormpy.pomdp.PomdpMemoryBuilder() memval=1 memory = memory_builder.build(stormpy.pomdp.PomdpMemoryPattern.selective_counter, memval) # apply the memory onto the POMDP to get the cartesian product pomdp = stormpy.pomdp.unfold_memory(pomdp, memory) print("Number of pomdp states before simple:",pomdp.nr_states) print("Number of transitions: {}".format(pomdp.nr_transitions)) # make the POMDP simple. This step is optional but often beneficial pomdp = stormpy.pomdp.make_simple(pomdp) print("Number of pomdp states after simple:",pomdp.nr_states) print("Number of transitions: {}".format(pomdp.nr_transitions)) # apply the unknown FSC to obtain a pmc from the POMDP pmc = stormpy.pomdp.apply_unknown_fsc(pomdp, stormpy.pomdp.PomdpFscApplicationMode.simple_linear) print("Number of pomdp states after simple",pmc.nr_states) print("Number of transitions: {}".format(pmc.nr_transitions)) print(pmc) print("applied pmc") path_pmc = "export_" + str(memval) + "_mem_" + path print(path_pmc) stormpy.export_parametric_to_drn(pmc, path_pmc) print("built model") #print(model.initial_states) fsc_parameters = pmc.collect_probability_parameters() - pomdp.collect_probability_parameters() print("number of pomdp parameters:",len(fsc_parameters)) #print(fsc_parameters) #print(pomdp_parameters) #intervals2, polyhedrons = interval_parser.parse_input(interval_path) intervals, polyhedrons,items = interval_parser.parse_model_interval(pmc,pomdp_parameters,interval_path) #for item in intervals: #print(item,"printing in the main") #for item in items: # print(item,"printing in the main") for p in polyhedrons: #print(p) p.compute_vertices() properties = stormpy.parse_properties(formula_str) print("Building model from {}".format(path)) #parameters = model.collect_probability_parameters() print(pmc.nr_states) prob0E, prob1A = stormpy.prob01max_states(pmc, properties[0].raw_formula.subformula) #print(prob0E) #threshold = 0.90 direction = "below" # can be "below" or "above" options = QcqpOptions(mu=1e4, maxiter=10000, graph_epsilon=1e-2, silent=False) # result = solver.run(reward_model_name ,model_rew, parameters_rew, rew0, rew_threshold, direction, options) solver = QcqpSolver_affine_simple_fun() result = solver.run(pmc, fsc_parameters, pomdp_parameters,properties, prob0E, prob1A, threshold, direction, options,intervals,items,True) print("number of iterations={}".format(solver.iterations)) print("solver time={}".format(solver.solver_timer)) #compute the policy against the robust interval #interval_path="collision_partial_obs_2d_upd_hobs_20_small.intervals" intervals, polyhedrons,items = interval_parser.parse_model_interval(pmc,pomdp_parameters,interval_path) regiondict = dict() for x in pomdp_parameters: for item in items: if item.name == x.name: regiondict[x] = (stormpy.RationalRF(item.lowerbound), stormpy.RationalRF(item.upperbound)) region = stormpy.pars.ParameterRegion(regiondict) instantiator = stormpy.pars.PartialPDtmcInstantiator(pmc) instantiated_model = instantiator.instantiate(solver.solver_params) env = stormpy.Environment() env.solver_environment.set_linear_equation_solver_type(stormpy.EquationSolverType.eigen) env.solver_environment.native_solver_environment.method = stormpy.NativeLinearEquationSolverMethod.optimistic_value_iteration env.solver_environment.native_solver_environment.precision = stormpy.Rational('0.01') start_check = time.time() region_checker = stormpy.pars.create_region_checker(env, instantiated_model, properties[0].raw_formula, allow_model_simplification=False) print("region check") result = region_checker.get_bound_all_states(env, region, maximise=False) end_check = time.time() print("model checking ans:") ansval=result.at(pmc.initial_states[0]) print(ansval) tend = time.time() print("Total time: ", str(tend - t0))