def pick_member(self):
# pick hole assignment
self.pick_assignment()
if self.member_assignment is not None:
# collect edges relevant for this assignment
indexed_assignment = Family._hole_options.index_map(
self.member_assignment)
subcolors = Family._quotient_container.edge_coloring.subcolors(
indexed_assignment)
collected_edge_indices = stormpy.FlatSet(
Family._quotient_container.color_to_edge_indices.get(
0, stormpy.FlatSet()))
for c in subcolors:
collected_edge_indices.insert_set(
Family._quotient_container.color_to_edge_indices.get(c))
# construct the DTMC by exploring the quotient MDP for this subfamily
self.dtmc, self.dtmc_state_map = stormpy.synthesis.dtmc_from_mdp(
self.mdp, collected_edge_indices)
Family._dtmc_stats = (Family._dtmc_stats[0] + self.dtmc.nr_states,
Family._dtmc_stats[1] + 1)
logger.debug(f"Constructed DTMC of size {self.dtmc.nr_states}.")
# assert absence of deadlocks or overlapping guards
# assert self.dtmc.labeling.get_states("deadlock").number_of_set_bits() == 0
assert self.dtmc.labeling.get_states(
"overlap_guards").number_of_set_bits() == 0
assert len(self.dtmc.initial_states) == 1 # to avoid ambiguity
# success
return self.member_assignment
def consider_subset(self, subset, indexed_suboptions):
logger.debug(f"Consider sub-set of hole-options: {subset}")
single_family_member = False
if max([len(options) for options in subset.values()]) == 1:
logger.debug(
f"Submodel reflects a single family member: "
f"{','.join(['{}={}'.format(k, v[0]) for k, v in subset.items()])}"
)
single_family_member = True
start_time = time.time()
subcolors = self._edge_coloring.subcolors(indexed_suboptions)
color_0_indices = self._color_to_edge_indices.get(0)
collected_edge_indices = stormpy.FlatSet(color_0_indices)
for c in subcolors:
collected_edge_indices.insert_set(
self._color_to_edge_indices.get(c))
logger.debug("restrict MDP")
self._mdp_handling.restrict(collected_edge_indices, color_0_indices)
end_time = time.time()
self._build_time += end_time - start_time
if single_family_member:
assert self._mdp_handling.submodel_is_dtmc(
), "The subfamily is a singleton, but the submodel is not a DTMC"
def test_choice_origins(self):
program, _ = stormpy.parse_jani_model(get_example_path("dtmc", "die.jani"))
a = stormpy.FlatSet()
options = stormpy.BuilderOptions()
options.set_build_with_choice_origins()
model = stormpy.build_sparse_model_with_options(program, options)
a = model.choice_origins.get_edge_index_set(3)
def construct(self, holes_options, remember={}, init_all_in_one={}):
assert len(
remember
) == 0, "Remember options have not been tested in a long time"
self._counter = self._counter + 1
make_initialiser_automaton = False
init_all_in_one_by_replacement = True
logger.info(
"Construct Jani Model with {} options and {} as remember".format(
holes_options, remember))
edge_coloring = EdgeColoring(holes_options)
jani_program = stormpy.JaniModel(self.original_model)
holes_memory_vars = {
c.name: self._make_memory_var(c, self.holes_memory_ep[c.name],
len(holes_options[c.name]))
for c in self._open_constants.values()
}
new_automata = dict()
for aut_index, automaton in enumerate(jani_program.automata):
if len([
x for x in self._automata_to_open_constants[automaton.name]
if x not in init_all_in_one
]) == 0:
continue
logger.debug("Reconstructing automaton {}".format(automaton.name))
new_aut = stormpy.storage.JaniAutomaton(
automaton.name + "", automaton.location_variable)
for loc in automaton.locations:
new_aut.add_location(loc)
for idx in automaton.initial_location_indices:
new_aut.add_initial_location(idx)
for var in automaton.variables:
new_aut.variables.add_variable(var)
for c in remember.intersection(
self._automata_to_open_constants[automaton.name]):
holes_memory_vars[
c] = new_aut.variables.add_bounded_integer_variable(
holes_memory_vars[c])
logger.debug("added {}".format(holes_memory_vars[c]))
for edge in automaton.edges:
expand_td = dict()
expand_guard = set()
for c in self._open_constants.values():
if init_all_in_one_by_replacement and c in init_all_in_one:
continue
if edge.template_edge.guard.contains_variable(
set([c.expression_variable])):
expand_guard.add(c)
for tedidx, ted in enumerate(edge.template_edge.destinations):
for c in self._open_constants.values():
if init_all_in_one_by_replacement and c in init_all_in_one:
# For init_all_in_one_by_replacement, we do not substitute the values.
continue
for assignment in ted.assignments:
if assignment.expression.contains_variable(
set([c.expression_variable])):
if c in expand_td:
expand_td[c].append(tedidx)
expand_td[c] = [tedidx]
if len(expand_td) > 0 or len(expand_guard) > 0:
if len(expand_guard) == 0:
guard_expr = stormpy.Expression(
edge.template_edge.guard)
for combination in itertools.product(*[
range(len(holes_options[c.name])) if
(c in expand_td or c in expand_guard) else [None]
for c in self._open_constants.values()
]):
substitution = {
c.expression_variable: holes_options[c.name][v]
for c, v in zip(self._open_constants.values(),
combination) if v is not None
}
if len(expand_guard) > 0:
guard_expr = stormpy.Expression(
edge.template_edge.guard)
guard_expr = guard_expr.substitute(substitution)
te = stormpy.storage.JaniTemplateEdge(guard_expr)
remember_addition = {
c: v + 1
for c, v in zip(self._open_constants.values(),
combination)
if v is not None and c.name in remember
}
for ted in edge.template_edge.destinations:
assignments = ted.assignments.clone()
remember_here = set()
for x in remember_addition:
for a in ted.assignments:
if a.expression.contains_variable(
set([x.expression_variable])):
remember_here.add(x)
for x in remember_here:
#logger.debug("Remember {} in {}={}".format(x.name, holes_memory_vars[x.name], remember_addition[x]))
memory_assignment = stormpy.JaniAssignment(
holes_memory_vars[x.name],
self.expression_manager.create_integer(
remember_addition[x]))
assignments.add(memory_assignment)
guard_mem_set_before = stormpy.Expression.Eq(
holes_memory_vars[x.name].
expression_variable.get_expression(),
self.expression_manager.create_integer(0))
guard_mem_not_set = stormpy.Expression.Eq(
holes_memory_vars[x.name].
expression_variable.get_expression(),
self.expression_manager.create_integer(
remember_addition[x]))
te.guard = stormpy.Expression.And(
te.guard,
stormpy.Expression.Or(
guard_mem_set_before,
guard_mem_not_set))
assignments.substitute(substitution)
te.add_destination(
stormpy.storage.JaniTemplateEdgeDestination(
assignments))
dests = [(d.target_location_index, d.probability)
for d in edge.destinations]
expand_d = set()
for c in self._open_constants.values():
for (t, p) in dests:
if p.contains_variable(
set([c.expression_variable])):
expand_d.add(c)
expand_d = list(expand_d)
assert len(expand_d) == 0
new_edge = stormpy.storage.JaniEdge(
edge.source_location_index, edge.action_index,
edge.rate, te, dests)
new_edge.color = edge_coloring.get_or_make_color(
combination)
new_aut.add_edge(new_edge)
else:
assert len(expand_guard) == 0
guard_expr = stormpy.Expression(edge.template_edge.guard)
te = stormpy.storage.JaniTemplateEdge(guard_expr)
# Just copy the stuff over.
for ted in edge.template_edge.destinations:
assignment = ted.assignments.clone()
te.add_destination(
stormpy.storage.JaniTemplateEdgeDestination(
assignment))
dests = [(d.target_location_index, d.probability)
for d in edge.destinations]
expand_d = set()
for c in self._open_constants.values():
for (t, p) in dests:
if p.contains_variable(set([c.expression_variable
])):
expand_d.add(c)
expand_d = list(expand_d)
if len(expand_d) > 0: #TODO
for combination in itertools.product(
*[(range(len(holes_options[c.name])) if c in
expand_d else [None])
for c in self._open_constants.values()]):
#print(combination)
edge_color = edge_coloring.get_or_make_color(
combination)
substitution = {
c.expression_variable: holes_options[c.name][v]
for c, v in zip(self._open_constants.values(),
combination) if v is not None
}
new_dests = [
(d.target_location_index,
d.probability.substitute(substitution))
for d in edge.destinations
]
new_edge = stormpy.storage.JaniEdge(
edge.source_location_index, edge.action_index,
edge.rate, te, new_dests)
new_edge.color = edge_color
new_aut.add_edge(new_edge)
else:
new_edge = stormpy.storage.JaniEdge(
edge.source_location_index, edge.action_index,
edge.rate, te, dests)
new_aut.add_edge(new_edge)
logger.debug("Done rewriting {}".format(new_aut.name))
new_automata[aut_index] = new_aut
logger.debug("Replacing automata...")
for idx, aut in new_automata.items():
jani_program.replace_automaton(idx, aut)
logger.debug("Number of colors: {}".format(len(edge_coloring)))
logger.debug("Removing constants...")
remove_constant_names = [c.name for c in self._open_constants.values()]
new_variables = []
for c, vs in holes_options.items():
if c not in init_all_in_one:
continue
#TODO use evaluation
min_val = min([int(str(v)) for v in vs])
max_val = max([int(str(v)) for v in vs])
logger.debug(
"Variable {} with options {} ranges from {} to {}".format(
c, vs, min_val, max_val))
upper_bound = self.expression_manager.create_integer(max_val)
expr_var = self._open_constants[c].expression_variable
var_restriction = self.expression_manager.create_boolean(False)
for v in vs:
var_restriction = stormpy.Expression.Or(
var_restriction,
stormpy.Expression.Eq(expr_var.get_expression(), v))
jani_program.initial_states_restriction = stormpy.Expression.And(
jani_program.initial_states_restriction, var_restriction)
# TODO if using an initialiser automaton, change the way variables are initialises
lower_bound = self.expression_manager.create_integer(min_val)
new_variables.append(
stormpy.storage.JaniBoundedIntegerVariable(
c, expr_var, lower_bound, upper_bound))
for cname in remove_constant_names:
jani_program.remove_constant(cname)
for n in new_variables:
jani_program.global_variables.add_bounded_integer_variable(n)
if len(init_all_in_one) != len(holes_options):
# also do this with initializer automata
jani_program.set_model_type(stormpy.JaniModelType.MDP)
jani_program.finalize()
jani_program.check_valid()
filename = "output_{}.jani".format(self._counter)
logger.debug("Write to {}".format(filename))
with open(filename, "w") as F:
#jani_program.make_standard_compliant()
F.write(str(jani_program))
pass
logger.debug("done writing file.")
color_to_edge_indices = dict()
for aut_index, automaton in enumerate(jani_program.automata):
for edge_index, edge in enumerate(automaton.edges):
new_list = color_to_edge_indices.get(edge.color,
stormpy.FlatSet())
new_list.insert(
jani_program.encode_automaton_and_edge_index(
aut_index, edge_index))
color_to_edge_indices[edge.color] = new_list
print(",".join(
["{}: {}".format(k, v) for k, v in color_to_edge_indices.items()]))
return JaniQuotientContainer(jani_program, edge_coloring,
holes_options, color_to_edge_indices)
def test_build_ma(self):
nr_states = 5
nr_choices = 10
# Build transition matrix
builder = stormpy.SparseMatrixBuilder(rows=0,
columns=0,
entries=0,
force_dimensions=False,
has_custom_row_grouping=True,
row_groups=0)
# Row group, state 0
builder.new_row_group(0)
# Add Transition for (state) 0 to target states
builder.add_next_value(0, 2, 1)
builder.add_next_value(1, 2, 1)
builder.add_next_value(2, 0, 0.8)
builder.add_next_value(2, 1, 0.2)
# Row group, state 1
builder.new_row_group(3)
# New Transition (state) 1 to target state
builder.add_next_value(3, 3, 1)
# Row group, state 2
builder.new_row_group(4)
# New Transition (state) 1 to target state
builder.add_next_value(4, 0, 0.9)
builder.add_next_value(4, 4, 0.1)
# Row group, state 3
builder.new_row_group(5)
# New Transition (state) 1 to target state
builder.add_next_value(5, 4, 1)
builder.add_next_value(6, 3, 1)
# Row group, state 4
builder.new_row_group(7)
# New Transition (state) 1 to target state
builder.add_next_value(7, 3, 0.5)
builder.add_next_value(7, 4, 0.5)
builder.add_next_value(8, 3, 1)
builder.add_next_value(9, 4, 1)
transition_matrix = builder.build(nr_choices, nr_states)
# state labeling
state_labeling = stormpy.storage.StateLabeling(nr_states)
# Add labels
state_labels = {'init', 'deadlock'}
for label in state_labels:
state_labeling.add_label(label)
# Add label to states
state_labeling.add_label_to_state('init', 0)
# state valuations
manager = stormpy.ExpressionManager()
var_s = manager.create_integer_variable(name='s')
v_builder = stormpy.StateValuationsBuilder()
v_builder.add_variable(var_s)
v_builder.add_state(state=0,
boolean_values=[],
integer_values=[0],
rational_values=[])
v_builder.add_state(state=1,
boolean_values=[],
integer_values=[2],
rational_values=[])
v_builder.add_state(state=2,
boolean_values=[],
integer_values=[1],
rational_values=[])
v_builder.add_state(state=3,
boolean_values=[],
integer_values=[4],
rational_values=[])
v_builder.add_state(state=4,
boolean_values=[],
integer_values=[3],
rational_values=[])
state_valuations = v_builder.build(nr_states)
# choice origins:
prism_program = stormpy.parse_prism_program(
get_example_path("ma", "hybrid_states.ma"))
index_to_identifier_mapping = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
id_to_command_set_mapping = [stormpy.FlatSet() for _ in range(11)]
id_to_command_set_mapping[1].insert(2)
id_to_command_set_mapping[2].insert(1)
id_to_command_set_mapping[3].insert(0)
id_to_command_set_mapping[4].insert(4)
id_to_command_set_mapping[5].insert(3)
id_to_command_set_mapping[6].insert(9)
id_to_command_set_mapping[7].insert(8)
id_to_command_set_mapping[8].insert(7)
id_to_command_set_mapping[9].insert(6)
id_to_command_set_mapping[10].insert(5)
choice_origins = stormpy.PrismChoiceOrigins(
prism_program, index_to_identifier_mapping,
id_to_command_set_mapping)
exit_rates = [3.0, 12.0, 10.0, 3.0, 4.0]
markovian_states = stormpy.BitVector(5, [0, 1, 2, 3, 4])
# Build components, set rate_transitions to False
components = stormpy.SparseModelComponents(
transition_matrix=transition_matrix,
state_labeling=state_labeling,
rate_transitions=False,
markovian_states=markovian_states)
components.state_valuations = state_valuations
components.choice_origins = choice_origins
components.exit_rates = exit_rates
# Build MA
ma = stormpy.storage.SparseMA(components)
assert type(ma) is stormpy.SparseMA
assert not ma.supports_parameters
# Test transition matrix
assert ma.nr_choices == nr_choices
assert ma.nr_states == nr_states
assert ma.nr_transitions == 13
assert ma.transition_matrix.nr_columns == nr_states
assert ma.transition_matrix.nr_rows == nr_choices
# Check row groups
assert ma.transition_matrix.get_row_group_start(0) == 0
assert ma.transition_matrix.get_row_group_end(0) == 3
assert ma.transition_matrix.get_row_group_start(1) == 3
assert ma.transition_matrix.get_row_group_end(1) == 4
assert ma.transition_matrix.get_row_group_start(2) == 4
assert ma.transition_matrix.get_row_group_end(2) == 5
assert ma.transition_matrix.get_row_group_start(3) == 5
assert ma.transition_matrix.get_row_group_end(3) == 7
assert ma.transition_matrix.get_row_group_start(4) == 7
assert ma.transition_matrix.get_row_group_end(4) == 10
for e in ma.transition_matrix:
assert e.value() == 1.0 or e.value() == 0 or e.value(
) == 0.8 or e.value() == 0.2 or e.value() == 0.1 or e.value(
) == 0.5 or e.value() == 0.9
for state in ma.states:
assert len(state.actions) <= 3
# Test state labeling
assert ma.labeling.get_labels() == {'deadlock', 'init'}
# Test reward models
assert len(ma.reward_models) == 0
# Test choice labeling
assert not ma.has_choice_labeling()
# Test state valuations
assert ma.has_state_valuations()
value_s = [None] * nr_states
for s in range(0, ma.nr_states):
value_s[s] = ma.state_valuations.get_integer_value(s, var_s)
assert value_s == [0, 2, 1, 4, 3]
# Test choice origins
assert ma.has_choice_origins()
assert ma.choice_origins.get_number_of_identifiers() == 11
# Test exit rates
assert ma.exit_rates == [3.0, 12.0, 10.0, 3.0, 4.0]
# Test Markovian states
assert ma.markovian_states == stormpy.BitVector(5, [0, 1, 2, 3, 4])
def test_build_dtmc(self):
nr_states = 13
nr_choices = 13
# transition_matrix
builder = stormpy.SparseMatrixBuilder(rows=0,
columns=0,
entries=0,
force_dimensions=False,
has_custom_row_grouping=False,
row_groups=0)
# Add transitions
builder.add_next_value(0, 1, 0.5)
builder.add_next_value(0, 2, 0.5)
builder.add_next_value(1, 3, 0.5)
builder.add_next_value(1, 4, 0.5)
builder.add_next_value(2, 5, 0.5)
builder.add_next_value(2, 6, 0.5)
builder.add_next_value(3, 7, 0.5)
builder.add_next_value(3, 1, 0.5)
builder.add_next_value(4, 8, 0.5)
builder.add_next_value(4, 9, 0.5)
builder.add_next_value(5, 10, 0.5)
builder.add_next_value(5, 11, 0.5)
builder.add_next_value(6, 2, 0.5)
builder.add_next_value(6, 12, 0.5)
for s in range(7, 13):
builder.add_next_value(s, s, 1)
# Build transition matrix, update number of rows and columns
transition_matrix = builder.build(nr_states, nr_states)
# state labeling
state_labeling = stormpy.storage.StateLabeling(nr_states)
state_labels = {
'init', 'one', 'two', 'three', 'four', 'five', 'six', 'done',
'deadlock'
}
for label in state_labels:
state_labeling.add_label(label)
# Add label to one state
state_labeling.add_label_to_state('init', 0)
state_labeling.add_label_to_state('one', 7)
state_labeling.add_label_to_state('two', 8)
state_labeling.add_label_to_state('three', 9)
state_labeling.add_label_to_state('four', 10)
state_labeling.add_label_to_state('five', 11)
state_labeling.add_label_to_state('six', 12)
state_labeling.set_states(
'done', stormpy.BitVector(nr_states, [7, 8, 9, 10, 11, 12]))
# reward_models
reward_models = {}
# Create a vector representing the state-action rewards
action_reward = [
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
]
reward_models['coin_flips'] = stormpy.SparseRewardModel(
optional_state_action_reward_vector=action_reward)
# state valuations
manager = stormpy.ExpressionManager()
var_s = manager.create_integer_variable(name='s')
var_d = manager.create_integer_variable(name='d')
v_builder = stormpy.StateValuationsBuilder()
v_builder.add_variable(var_s)
v_builder.add_variable(var_d)
for s in range(7):
v_builder.add_state(state=s, integer_values=[s, 0])
for s in range(7, 13):
v_builder.add_state(state=s, integer_values=[7, s - 6])
state_valuations = v_builder.build(13)
# choice origins
prism_program = stormpy.parse_prism_program(
get_example_path("dtmc", "die.pm"))
index_to_identifier_mapping = [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8]
id_to_command_set_mapping = [stormpy.FlatSet() for _ in range(9)]
for i in range(1, 8): # 0: no origin
id_to_command_set_mapping[i].insert(i - 1)
id_to_command_set_mapping[8].insert(7)
choice_origins = stormpy.PrismChoiceOrigins(
prism_program, index_to_identifier_mapping,
id_to_command_set_mapping)
# Construct components
components = stormpy.SparseModelComponents(
transition_matrix=transition_matrix,
state_labeling=state_labeling,
reward_models=reward_models)
components.choice_origins = choice_origins
components.state_valuations = state_valuations
# Build DTMC
dtmc = stormpy.storage.SparseDtmc(components)
assert type(dtmc) is stormpy.SparseDtmc
assert not dtmc.supports_parameters
# Test transition matrix
assert dtmc.nr_choices == nr_choices
assert dtmc.nr_states == nr_states
assert dtmc.nr_transitions == 20
assert dtmc.transition_matrix.nr_entries == dtmc.nr_transitions
for e in dtmc.transition_matrix:
assert e.value() == 0.5 or e.value() == 0 or (e.value() == 1
and e.column > 6)
for state in dtmc.states:
assert len(state.actions) <= 1
# Test state labeling
assert dtmc.labeling.get_labels() == {
'init', 'deadlock', 'done', 'one', 'two', 'three', 'four', 'five',
'six'
}
# Test reward_models
assert len(dtmc.reward_models) == 1
assert not dtmc.reward_models["coin_flips"].has_state_rewards
assert dtmc.reward_models["coin_flips"].has_state_action_rewards
for reward in dtmc.reward_models["coin_flips"].state_action_rewards:
assert reward == 1.0 or reward == 0.0
assert not dtmc.reward_models["coin_flips"].has_transition_rewards
# Test choice labeling
assert not dtmc.has_choice_labeling()
# Test state_valuations
assert dtmc.has_state_valuations()
assert dtmc.state_valuations
value_s = [None] * nr_states
value_d = [None] * nr_states
for s in range(0, dtmc.nr_states):
value_s[s] = dtmc.state_valuations.get_integer_value(s, var_s)
value_d[s] = dtmc.state_valuations.get_integer_value(s, var_d)
assert value_s == [0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7]
assert value_d == [0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6]
# Test choice origins
assert dtmc.has_choice_origins()
assert dtmc.choice_origins is components.choice_origins
assert dtmc.choice_origins.get_number_of_identifiers() == 9
def test_build_mdp(self):
nr_states = 13
nr_choices = 14
# Build transition matrix
builder = stormpy.SparseMatrixBuilder(rows=0,
columns=0,
entries=0,
force_dimensions=False,
has_custom_row_grouping=True,
row_groups=0)
# Row group, state 0
builder.new_row_group(0)
builder.add_next_value(0, 1, 0.5)
builder.add_next_value(0, 2, 0.5)
builder.add_next_value(1, 1, 0.2)
builder.add_next_value(1, 2, 0.8)
# Row group, state 1
builder.new_row_group(2)
builder.add_next_value(2, 3, 0.5)
builder.add_next_value(2, 4, 0.5)
# Row group, state 2
builder.new_row_group(3)
builder.add_next_value(3, 5, 0.5)
builder.add_next_value(3, 6, 0.5)
# Row group, state 3
builder.new_row_group(4)
builder.add_next_value(4, 7, 0.5)
builder.add_next_value(4, 1, 0.5)
# Row group, state 4
builder.new_row_group(5)
builder.add_next_value(5, 8, 0.5)
builder.add_next_value(5, 9, 0.5)
# Row group, state 5
builder.new_row_group(6)
builder.add_next_value(6, 10, 0.5)
builder.add_next_value(6, 11, 0.5)
# Row group, state 6
builder.new_row_group(7)
builder.add_next_value(7, 2, 0.5)
builder.add_next_value(7, 12, 0.5)
# final states
for s in range(8, 14):
builder.new_row_group(s)
builder.add_next_value(s, s - 1, 1)
transition_matrix = builder.build(nr_choices, nr_states)
# state labeling
state_labeling = stormpy.storage.StateLabeling(nr_states)
labels = {
'init', 'one', 'two', 'three', 'four', 'five', 'six', 'done',
'deadlock'
}
for label in labels:
state_labeling.add_label(label)
state_labeling.add_label_to_state('init', 0)
state_labeling.add_label_to_state('one', 7)
state_labeling.add_label_to_state('two', 8)
state_labeling.add_label_to_state('three', 9)
state_labeling.add_label_to_state('four', 10)
state_labeling.add_label_to_state('five', 11)
state_labeling.add_label_to_state('six', 12)
state_labeling.set_states(
'done', stormpy.BitVector(nr_states, [7, 8, 9, 10, 11, 12]))
# reward models
reward_models = {}
# Vector representing the state-action rewards
action_reward = [
0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0
]
reward_models['coin_flips'] = stormpy.SparseRewardModel(
optional_state_action_reward_vector=action_reward)
# choice labeling
choice_labeling = stormpy.storage.ChoiceLabeling(nr_choices)
choice_labels = {'a', 'b'}
for label in choice_labels:
choice_labeling.add_label(label)
choice_labeling.add_label_to_choice('a', 0)
choice_labeling.add_label_to_choice('b', 1)
# state valuations
manager = stormpy.ExpressionManager()
var_s = manager.create_integer_variable(name='s')
var_d = manager.create_integer_variable(name='d')
v_builder = stormpy.StateValuationsBuilder()
v_builder.add_variable(var_s)
v_builder.add_variable(var_d)
for s in range(7):
# values: vector [value for s, value for d]
v_builder.add_state(state=s,
boolean_values=[],
integer_values=[s, 0],
rational_values=[])
for s in range(7, 13):
v_builder.add_state(state=s,
boolean_values=[],
integer_values=[7, s - 6],
rational_values=[])
state_valuations = v_builder.build(13)
# choice origins
prism_program = stormpy.parse_prism_program(
get_example_path("mdp", "die_c1.nm"))
index_to_identifier_mapping = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9, 9, 9, 9
]
id_to_command_set_mapping = [stormpy.FlatSet() for _ in range(10)]
for i in range(1, 9):
# 0: no origin
id_to_command_set_mapping[i].insert(i - 1)
id_to_command_set_mapping[9].insert(8)
choice_origins = stormpy.PrismChoiceOrigins(
prism_program, index_to_identifier_mapping,
id_to_command_set_mapping)
# Construct Components
components = stormpy.SparseModelComponents(
transition_matrix=transition_matrix,
state_labeling=state_labeling,
reward_models=reward_models,
rate_transitions=False)
components.state_valuations = state_valuations
components.choice_labeling = choice_labeling
components.choice_origins = choice_origins
# Build MDP
mdp = stormpy.storage.SparseMdp(components)
assert type(mdp) is stormpy.SparseMdp
assert not mdp.supports_parameters
# Test transition matrix
assert mdp.nr_choices == nr_choices
assert mdp.nr_states == nr_states
assert mdp.nr_transitions == 22
assert mdp.transition_matrix.nr_entries == mdp.nr_transitions
for e in mdp.transition_matrix:
assert e.value() == 0.5 or e.value() == 0 or e.value(
) == 0.2 or e.value() == 0.8 or (e.value() == 1 and e.column > 6)
for state in mdp.states:
assert len(state.actions) <= 2
# Test state labeling
assert mdp.labeling.get_labels() == {
'init', 'deadlock', 'done', 'one', 'two', 'three', 'four', 'five',
'six'
}
# Test reward models
assert len(mdp.reward_models) == 1
assert not mdp.reward_models["coin_flips"].has_state_rewards
assert mdp.reward_models["coin_flips"].has_state_action_rewards
for reward in mdp.reward_models["coin_flips"].state_action_rewards:
assert reward == 1.0 or reward == 0.0
assert not mdp.reward_models["coin_flips"].has_transition_rewards
# Test choice labeling
assert mdp.has_choice_labeling()
assert mdp.choice_labeling.get_labels() == {'a', 'b'}
# Test state valuations
assert mdp.has_state_valuations()
assert mdp.state_valuations
value_s = [None] * nr_states
value_d = [None] * nr_states
for s in range(0, mdp.nr_states):
value_s[s] = mdp.state_valuations.get_integer_value(s, var_s)
value_d[s] = mdp.state_valuations.get_integer_value(s, var_d)
assert value_s == [0, 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7]
assert value_d == [0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6]
# Test choice origins
assert mdp.has_choice_origins()
assert mdp.choice_origins is components.choice_origins
assert mdp.choice_origins.get_number_of_identifiers() == 10