diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 35d2e1d92..5fcf85253 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -32,6 +32,7 @@ file(GLOB_RECURSE STORM_PERMISSIVESCHEDULER_FILES ${PROJECT_SOURCE_DIR}/src/perm
file(GLOB STORM_MODELS_FILES ${PROJECT_SOURCE_DIR}/src/models/*.h ${PROJECT_SOURCE_DIR}/src/models/*.cpp)
file(GLOB_RECURSE STORM_MODELS_SPARSE_FILES ${PROJECT_SOURCE_DIR}/src/models/sparse/*.h ${PROJECT_SOURCE_DIR}/src/models/sparse/*.cpp)
file(GLOB_RECURSE STORM_MODELS_SYMBOLIC_FILES ${PROJECT_SOURCE_DIR}/src/models/symbolic/*.h ${PROJECT_SOURCE_DIR}/src/models/symbolic/*.cpp)
+file(GLOB_RECURSE STORM_MODELTRANSFORMER_FILES ${PROJECT_SOURCE_DIR}/src/modeltransformer/*.h ${PROJECT_SOURCE_DIR}/src/modeltransformer/*.cpp)
file(GLOB STORM_PARSER_FILES ${PROJECT_SOURCE_DIR}/src/parser/*.h ${PROJECT_SOURCE_DIR}/src/parser/*.cpp)
file(GLOB_RECURSE STORM_PARSER_PRISMPARSER_FILES ${PROJECT_SOURCE_DIR}/src/parser/prismparser/*.h ${PROJECT_SOURCE_DIR}/src/parser/prismparser/*.cpp)
file(GLOB STORM_SETTINGS_FILES ${PROJECT_SOURCE_DIR}/src/settings/*.h ${PROJECT_SOURCE_DIR}/src/settings/*.cpp)
@@ -88,6 +89,7 @@ source_group(permissiveschedulers FILES ${STORM_PERMISSIVESCHEDULER_FILES})
source_group(models FILES ${STORM_MODELS_FILES})
source_group(models\\sparse FILES ${STORM_MODELS_SPARSE_FILES})
source_group(models\\symbolic FILES ${STORM_MODELS_SYMBOLIC_FILES})
+source_group(modeltransformer FILES ${STORM_MODELTRANSFORMER_FILES})
source_group(parser FILES ${STORM_PARSER_FILES})
source_group(parser\\prismparser FILES ${STORM_PARSER_PRISMPARSER_FILES})
source_group(settings FILES ${STORM_SETTINGS_FILES})
diff --git a/src/modeltransformers/StateDuplicator.h b/src/modeltransformers/StateDuplicator.h
new file mode 100644
index 000000000..f96e0f9c6
--- /dev/null
+++ b/src/modeltransformers/StateDuplicator.h
@@ -0,0 +1,204 @@
+#ifndef STORM_MDPTRIVIALSTATEELIMINATOR_H
+#define STORM_MDPTRIVIALSTATEELIMINATOR_H
+
+#include "../utility/macros.h"
+
+#include <chrono>
+#include <memory>
+#include <boost/optional.hpp>
+
+#include "src/adapters/CarlAdapter.h"
+#include "src/logic/Formulas.h"
+#include "src/modelchecker/results/ExplicitQualitativeCheckResult.h"
+#include "src/modelchecker/region/RegionCheckResult.h"
+#include "src/modelchecker/propositional/SparsePropositionalModelChecker.h"
+#include "src/models/sparse/StandardRewardModel.h"
+#include "src/settings/SettingsManager.h"
+#include "src/settings/modules/RegionSettings.h"
+#include "src/solver/OptimizationDirection.h"
+#include "src/storage/sparse/StateType.h"
+#include "src/storage/FlexibleSparseMatrix.h"
+#include "src/utility/constants.h"
+#include "src/utility/graph.h"
+#include "src/utility/macros.h"
+#include "src/utility/vector.h"
+
+#include "src/exceptions/InvalidArgumentException.h"
+#include "src/exceptions/InvalidPropertyException.h"
+#include "src/exceptions/InvalidStateException.h"
+#include "src/exceptions/InvalidSettingsException.h"
+#include "src/exceptions/NotImplementedException.h"
+#include "src/exceptions/UnexpectedException.h"
+#include "src/exceptions/NotSupportedException.h"
+#include "src/logic/FragmentSpecification.h"
+
+namespace storm {
+ namespace transformer {
+
+ /*
+ * Duplicates the state space of the given model and redirects the incoming transitions of gateStates of the first copy to the gateStates of the second copy.
+ * Only states reachable from the initial states are kept.
+ */
+ <template ModelType>
+ class StateDuplicator {
+ public:
+ typedef typename SparseMdpModelType::ValueType ValueType;
+ typedef typename SparseMdpModelType::RewardModelType RewardModelType;
+
+ struct StateDuplicatorReturnType {
+ ModelType model; // The resulting model
+ storm::storage::BitVector firstCopy; // The states of the resulting model that correspond to the first copy
+ storm::storage::BitVector secondCopy; // The states of the resulting model that correspond to the second copy
+ storm::storage::BitVector gateStates; // The gate states of the resulting model
+ std::vector<uint_fast64_t> newToOldStateIndexMapping; // Gives for each state in the resulting model the corresponding state in the original model
+ std::vector<uint_fast64_t> firstCopyOldToNewStateIndexMapping; //Maps old indices of states in the first copy to their new indices
+ std::vector<uint_fast64_t> secondCopyOldToNewStateIndexMapping; //Maps old indices of states in the second copy to their new indices
+ storm::storage::BitVector duplicatedStates; // The states in the original model that have been duplicated
+ storm::storage::BitVector reachableStates; // The states in the original model that are reachable from the initial state
+ };
+
+ /*
+ * Duplicates the state space of the given model and redirects the incoming transitions of gateStates of the first copy to the gateStates of the second copy.
+ *
+ * Note that only reachable states are kept.
+ * Gate states will always belong to the second copy.
+ * Rewards and labels are duplicated accordingly, but the states in the second copy will not get the label for initial states.
+ *
+ * @param originalModel The model to be duplicated
+ * @param gateStates The states for which the incoming transitions are redirected
+ */
+ static StateDuplicatorReturnType transform(ModelType const& originalModel, storm::storage::BitVector const& gateStates) {
+ StateDuplicatorReturnType result;
+
+ // Collect some data for the result
+ initializeTransformation(originalModel, gateStates, result);
+
+ // Transform the ingedients of the model
+
+ storm::storage::SparseMatrix<ValueType> matrix = transformMatrix(originalModel.getTransitionMatrix(), originalModel, gateStates, result);
+
+ //TODO
+ return result;
+ }
+
+ private:
+
+ static void initializeTransformation(ModelType const& originalModel, storm::storage::BitVector const& gateStates, StateDuplicatorReturnType& result) {
+
+ storm::storage::BitVector noStates(originalModel.getNumberOfStates(), false)
+ // Get the states that are reachable without visiting a gateState
+ storm::storage::BitVector statesForFirstCopy = storm::utility::graph::getReachableStates(originalModel.getTransitionMatrix(), originalModel.getInitialStates(), ~gateStates, noStates);
+
+ // Get the states reachable from gateStates
+ storm::storage::BitVector statesForSecondCopy = storm::utility::graph::getReachableStates(originalModel.getTransitionMatrix(), gateStates, ~noStates, noStates);
+
+ result.duplicatedStates = statesForFirstCopy & statesForSecondCopy;
+ result.reachableStates = statesForFirstCopy | statesForSecondCopy;
+
+ uint_fast64_t numStates = statesForFirstCopy.getNumberOfSetBits() + statesForSecondCopy.getNumberOfSetBits();
+ result.firstCopy = statesForFirstCopy % reachableStates; // only consider reachable states
+ result.firstCopy.resize(numStates, false); // the new states do NOT belong to the first copy
+ result.secondCopy = (statesForSecondCopy & (~statesForFirstCopy)) % reachableStates; // only consider reachable states
+ result.secondCopy.resize(numStates, true); // the new states DO belong to the second copy
+ result.gateStates = gateStates;
+ gateStates.resize(numStates, false); // there are no duplicated gateStates
+ STORM_LOG_ASSERT((result.firstCopy^result.secondCopy).full()), "firstCopy and secondCopy do not partition the state space.");
+
+ // Get the state mappings.
+ // We initialize them with illegal values to assert that we don't get a valid
+ // state when given e.g. an unreachable state or a state from the other copy.
+ result.newToOldStateIndexMapping = std::vector<uint_fast64_t>(numStates, std::numeric_limits<uint_fast64_t>::max());
+ result.firstCopyOldToNewStateIndexMapping = std::vector<uint_fast64_t>(originalModel.getNumberOfStates(), std::numeric_limits<uint_fast64_t>::max());
+ result.secondCopyOldToNewStateIndexMapping = std::vector<uint_fast64_t>(originalModel.getNumberOfStates(), std::numeric_limits<uint_fast64_t>::max());
+ uint_fast64_t newState = 0;
+ for(auto const& oldState : reachableStates){
+ result.newToOldStateIndexMapping[newState] = oldState;
+ if(statesForFirstCopy.get(oldState)){
+ result.firstCopyOldToNewStateIndexMapping[oldState] = newState;
+ } else {
+ result.secondCopyOldToNewStateIndexMapping[oldState] = newState;
+ }
+ ++newState;
+ }
+ // The remaining states are duplicates. All these states belong to the second copy.
+
+ for(auto const& oldState : result.duplicatedStates) {
+ result.newToOldStateIndexMapping[newState] = oldState;
+ result.secondCopyOldToNewStateIndexMapping[oldState] = newState;
+ ++newState
+ }
+ STORM_LOG_ASSERT(newState == numStates, "Unexpected state Indices");
+ }
+
+ static storm::storage::SparseMatrix<ValueType> transformMatrix(storm::storage::SparseMatrix<ValueType> const& originalMatrix, StateDuplicatorReturnType const& result) {
+ // Build the builder
+ uint_fast64_t numStates = result.newToOldStateIndexMapping.size();
+ uint_fast64_t numRows = 0;
+ uint_fast64_t numEntries = 0;
+ for(auto const& oldState : result.newToOldStateIndexMapping){
+ numRows += originalMatrix.getRowGroupSize(oldState);
+ numEntries += stateOccurrences * originalMatrix.getRowGroupEntryCount(oldState);
+ }
+ storm::storage::SparseMatrixBuilder<ValueType> builder(numRows, numStates, numEntries, true, !originalMatrix.hasTrivialRowGrouping(), originalMatrix.hasTrivialRowGrouping() ? 0 : numStates);
+
+ // Fill in the data
+ uint_fast64_t newRow = 0;
+ for(uint_fast64_t newState = 0; newState < numStates; ++newState){
+ if(!originalMatrix.hasTrivialRowGrouping()){
+ builder.newRowGroup(newRow);
+ }
+ uint_fast64_t oldState = result.newToOldStateIndexMapping[newState];
+ const& correctOldToNewMapping = result.firstCopy.get(newState) ? result.firstCopyOldToNewStateIndexMapping : result.secondCopyOldToNewStateIndexMapping;
+ for (uint_fast64_t oldRow = originalMatrix.getRowGroupIndices()[oldState]; oldRow < originalMatrix.getRowGroupIndices()[oldState+1]; ++oldRow){
+ for(auto const& entry : originalMatrix.getRow(oldRow)){
+ builder.addNextValue(newRow, correctOldToNewMapping[entry.getColumn()], entry.getValue());
+ }
+ ++newRow;
+ }
+ }
+
+ return builder.build();
+ }
+
+ static std::vector<ValueType> transformActionValueVector(std::vector<ValueType>const& originalVector, std::vector<uint_fast64_t> const& originalRowGroupIndices, StateDuplicatorReturnType const& result) {
+ uint_fast64_t numActions = 0;
+ for(auto const& oldState : result.newToOldStateIndexMapping){
+ numActions += originalRowGroupIndices[oldState+1] - originalRowGroupIndices[oldState];
+ }
+ std::vector<ValueType> v;
+ v.reserve(numActions);
+ for(auto const& oldState : result.newToOldStateIndexMapping){
+ for (uint_fast64_t oldAction = originalRowGroupIndices()[oldState]; oldAction < originaRowGroupIndices()[oldState+1]; ++oldAction){
+ v.push_back(originalVector[oldAction]);
+ }
+ }
+ STORM_LOG_ASSERT(v.size() == numActions, "Unexpected vector size.");
+ return v;
+ }
+
+ static std::vector<ValueType> transformStateValueVector(std::vector<ValueType> const& originalVector, StateDuplicatorReturnType const& result) {
+ uint_fast64_t numStates = result.newToOldStateIndexMapping.size();
+ std::vector<ValueType> v;
+ result.reserve(numStates);
+ for(auto const& oldState : result.newToOldStateIndexMapping){
+ v.push_back(originalVector[oldState]);
+ }
+ STORM_LOG_ASSERT(result.size() == numStates, "Unexpected vector size.");
+ return v;
+ }
+
+ static storm::storage::BitVector transformStateBitVector(storm::storage::BitVector const& originalBitVector, StateDuplicatorReturnType const& result) {
+ uint_fast64_t numStates = result.newToOldStateIndexMapping.size();
+ storm::storage::BitVector bv(numStates);
+ for(uint_fast64_t newState = 0; newState < numStates; ++newState){
+ uint_fast64_t oldState = result.newToOldStateIndexMapping[newState];
+ bv.set(newState, originalBitVector.get(oldState));
+ }
+ return bv;
+ }
+
+
+
+ };
+ }
+}