def restrict(self, edge_indices, edge_0_indices):
logger.debug("select mask for submodel construction...")
all_states = stormpy.BitVector(self._model.nr_states, True)
if self._color_0_actions is None:
self._color_0_actions = stormpy.BitVector(self._model.nr_choices, False)
for act_index in range(0, self._model.nr_choices):
if self._model.choice_origins.get_edge_index_set(act_index).is_subset_of(edge_0_indices):
assert self._model.choice_origins.get_edge_index_set(act_index).is_subset_of(edge_indices)
self._color_0_actions.set(act_index)
selected_actions = stormpy.BitVector(self._color_0_actions)
for act_index in range(0, self._model.nr_choices):
if selected_actions.get(act_index):
continue
#TODO many actions are always taken. We should preprocess these.
if self._model.choice_origins.get_edge_index_set(act_index).is_subset_of(edge_indices):
selected_actions.set(act_index)
keep_unreachable_states = False
logger.debug("Construct submodel...")
subsystem_options = stormpy.SubsystemBuilderOptions()
subsystem_options.build_action_mapping = True
submodel_construction = stormpy.construct_submodel(self._model, all_states, selected_actions, keep_unreachable_states, subsystem_options)
assert (not keep_unreachable_states) or submodel_construction.kept_actions == selected_actions, "kept: {} vs selected: {}".format(submodel_construction.kept_actions, selected_actions)
self._submodel = submodel_construction.model
self._mapping_to_original = submodel_construction.new_to_old_action_mapping
assert len(self._mapping_to_original) == self._submodel.nr_choices, "mapping contains {} actions, but model has {} actions".format(len(self._mapping_to_original), self._submodel.nr_choices)
assert self._submodel.has_choice_origins()
return self._submodel
def test_init_length(self):
bit = stormpy.BitVector(10)
assert bit.size() == 10
assert bit.number_of_set_bits() == 0
bit = stormpy.BitVector(5, True)
assert bit.size() == 5
assert bit.number_of_set_bits() == 5
def test_negate(self):
bit = stormpy.BitVector(7, [0, 6])
bit2 = stormpy.BitVector(bit)
bit = ~bit
assert bit.get(0) is False
assert bit.get(6) is False
for i in range(bit.size()):
assert bit.get(i) is not bit2.get(i)
def test_init_vector(self):
bit = stormpy.BitVector(5, [2, 3])
assert bit.size() == 5
assert bit.number_of_set_bits() == 2
assert bit.get(0) is False
assert bit.get(1) is False
assert bit.get(2) is True
assert bit.get(3) is True
assert bit.get(4) is False
def test_elimination_on_two_dice(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_model(program, formulas)
subsystem = stormpy.BitVector(model.nr_states, True)
possible_ec_rows = stormpy.BitVector(model.nr_choices, True)
add_sink_rows = subsystem
ec_elimination_result = stormpy.eliminate_ECs(model.transition_matrix,
subsystem,
possible_ec_rows,
add_sink_rows, True)
assert ec_elimination_result.matrix.nr_rows == 218
assert ec_elimination_result.matrix.nr_columns == model.nr_states
assert ec_elimination_result.old_to_new_state_mapping[23] == 23
assert ec_elimination_result.new_to_old_row_mapping[200] == 245
assert ec_elimination_result.sink_rows.number_of_set_bits() == 36
def _apply_scheduler(mdp, scheduler, drop_unreachable_states):
action_selection = scheduler.compute_action_support(
mdp.nondeterministic_choice_indices)
all_states = stormpy.BitVector(mdp.nr_states, True)
subsystem_construction_options = stormpy.SubsystemBuilderOptions()
subsystem_construction_options.build_action_mapping = True
result = stormpy.construct_submodel(mdp, all_states, action_selection,
not drop_unreachable_states,
subsystem_construction_options)
return result.model, result.new_to_old_state_mapping, result.new_to_old_action_mapping
def test_for_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_model(program, formulas)
assert model.nr_states == 12
selected_outgoing_transitions = stormpy.BitVector(
model.nr_states, True)
selected_outgoing_transitions.set(3, False)
selected_outgoing_transitions.set(6, False)
options = stormpy.SubsystemBuilderOptions()
options.fix_deadlocks = True
submodel_result = stormpy.construct_submodel(
model, stormpy.BitVector(model.nr_states, True),
selected_outgoing_transitions, False, options)
submodel = submodel_result.model
abort_label = submodel_result.deadlock_label
assert submodel.nr_states == 8
assert abort_label == "deadl"
assert "deadl" in submodel.labeling.get_labels()
def example_building_mas_01():
if not numpy_found:
print("Numpy not available")
return
# Building the transition matrix using numpy
transitions = np.array([
[0, 1, 0, 0, 0],
[0.8, 0, 0.2, 0, 0],
[0.9, 0, 0, 0.1, 0],
[0, 0, 0, 0, 1],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]
], dtype='float64')
# Build matrix and define indices of row groups (ascending order)
transition_matrix = stormpy.build_sparse_matrix(transitions, [0, 2, 3, 4, 5])
print(transition_matrix)
# StateLabeling
state_labeling = stormpy.storage.StateLabeling(5)
# Add labels
state_labels = {'init', 'deadlock'}
# Set labeling of states
for label in state_labels:
state_labeling.add_label(label)
state_labeling.add_label_to_state('init', 0)
# Choice labeling
choice_labeling = stormpy.storage.ChoiceLabeling(6)
# Add labels
choice_labels = {'alpha', 'beta'}
# Set labeling of choices
for label in choice_labels:
choice_labeling.add_label(label)
choice_labeling.add_label_to_choice('alpha', 0)
choice_labeling.add_label_to_choice('beta', 1)
exit_rates = [0.0, 10.0, 12.0, 1.0, 1.0]
markovian_states = stormpy.BitVector(5, [1, 2, 3, 4])
# Collect components
components = stormpy.SparseModelComponents(transition_matrix=transition_matrix, state_labeling=state_labeling,
markovian_states=markovian_states)
components.choice_labeling = choice_labeling
components.exit_rates = exit_rates
# Build the model
ma = stormpy.storage.SparseMA(components)
print(ma)
def __init__(self, mdp, holes, action_to_hole_options):
# reference to the quotient MDP
self.mdp = mdp
# design space
self.holes = holes
# for each choice of the quotient MDP contains a set of hole-option labelings
self.action_to_hole_options = action_to_hole_options
# bitvector of quotient MDP choices not labeled by any hole
self.default_actions = None
# for each state of the quotient MDP, a set of holes associated with the actions in this state
self.state_to_holes = None
# whether each state is marked by at most one hole
self.coloring_is_simple = None
# to each hole-option pair a list of actions colored by this combination
self.hole_option_to_actions = None
# compute default actions
self.default_actions = stormpy.BitVector(self.mdp.nr_choices, False)
for choice in range(self.mdp.nr_choices):
if not self.action_to_hole_options[choice]:
self.default_actions.set(choice)
# collect relevant holes in states
tm = self.mdp.transition_matrix
self.state_to_holes = []
for state in range(self.mdp.nr_states):
relevant_holes = set()
for action in range(tm.get_row_group_start(state),
tm.get_row_group_end(state)):
relevant_holes.update(
set(self.action_to_hole_options[action].keys()))
self.state_to_holes.append(relevant_holes)
self.coloring_is_simple = all([
len(self.state_to_holes[state]) <= 1
for state in range(self.mdp.nr_states)
])
# construct reverse coloring
self.hole_option_to_actions = [[] for hole in self.holes]
for hole_index, hole in enumerate(self.holes):
self.hole_option_to_actions[hole_index] = [
[] for option in hole.options
]
for action in range(self.mdp.nr_choices):
for hole_index, option in self.action_to_hole_options[
action].items():
self.hole_option_to_actions[hole_index][option].append(action)
def restrict_mdp(self, mdp, selected_actions_bv):
'''
Restrict the quotient MDP to the selected actions.
:param selected_actions_bv a bitvector of selected actions
:return (1) the restricted model
:return (2) sub- to full state mapping
:return (3) sub- to full action mapping
'''
keep_unreachable_states = False # TODO investigate this
all_states = stormpy.BitVector(mdp.nr_states, True)
submodel_construction = stormpy.construct_submodel(
mdp, all_states, selected_actions_bv, keep_unreachable_states,
self.subsystem_builder_options)
model = submodel_construction.model
state_map = list(submodel_construction.new_to_old_state_mapping)
choice_map = list(submodel_construction.new_to_old_action_mapping)
return model, state_map, choice_map
def test_submatrix(self):
model = stormpy.build_sparse_model_from_explicit(
get_example_path("dtmc", "die.tra"),
get_example_path("dtmc", "die.lab"))
matrix = model.transition_matrix
assert matrix.nr_rows == 13
assert matrix.nr_columns == 13
assert matrix.nr_entries == 20
assert matrix.nr_entries == model.nr_transitions
for e in matrix:
assert e.value() == 0.5 or e.value() == 0 or (e.value() == 1
and e.column > 6)
row_constraint = stormpy.BitVector(13, [0, 1, 3, 4, 7, 8, 9])
submatrix = matrix.submatrix(row_constraint, row_constraint)
assert submatrix.nr_rows == 7
assert submatrix.nr_columns == 7
assert submatrix.nr_entries == 10
for e in submatrix:
assert e.value() == 0.5 or e.value() == 0 or (e.value() == 1
and e.column > 3)
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_init_default(self):
bit = stormpy.BitVector()
assert bit.size() == 0
assert bit.number_of_set_bits() == 0
def example_building_mdps_01():
nr_states = 13
nr_choices = 14
# Transition matrix with custom row grouping: nondeterministic choice over the actions available in states
builder = stormpy.SparseMatrixBuilder(rows=0,
columns=0,
entries=0,
force_dimensions=False,
has_custom_row_grouping=True,
row_groups=0)
# New row group, for actions of 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)
# State 1
builder.new_row_group(2)
builder.add_next_value(2, 3, 0.5)
builder.add_next_value(2, 4, 0.5)
# State 2
builder.new_row_group(3)
builder.add_next_value(3, 5, 0.5)
builder.add_next_value(3, 6, 0.5)
# State 3
builder.new_row_group(4)
builder.add_next_value(4, 7, 0.5)
builder.add_next_value(4, 1, 0.5)
# State 4
builder.new_row_group(5)
builder.add_next_value(5, 8, 0.5)
builder.add_next_value(5, 9, 0.5)
# State 5
builder.new_row_group(6)
builder.add_next_value(6, 10, 0.5)
builder.add_next_value(6, 11, 0.5)
# State 6
builder.new_row_group(7)
builder.add_next_value(7, 2, 0.5)
builder.add_next_value(7, 12, 0.5)
# Add transitions for the 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()
# State labeling
state_labeling = stormpy.storage.StateLabeling(nr_states)
# Add labels
labels = {
'init', 'one', 'two', 'three', 'four', 'five', 'six', 'done',
'deadlock'
}
for label in labels:
state_labeling.add_label(label)
# Set labeling of states
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)
# Set label 'done' for multiple states
state_labeling.set_states(
'done', stormpy.BitVector(nr_states, [7, 8, 9, 10, 11, 12]))
# Choice labeling
choice_labeling = stormpy.storage.ChoiceLabeling(nr_choices)
choice_labels = {'a', 'b'}
# Add labels
for label in choice_labels:
choice_labeling.add_label(label)
# Set labels
choice_labeling.add_label_to_choice('a', 0)
choice_labeling.add_label_to_choice('b', 1)
print(choice_labeling)
# Reward models
reward_models = {}
# Create a 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)
# Collect components
components = stormpy.SparseModelComponents(
transition_matrix=transition_matrix,
state_labeling=state_labeling,
reward_models=reward_models,
rate_transitions=False)
components.choice_labeling = choice_labeling
# Build the model
mdp = stormpy.storage.SparseMdp(components)
print(mdp)
def test_init_bitvector(self):
bit = stormpy.BitVector(7, [0, 6])
bit2 = stormpy.BitVector(bit)
assert bit == bit2
assert bit2.get(0) is True
assert bit2.get(6) is True
def test_build_pomdp(self):
import numpy as np
nr_states = 10
nr_choices = 34
# Build transition matrix
builder = stormpy.SparseMatrixBuilder(rows=0,
columns=0,
entries=0,
force_dimensions=False,
has_custom_row_grouping=True,
row_groups=0)
transitions = np.array(
[[0, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1]])
transition_matrix = stormpy.build_sparse_matrix(
transitions,
row_group_indices=[0, 1, 5, 9, 13, 17, 21, 25, 29, 33])
# state labeling
state_labeling = stormpy.storage.StateLabeling(nr_states)
labels = {'deadlock', 'goal', 'init'}
for label in labels:
state_labeling.add_label(label)
state_labeling.add_label_to_state('init', 0)
state_labeling.add_label_to_state('goal', 9)
# reward models
reward_models = {}
# Vector representing state-action rewards
action_reward = [
0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0
]
reward_models[''] = stormpy.SparseRewardModel(
optional_state_action_reward_vector=action_reward)
# choice labeling
choice_labeling = stormpy.storage.ChoiceLabeling(nr_choices)
choice_labels = {'south', 'north', 'west', 'east', 'done'}
for label in choice_labels:
choice_labeling.add_label(label)
choice_labeling.set_choices(
'south',
stormpy.BitVector(nr_choices, [4, 8, 12, 16, 20, 24, 28, 32]))
choice_labeling.set_choices(
'north',
stormpy.BitVector(nr_choices, [3, 7, 11, 15, 19, 23, 27, 31]))
choice_labeling.set_choices(
'west',
stormpy.BitVector(nr_choices, [2, 6, 10, 14, 18, 22, 26, 30]))
choice_labeling.set_choices(
'east', stormpy.BitVector(nr_choices,
[1, 5, 9, 13, 17, 21, 25, 29]))
choice_labeling.set_choices('done',
stormpy.BitVector(nr_choices, [33]))
# state valuations
manager = stormpy.ExpressionManager()
var_x = manager.create_integer_variable(name='x')
var_y = manager.create_integer_variable(name='y')
var_o = manager.create_integer_variable(name='o')
v_builder = stormpy.StateValuationsBuilder()
v_builder.add_variable(var_x)
v_builder.add_variable(var_y)
v_builder.add_variable(var_o)
v_builder.add_state(state=0,
boolean_values=[],
integer_values=[0, 0, 0],
rational_values=[])
v_builder.add_state(state=1,
boolean_values=[],
integer_values=[0, 0, 1],
rational_values=[])
v_builder.add_state(state=2,
boolean_values=[],
integer_values=[0, 1, 1],
rational_values=[])
v_builder.add_state(state=3,
boolean_values=[],
integer_values=[0, 2, 1],
rational_values=[])
v_builder.add_state(state=4,
boolean_values=[],
integer_values=[1, 0, 1],
rational_values=[])
v_builder.add_state(state=5,
boolean_values=[],
integer_values=[1, 1, 1],
rational_values=[])
v_builder.add_state(state=6,
boolean_values=[],
integer_values=[1, 2, 1],
rational_values=[])
v_builder.add_state(state=7,
boolean_values=[],
integer_values=[2, 1, 1],
rational_values=[])
v_builder.add_state(state=8,
boolean_values=[],
integer_values=[2, 2, 1],
rational_values=[])
v_builder.add_state(state=9,
boolean_values=[],
integer_values=[2, 0, 2],
rational_values=[])
state_valuations = v_builder.build(nr_states)
observations = [1, 0, 0, 0, 0, 0, 0, 0, 0, 2]
# Build components, set rate_transitions to False
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
components.observability_classes = observations
# Build POMDP
pomdp = stormpy.storage.SparsePomdp(components)
assert type(pomdp) is stormpy.SparsePomdp
assert not pomdp.supports_parameters
# Test transition matrix
assert pomdp.nr_choices == nr_choices
assert pomdp.nr_states == nr_states
assert pomdp.nr_transitions == 41
for e in pomdp.transition_matrix:
assert e.value() == 1 or e.value() == 0 or e.value() == 0.125
for state in pomdp.states:
assert len(state.actions) <= 4
# Test state labeling
assert pomdp.labeling.get_labels() == {'init', 'goal', 'deadlock'}
# Test reward models
assert len(pomdp.reward_models) == 1
assert not pomdp.reward_models[''].has_state_rewards
assert pomdp.reward_models[''].has_state_action_rewards
for reward in pomdp.reward_models[''].state_action_rewards:
assert reward == 1.0 or reward == 0.0
assert not pomdp.reward_models[''].has_transition_rewards
# Test choice labeling
assert pomdp.has_choice_labeling()
assert pomdp.choice_labeling.get_labels() == {
'east', 'west', 'north', 'south', 'done'
}
# Test state valuations
assert pomdp.has_state_valuations()
assert pomdp.state_valuations
value_x = [None] * nr_states
value_y = [None] * nr_states
value_o = [None] * nr_states
for s in range(0, pomdp.nr_states):
value_x[s] = pomdp.state_valuations.get_integer_value(s, var_x)
value_y[s] = pomdp.state_valuations.get_integer_value(s, var_y)
value_o[s] = pomdp.state_valuations.get_integer_value(s, var_o)
assert value_x == [0, 0, 0, 0, 1, 1, 1, 2, 2, 2]
assert value_y == [0, 0, 1, 2, 0, 1, 2, 1, 2, 0]
assert value_o == [0, 1, 1, 1, 1, 1, 1, 1, 1, 2]
# Test choice origins
assert not pomdp.has_choice_origins()
assert pomdp.observations == [1, 0, 0, 0, 0, 0, 0, 0, 0, 2]
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_ctmc(self):
import numpy as np
nr_states = 12
nr_choices = 12
# Build transition_matrix
transitions = np.array([[0, 0.5, 0.5, 200, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0.5, 200, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0.5, 0, 200, 0, 0, 0, 0, 0],
[200, 0, 0, 0, 0, 0, 0.5, 0.5, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 200, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0, 0.5, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 200, 0],
[0, 200, 0, 0, 0, 0, 0, 0, 0, 0.5, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
dtype='float64')
transition_matrix = stormpy.build_sparse_matrix(transitions)
# state labeling
state_labeling = stormpy.storage.StateLabeling(nr_states)
# Add labels
state_labels = {'init', 'deadlock', 'target'}
for label in state_labels:
state_labeling.add_label(label)
# Add labels to states
state_labeling.add_label_to_state('init', 0)
state_labeling.set_states('target',
stormpy.BitVector(nr_states, [5, 8]))
# reward models
reward_models = {}
# vector representing state-action rewards
action_reward = [
0.0, 0.0, 0.0, 0.0, 0.0, 2 / 3, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0
]
reward_models['served'] = stormpy.SparseRewardModel(
optional_state_action_reward_vector=action_reward)
# vector representing state rewards
state_reward = [
0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
]
reward_models['waiting'] = stormpy.SparseRewardModel(
optional_state_reward_vector=state_reward)
# choice labeling
choice_labeling = stormpy.storage.ChoiceLabeling(nr_choices)
choice_labels = {
'loop1a', 'loop1b', 'serve1', 'loop2a', 'loop2b', 'serve2'
}
# Add labels
for label in choice_labels:
choice_labeling.add_label(label)
choice_labeling.set_choices('loop1a',
stormpy.BitVector(nr_choices, [0, 2]))
choice_labeling.set_choices('loop1b',
stormpy.BitVector(nr_choices, [1, 4]))
choice_labeling.set_choices('serve1',
stormpy.BitVector(nr_choices, [5, 8]))
choice_labeling.set_choices('loop2a',
stormpy.BitVector(nr_choices, [3, 7]))
choice_labeling.set_choices('loop2b',
stormpy.BitVector(nr_choices, [6, 9]))
choice_labeling.set_choices('serve2',
stormpy.BitVector(nr_choices, [10, 11]))
# state exit rates
exit_rates = [
201.0, 200.5, 200.5, 201.0, 200.0, 1.5, 200.5, 200.5, 1.0, 200.0,
1.5, 1.0
]
# state valuations
manager = stormpy.ExpressionManager()
var_s = manager.create_integer_variable(name='s')
var_a = manager.create_integer_variable(name='a')
var_s1 = manager.create_integer_variable(name='s1')
var_s2 = manager.create_integer_variable(name='s2')
v_builder = stormpy.StateValuationsBuilder()
v_builder.add_variable(var_s)
v_builder.add_variable(var_a)
v_builder.add_variable(var_s1)
v_builder.add_variable(var_s2)
v_builder.add_state(state=0,
boolean_values=[],
integer_values=[1, 0, 0, 0],
rational_values=[])
v_builder.add_state(state=1,
boolean_values=[],
integer_values=[1, 0, 1, 0],
rational_values=[])
v_builder.add_state(state=2,
boolean_values=[],
integer_values=[1, 0, 0, 1],
rational_values=[])
v_builder.add_state(state=3,
boolean_values=[],
integer_values=[2, 0, 0, 0],
rational_values=[])
v_builder.add_state(state=4,
boolean_values=[],
integer_values=[1, 0, 1, 1],
rational_values=[])
v_builder.add_state(state=5,
boolean_values=[],
integer_values=[1, 1, 1, 0],
rational_values=[])
v_builder.add_state(state=6,
boolean_values=[],
integer_values=[2, 0, 0, 1],
rational_values=[])
v_builder.add_state(state=7,
boolean_values=[],
integer_values=[2, 0, 1, 0],
rational_values=[])
v_builder.add_state(state=8,
boolean_values=[],
integer_values=[1, 1, 1, 1],
rational_values=[])
v_builder.add_state(state=9,
boolean_values=[],
integer_values=[2, 0, 1, 1],
rational_values=[])
v_builder.add_state(state=10,
boolean_values=[],
integer_values=[2, 1, 0, 1],
rational_values=[])
v_builder.add_state(state=11,
boolean_values=[],
integer_values=[2, 1, 1, 1],
rational_values=[])
state_valuations = v_builder.build(nr_states)
# set rate_transitions to True: the transition values are interpreted as rates
components = stormpy.SparseModelComponents(
transition_matrix=transition_matrix,
state_labeling=state_labeling,
reward_models=reward_models,
rate_transitions=True)
components.choice_labeling = choice_labeling
components.exit_rates = exit_rates
components.state_valuations = state_valuations
# Build CTMC
ctmc = stormpy.storage.SparseCtmc(components)
assert type(ctmc) is stormpy.SparseCtmc
assert not ctmc.supports_parameters
# Test transition matrix
assert ctmc.nr_choices == nr_choices
assert ctmc.nr_states == nr_states
assert ctmc.nr_transitions == 22
assert ctmc.transition_matrix.nr_columns == nr_states
assert ctmc.transition_matrix.nr_rows == nr_choices
for e in ctmc.transition_matrix:
assert e.value() == 0.5 or e.value() == 0 or e.value(
) == 200 or e.value() == 1.0
for state in ctmc.states:
assert len(state.actions) <= 1
# Test state labeling
assert ctmc.labeling.get_labels() == {'target', 'init', 'deadlock'}
# Test reward models
assert len(ctmc.reward_models) == 2
assert not ctmc.reward_models["served"].has_state_rewards
assert ctmc.reward_models["served"].has_state_action_rewards
assert ctmc.reward_models["served"].state_action_rewards == [
0.0, 0.0, 0.0, 0.0, 0.0, 0.6666666666666666, 0.0, 0.0, 1.0, 0.0,
0.0, 0.0
]
assert not ctmc.reward_models["served"].has_transition_rewards
assert ctmc.reward_models["waiting"].has_state_rewards
assert not ctmc.reward_models["waiting"].has_state_action_rewards
assert ctmc.reward_models["waiting"].state_rewards == [
0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
]
assert not ctmc.reward_models["waiting"].has_transition_rewards
# Test choice labeling
assert ctmc.has_choice_labeling()
assert ctmc.choice_labeling.get_labels() == {
'loop1a', 'loop1b', 'serve1', 'loop2a', 'loop2b', 'serve2'
}
# Test state valuations
assert ctmc.has_state_valuations()
assert ctmc.state_valuations
value_s = [None] * nr_states
value_a = [None] * nr_states
value_s1 = [None] * nr_states
value_s2 = [None] * nr_states
for s in range(0, ctmc.nr_states):
value_s[s] = ctmc.state_valuations.get_integer_value(s, var_s)
value_a[s] = ctmc.state_valuations.get_integer_value(s, var_a)
value_s1[s] = ctmc.state_valuations.get_integer_value(s, var_s1)
value_s2[s] = ctmc.state_valuations.get_integer_value(s, var_s2)
assert value_s == [1, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 2]
assert value_a == [0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1]
assert value_s1 == [0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1]
assert value_s2 == [0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1]
# Test choice origins
assert not ctmc.has_choice_origins()
# Test exit_rates
assert ctmc.exit_rates == [
201.0, 200.5, 200.5, 201.0, 200.0, 1.5, 200.5, 200.5, 1.0, 200.0,
1.5, 1.0
]
def example_building_dtmcs_01():
# Use the SparseMatrixBuilder for constructing the transition matrix
builder = stormpy.SparseMatrixBuilder(rows=0,
columns=0,
entries=0,
force_dimensions=False,
has_custom_row_grouping=False)
# New Transition from state 0 to target state 1 with probability 0.5
builder.add_next_value(row=0, column=1, value=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)
# Add transitions for the final states
for s in range(7, 13):
builder.add_next_value(s, s, 1)
# Build matrix
transition_matrix = builder.build()
print(transition_matrix)
# State labeling
state_labeling = stormpy.storage.StateLabeling(13)
# Add labels
labels = {
'init', 'one', 'two', 'three', 'four', 'five', 'six', 'done',
'deadlock'
}
for label in labels:
state_labeling.add_label(label)
# Set label of state 0
state_labeling.add_label_to_state('init', 0)
print(state_labeling.get_states('init'))
# Set remaining labels
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)
# Set label 'done' for multiple states
state_labeling.set_states('done',
stormpy.BitVector(13, [7, 8, 9, 10, 11, 12]))
print(state_labeling)
# 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)
components = stormpy.SparseModelComponents(
transition_matrix=transition_matrix,
state_labeling=state_labeling,
reward_models=reward_models)
dtmc = stormpy.storage.SparseDtmc(components)
print(dtmc)
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