Merge branch 'jani_support' of https://sselab.de/lab9/private/git/storm into jani_support

Former-commit-id: f2c3f1665b

src/builder/DdPrismModelBuilder.cpp

@@ -1,5 +1,7 @@
 #include "src/builder/DdPrismModelBuilder.h"
 
+#include <boost/algorithm/string/join.hpp>
+
 #include "src/models/symbolic/Dtmc.h"
 #include "src/models/symbolic/Ctmc.h"
 #include "src/models/symbolic/Mdp.h"
@@ -9,12 +11,13 @@
 #include "src/settings/SettingsManager.h"
 
 #include "src/exceptions/InvalidStateException.h"
-
+#include "src/exceptions/NotSupportedException.h"
 #include "src/exceptions/InvalidArgumentException.h"
 
 #include "src/utility/prism.h"
 #include "src/utility/math.h"
 #include "src/storage/prism/Program.h"
+#include "src/storage/prism/Compositions.h"
 
 #include "src/storage/dd/Add.h"
 #include "src/storage/dd/cudd/CuddAddIterator.h"
@@ -189,6 +192,238 @@ namespace storm {
             }
         };
         
+        template <storm::dd::DdType Type, typename ValueType>
+        class ModuleComposer : public storm::prism::CompositionVisitor {
+        public:
+            ModuleComposer(typename DdPrismModelBuilder<Type, ValueType>::GenerationInformation& generationInfo) : generationInfo(generationInfo) {
+                for (auto const& actionIndex : generationInfo.program.getSynchronizingActionIndices()) {
+                    synchronizingActionToOffsetMap[actionIndex] = 0;
+                }
+            }
+            
+            typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram compose(storm::prism::Composition const& composition) {
+                std::cout << "composing the system " << composition << std::endl;
+                return boost::any_cast<typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram>(composition.accept(*this));
+            }
+            
+            virtual boost::any visit(storm::prism::ModuleComposition const& composition) override {
+                STORM_LOG_TRACE("Translating module '" << composition.getModuleName() << "'.");
+                typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram result = DdPrismModelBuilder<Type, ValueType>::createModuleDecisionDiagram(generationInfo, generationInfo.program.getModule(composition.getModuleName()), synchronizingActionToOffsetMap);
+                
+                // Update the offset indices.
+                for (auto const& actionIndex : generationInfo.program.getSynchronizingActionIndices()) {
+                    if (result.hasSynchronizingAction(actionIndex)) {
+                        synchronizingActionToOffsetMap[actionIndex] = result.synchronizingActionToDecisionDiagramMap[actionIndex].numberOfUsedNondeterminismVariables;
+                    }
+                }
+                
+                return result;
+            }
+            
+            virtual boost::any visit(storm::prism::RenamingComposition const& composition) override {
+                // First, we translate the subcomposition.
+                typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram sub = boost::any_cast<typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram>(composition.getSubcomposition().accept(*this));
+
+                // Create the mapping from action indices to action indices.
+                std::map<uint_fast64_t, uint_fast64_t> renaming;
+                for (auto const& namePair : composition.getActionRenaming()) {
+                    STORM_LOG_THROW(generationInfo.program.hasAction(namePair.first), storm::exceptions::InvalidArgumentException, "Composition refers to unknown action '" << namePair.first << "'.");
+                    STORM_LOG_THROW(generationInfo.program.hasAction(namePair.second), storm::exceptions::InvalidArgumentException, "Composition refers to unknown action '" << namePair.second << "'.");
+                    renaming.emplace(generationInfo.program.getActionIndex(namePair.first), generationInfo.program.getActionIndex(namePair.second));
+                }
+                
+                // Perform the renaming and return result.
+                return rename(sub, renaming);
+            }
+            
+            virtual boost::any visit(storm::prism::HidingComposition const& composition) override {
+                // First, we translate the subcomposition.
+                typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram sub = boost::any_cast<typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram>(composition.getSubcomposition().accept(*this));
+                
+                // Create the mapping from action indices to action indices.
+                std::set<uint_fast64_t> actionIndicesToHide;
+                for (auto const& action : composition.getActionsToHide()) {
+                    STORM_LOG_THROW(generationInfo.program.hasAction(action), storm::exceptions::InvalidArgumentException, "Composition refers to unknown action '" << action << "'.");
+                    actionIndicesToHide.insert(generationInfo.program.getActionIndex(action));
+                }
+                
+                // Perform the hiding and return result.
+                return hide(sub, actionIndicesToHide);
+            }
+            
+            virtual boost::any visit(storm::prism::SynchronizingParallelComposition const& composition) override {
+                // First, we translate the subcompositions.
+                typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram left = boost::any_cast<typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram>(composition.getLeftSubcomposition().accept(*this));
+                typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram right = boost::any_cast<typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram>(composition.getRightSubcomposition().accept(*this));
+                
+                // Then, determine the action indices on which we need to synchronize.
+                std::set<uint_fast64_t> leftSynchronizationActionIndices = left.getSynchronizingActionIndices();
+                std::set<uint_fast64_t> rightSynchronizationActionIndices = right.getSynchronizingActionIndices();
+                std::set<uint_fast64_t> synchronizationActionIndices;
+                std::set_intersection(leftSynchronizationActionIndices.begin(), leftSynchronizationActionIndices.end(), rightSynchronizationActionIndices.begin(), rightSynchronizationActionIndices.end(), std::inserter(synchronizationActionIndices, synchronizationActionIndices.begin()));
+                
+                // Finally, we compose the subcompositions to create the result.
+                composeInParallel(left, right, synchronizationActionIndices);
+                return left;
+            }
+            
+            virtual boost::any visit(storm::prism::InterleavingParallelComposition const& composition) override {
+                // First, we translate the subcompositions.
+                typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram left = boost::any_cast<typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram>(composition.getLeftSubcomposition().accept(*this));
+                typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram right = boost::any_cast<typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram>(composition.getRightSubcomposition().accept(*this));
+
+                // Finally, we compose the subcompositions to create the result.
+                composeInParallel(left, right, std::set<uint_fast64_t>());
+                return left;
+            }
+            
+            virtual boost::any visit(storm::prism::RestrictedParallelComposition const& composition) override {
+                // First, we translate the subcompositions.
+                typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram left = boost::any_cast<typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram>(composition.getLeftSubcomposition().accept(*this));
+                typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram right = boost::any_cast<typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram>(composition.getRightSubcomposition().accept(*this));
+                
+                // Construct the synchronizing action indices from the synchronizing action names.
+                std::set<uint_fast64_t> synchronizingActionIndices;
+                for (auto const& action : composition.getSynchronizingActions()) {
+                    synchronizingActionIndices.insert(generationInfo.program.getActionIndex(action));
+                }
+                
+                std::set<uint_fast64_t> leftSynchronizationActionIndices = left.getSynchronizingActionIndices();
+                bool isContainedInLeft = std::includes(leftSynchronizationActionIndices.begin(), leftSynchronizationActionIndices.end(), synchronizingActionIndices.begin(), synchronizingActionIndices.end());
+                STORM_LOG_WARN_COND(isContainedInLeft, "Left subcomposition of composition '" << composition << "' does not include all actions over which to synchronize.");
+
+                std::set<uint_fast64_t> rightSynchronizationActionIndices = right.getSynchronizingActionIndices();
+                bool isContainedInRight = std::includes(rightSynchronizationActionIndices.begin(), rightSynchronizationActionIndices.end(), synchronizingActionIndices.begin(), synchronizingActionIndices.end());
+                STORM_LOG_WARN_COND(isContainedInRight, "Right subcomposition of composition '" << composition << "' does not include all actions over which to synchronize.");
+                
+                // Finally, we compose the subcompositions to create the result.
+                composeInParallel(left, right, synchronizingActionIndices);
+                return left;
+            }
+
+        private:
+            /*!
+             * Hides the actions of the given module according to the given set. As a result, the module is modified in
+             * place.
+             */
+            void hide(typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram& sub, std::set<uint_fast64_t> const& actionIndicesToHide) const {
+                STORM_LOG_TRACE("Hiding the actions " << boost::join(actionIndicesToHide, ", ") << ".");
+
+                for (auto const& action : sub.synchronizingActionToDecisionDiagramMap) {
+                    if (actionIndicesToHide.find(action) != actionIndicesToHide.end()) {
+                        
+                    }
+                }
+            }
+            
+            /*!
+             * Renames the actions of the given module according to the given renaming.
+             */
+            typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram rename(typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram& sub, std::map<uint_fast64_t, uint_fast64_t> const& renaming) const {
+                STORM_LOG_TRACE("Renaming actions.");
+                uint_fast64_t numberOfUsedNondeterminismVariables = sub.numberOfUsedNondeterminismVariables;
+                std::map<uint_fast64_t, typename DdPrismModelBuilder<Type, ValueType>::ActionDecisionDiagram> actionIndexToDdMap;
+                
+                // Go through all action DDs with a synchronizing label and rename them if they appear in the renaming.
+                for (auto const& action : sub.synchronizingActionToDecisionDiagramMap) {
+                    auto renamingIt = renaming.find(action.first);
+                    if (renamingIt != renaming.end()) {
+                        // If the action is to be renamed and an action with the target index already exists, we need
+                        // to combine the action DDs.
+                        auto itNewActions = actionIndexToDdMap.find(renamingIt.second);
+                        if (itNewActions != actionIndexToDdMap.end()) {
+                            actionIndexToDdMap[renamingIt.second] = DdPrismModelBuilder<Type, ValueType>::combineUnsynchronizedActions(generationInfo, action.second, itNewActions->second);
+                        } else {
+                            // In this case, we can simply copy the action over.
+                            actionIndexToDdMap[renamingIt.second] = action.second;
+                        }
+                    } else {
+                        // If the action is not to be renamed, we need to copy it over. However, if some other action
+                        // was renamed to the very same action name before, we need to combine the transitions.
+                        auto itNewActions = actionIndexToDdMap.find(action.first);
+                        if (itNewActions != actionIndexToDdMap.end()) {
+                            actionIndexToDdMap[action.first] = DdPrismModelBuilder<Type, ValueType>::combineUnsynchronizedActions(generationInfo, action.second, itNewActions->second);
+                        } else {
+                            // In this case, we can simply copy the action over.
+                            actionIndexToDdMap[action.first] = action.second;
+                        }
+                    }
+                }
+                
+                return ModuleDecisionDiagram(sub.independentAction, actionIndexToDdMap, sub.identity, numberOfUsedNondeterminismVariables);
+            }
+            
+            /*!
+             * Composes the given modules while synchronizing over the provided action indices. As a result, the first
+             * module is modified in place and will contain the composition after a call to this method.
+             */
+            void composeInParallel(typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram& left, typename DdPrismModelBuilder<Type, ValueType>::ModuleDecisionDiagram& right, std::set<uint_fast64_t> const& synchronizationActionIndices) const {
+                STORM_LOG_TRACE("Composing two modules over the actions " << boost::join(synchronizationActionIndices, ", ") << ".");
+                
+                // Combine the tau action.
+                uint_fast64_t numberOfUsedNondeterminismVariables = right.independentAction.numberOfUsedNondeterminismVariables;
+                left.independentAction = DdPrismModelBuilder<Type, ValueType>::combineUnsynchronizedActions(generationInfo, left.independentAction, right.independentAction, left.identity, right.identity);
+                numberOfUsedNondeterminismVariables = std::max(numberOfUsedNondeterminismVariables, left.independentAction.numberOfUsedNondeterminismVariables);
+
+                // Create an empty action for the case where one of the modules does not have a certain action.
+                typename DdPrismModelBuilder<Type, ValueType>::ActionDecisionDiagram emptyAction(*generationInfo.manager);
+
+                // Treat all non-tau actions of the left module.
+                for (auto& action : left.synchronizingActionToDecisionDiagramMap) {
+                    // If we need to synchronize over this action index, we try to do so now.
+                    if (synchronizationActionIndices.find(action.first) != synchronizationActionIndices.end()) {
+                        // If we are to synchronize over an action that does not exist in the second module, the result
+                        // is that the synchronization is the empty action.
+                        if (!right.hasSynchronizingAction(action.first)) {
+                            action.second = emptyAction;
+                        } else {
+                            // Otherwise, the actions of the modules are synchronized.
+                            action.second = DdPrismModelBuilder<Type, ValueType>::combineSynchronizingActions(generationInfo, action.second, right.synchronizingActionToDecisionDiagramMap[action.first]);
+                        }
+                    } else {
+                        // If we don't synchronize over this action, we need to construct the interleaving.
+                        
+                        // If both modules contain the action, we need to mutually multiply the other identity.
+                        if (right.hasSynchronizingAction(action.first)) {
+                            action.second = DdPrismModelBuilder<Type, ValueType>::combineUnsynchronizedActions(generationInfo, action.second, right.synchronizingActionToDecisionDiagramMap[action.first], left.identity, right.identity);
+                        } else {
+                            // If only the first module has this action, we need to use a dummy action decision diagram
+                            // for the second module.
+                            action.second = DdPrismModelBuilder<Type, ValueType>::combineUnsynchronizedActions(generationInfo, action.second, emptyAction, left.identity, right.identity);
+                        }
+                    }
+                    numberOfUsedNondeterminismVariables = std::max(numberOfUsedNondeterminismVariables, action.second.numberOfUsedNondeterminismVariables);
+                }
+                
+                // Treat all non-tau actions of the right module.
+                for (auto const& actionIndex : right.getSynchronizingActionIndices()) {
+                    // Here, we only need to treat actions that the first module does not have, because we have handled
+                    // this case earlier.
+                    if (!left.hasSynchronizingAction(actionIndex)) {
+                        if (synchronizationActionIndices.find(actionIndex) != synchronizationActionIndices.end()) {
+                            // If we are to synchronize over this action that does not exist in the first module, the
+                            // result is that the synchronization is the empty action.
+                            left.synchronizingActionToDecisionDiagramMap[actionIndex] = emptyAction;
+                        } else {
+                            // If only the second module has this action, we need to use a dummy action decision diagram
+                            // for the first module.
+                            left.synchronizingActionToDecisionDiagramMap[actionIndex] = DdPrismModelBuilder<Type, ValueType>::combineUnsynchronizedActions(generationInfo, emptyAction, right.synchronizingActionToDecisionDiagramMap[actionIndex], left.identity, right.identity);
+                        }
+                    }
+                    numberOfUsedNondeterminismVariables = std::max(numberOfUsedNondeterminismVariables, left.synchronizingActionToDecisionDiagramMap[actionIndex].numberOfUsedNondeterminismVariables);
+                }
+                
+                // Combine identity matrices.
+                left.identity = left.identity * right.identity;
+                
+                // Keep track of the number of nondeterminism variables used.
+                left.numberOfUsedNondeterminismVariables = std::max(left.numberOfUsedNondeterminismVariables, numberOfUsedNondeterminismVariables);
+            }
+            
+            typename DdPrismModelBuilder<Type, ValueType>::GenerationInformation& generationInfo;
+            std::map<uint_fast64_t, uint_fast64_t> synchronizingActionToOffsetMap;
+        };
+        
         template <storm::dd::DdType Type, typename ValueType>
         DdPrismModelBuilder<Type, ValueType>::Options::Options() : buildAllRewardModels(true), rewardModelsToBuild(), constantDefinitions(), buildAllLabels(true), labelsToBuild(), terminalStates(), negatedTerminalStates() {
             // Intentionally left empty.
@@ -636,21 +871,30 @@ namespace storm {
         
         template <storm::dd::DdType Type, typename ValueType>
         typename DdPrismModelBuilder<Type, ValueType>::ActionDecisionDiagram DdPrismModelBuilder<Type, ValueType>::combineUnsynchronizedActions(GenerationInformation const& generationInfo, ActionDecisionDiagram& action1, ActionDecisionDiagram& action2, storm::dd::Add<Type, ValueType> const& identityDd1, storm::dd::Add<Type, ValueType> const& identityDd2) {
-            storm::dd::Add<Type, ValueType> action1Extended = action1.transitionsDd * identityDd2;
-            storm::dd::Add<Type, ValueType> action2Extended = action2.transitionsDd * identityDd1;
             
+            // First extend the action DDs by the other identities.
+            STORM_LOG_TRACE("Multiplying identities to combine unsynchronized actions.");
+            action1.transitionsDd = action1.transitionsDd * identityDd2;
+            action2.transitionsDd = action2.transitionsDd * identityDd1;
+            
+            // Then combine the extended action DDs.
+            return combineUnsynchronizedActions(generationInfo, action1, action2);
+        }
+        
+        template <storm::dd::DdType Type, typename ValueType>
+        typename DdPrismModelBuilder<Type, ValueType>::ActionDecisionDiagram DdPrismModelBuilder<Type, ValueType>::combineUnsynchronizedActions(GenerationInformation const& generationInfo, ActionDecisionDiagram& action1, ActionDecisionDiagram& action2) {
             STORM_LOG_TRACE("Combining unsynchronized actions.");
             
             // Make both action DDs write to the same global variables.
             std::set<storm::expressions::Variable> assignedGlobalVariables = equalizeAssignedGlobalVariables(generationInfo, action1, action2);
             
             if (generationInfo.program.getModelType() == storm::prism::Program::ModelType::DTMC || generationInfo.program.getModelType() == storm::prism::Program::ModelType::CTMC) {
-                return ActionDecisionDiagram(action1.guardDd + action2.guardDd, action1Extended + action2Extended, assignedGlobalVariables, 0);
+                return ActionDecisionDiagram(action1.guardDd + action2.guardDd, action1.transitionsDd + action2.transitionsDd, assignedGlobalVariables, 0);
             } else if (generationInfo.program.getModelType() == storm::prism::Program::ModelType::MDP) {
                 if (action1.transitionsDd.isZero()) {
-                    return ActionDecisionDiagram(action2.guardDd, action2Extended, assignedGlobalVariables, action2.numberOfUsedNondeterminismVariables);
+                    return ActionDecisionDiagram(action2.guardDd, action2.transitionsDd, assignedGlobalVariables, action2.numberOfUsedNondeterminismVariables);
                 } else if (action2.transitionsDd.isZero()) {
-                    return ActionDecisionDiagram(action1.guardDd, action1Extended, assignedGlobalVariables, action1.numberOfUsedNondeterminismVariables);
+                    return ActionDecisionDiagram(action1.guardDd, action1.transitionsDd, assignedGlobalVariables, action1.numberOfUsedNondeterminismVariables);
                 }
                 
                 // Bring both choices to the same number of variables that encode the nondeterminism.
@@ -661,18 +905,18 @@ namespace storm {
                     for (uint_fast64_t i = action2.numberOfUsedNondeterminismVariables; i < action1.numberOfUsedNondeterminismVariables; ++i) {
                         nondeterminismEncoding *= generationInfo.manager->getEncoding(generationInfo.nondeterminismMetaVariables[i], 0).template toAdd<ValueType>();
                     }
-                    action2Extended *= nondeterminismEncoding;
+                    action2.transitionsDd *= nondeterminismEncoding;
                 } else if (action2.numberOfUsedNondeterminismVariables > action1.numberOfUsedNondeterminismVariables) {
                     storm::dd::Add<Type, ValueType> nondeterminismEncoding = generationInfo.manager->template getAddOne<ValueType>();
                     
                     for (uint_fast64_t i = action1.numberOfUsedNondeterminismVariables; i < action2.numberOfUsedNondeterminismVariables; ++i) {
                         nondeterminismEncoding *= generationInfo.manager->getEncoding(generationInfo.nondeterminismMetaVariables[i], 0).template toAdd<ValueType>();
                     }
-                    action1Extended *= nondeterminismEncoding;
+                    action1.transitionsDd *= nondeterminismEncoding;
                 }
                 
                 // Add a new variable that resolves the nondeterminism between the two choices.
-                storm::dd::Add<Type, ValueType> combinedTransitions = generationInfo.manager->getEncoding(generationInfo.nondeterminismMetaVariables[numberOfUsedNondeterminismVariables], 1).ite(action2Extended, action1Extended);
+                storm::dd::Add<Type, ValueType> combinedTransitions = generationInfo.manager->getEncoding(generationInfo.nondeterminismMetaVariables[numberOfUsedNondeterminismVariables], 1).ite(action2.transitionsDd, action1.transitionsDd);
                 
                 return ActionDecisionDiagram((action1.guardDd.toBdd() || action2.guardDd.toBdd()).template toAdd<ValueType>(), combinedTransitions, assignedGlobalVariables, numberOfUsedNondeterminismVariables + 1);
             } else {
@@ -789,61 +1033,8 @@ namespace storm {
         
         template <storm::dd::DdType Type, typename ValueType>
         typename DdPrismModelBuilder<Type, ValueType>::SystemResult DdPrismModelBuilder<Type, ValueType>::createSystemDecisionDiagram(GenerationInformation& generationInfo) {
-            // Create the initial offset mapping.
-            std::map<uint_fast64_t, uint_fast64_t> synchronizingActionToOffsetMap;
-            for (auto const& actionIndex : generationInfo.program.getSynchronizingActionIndices()) {
-                synchronizingActionToOffsetMap[actionIndex] = 0;
-            }
-
-            // Start by creating DDs for the first module.
-            STORM_LOG_TRACE("Translating (first) module '" << generationInfo.program.getModule(0).getName() << "'.");
-            ModuleDecisionDiagram system = createModuleDecisionDiagram(generationInfo, generationInfo.program.getModule(0), synchronizingActionToOffsetMap);
-
-            // Now translate module by module and combine it with the system created thus far.
-            for (uint_fast64_t i = 1; i < generationInfo.program.getNumberOfModules(); ++i) {
-                storm::prism::Module const& currentModule = generationInfo.program.getModule(i);
-                STORM_LOG_TRACE("Translating module '" << currentModule.getName() << "'.");
-                
-                // Update the offset index.
-                for (auto const& actionIndex : generationInfo.program.getSynchronizingActionIndices()) {
-                    if (system.hasSynchronizingAction(actionIndex)) {
-                        synchronizingActionToOffsetMap[actionIndex] = system.synchronizingActionToDecisionDiagramMap[actionIndex].numberOfUsedNondeterminismVariables;
-                    }
-                }
-                
-                ModuleDecisionDiagram currentModuleDd = createModuleDecisionDiagram(generationInfo, currentModule, synchronizingActionToOffsetMap);
-                
-                // Combine the non-synchronizing action.
-                uint_fast64_t numberOfUsedNondeterminismVariables = currentModuleDd.numberOfUsedNondeterminismVariables;
-                system.independentAction = combineUnsynchronizedActions(generationInfo, system.independentAction, currentModuleDd.independentAction, system.identity, currentModuleDd.identity);
-                numberOfUsedNondeterminismVariables = std::max(numberOfUsedNondeterminismVariables, system.independentAction.numberOfUsedNondeterminismVariables);
-                
-                ActionDecisionDiagram emptyAction(*generationInfo.manager);
-                
-                // For all synchronizing actions that the next module does not have, we need to multiply the identity of the next module.
-                for (auto& action : system.synchronizingActionToDecisionDiagramMap) {
-                    if (!currentModuleDd.hasSynchronizingAction(action.first)) {
-                        action.second = combineUnsynchronizedActions(generationInfo, action.second, emptyAction, system.identity, currentModuleDd.identity);
-                    }
-                }
-                
-                // Combine synchronizing actions.
-                for (auto const& actionIndex : currentModule.getSynchronizingActionIndices()) {
-                    if (system.hasSynchronizingAction(actionIndex)) {
-                        system.synchronizingActionToDecisionDiagramMap[actionIndex] = combineSynchronizingActions(generationInfo, system.synchronizingActionToDecisionDiagramMap[actionIndex], currentModuleDd.synchronizingActionToDecisionDiagramMap[actionIndex]);
-                        numberOfUsedNondeterminismVariables = std::max(numberOfUsedNondeterminismVariables, system.synchronizingActionToDecisionDiagramMap[actionIndex].numberOfUsedNondeterminismVariables);
-                    } else {
-                        system.synchronizingActionToDecisionDiagramMap[actionIndex] = combineUnsynchronizedActions(generationInfo, emptyAction, currentModuleDd.synchronizingActionToDecisionDiagramMap[actionIndex], system.identity, currentModuleDd.identity);
-                        numberOfUsedNondeterminismVariables = std::max(numberOfUsedNondeterminismVariables, system.synchronizingActionToDecisionDiagramMap[actionIndex].numberOfUsedNondeterminismVariables);
-                    }
-                }
-                
-                // Combine identity matrices.
-                system.identity = system.identity * currentModuleDd.identity;
-                
-                // Keep track of the number of nondeterminism variables used.
-                system.numberOfUsedNondeterminismVariables = std::max(system.numberOfUsedNondeterminismVariables, numberOfUsedNondeterminismVariables);
-            }
+            ModuleComposer<Type, ValueType> composer(generationInfo);
+            ModuleDecisionDiagram system = composer.compose(generationInfo.program.specifiesSystemComposition() ? generationInfo.program.getSystemCompositionConstruct().getSystemComposition() : *generationInfo.program.getDefaultSystemComposition());
             
             storm::dd::Add<Type, ValueType> result = createSystemFromModule(generationInfo, system);
             

src/builder/DdPrismModelBuilder.h

@@ -188,6 +188,14 @@ namespace storm {
                     return synchronizingActionToDecisionDiagramMap.find(actionIndex) != synchronizingActionToDecisionDiagramMap.end();
                 }
                 
+                std::set<uint_fast64_t> getSynchronizingActionIndices() const {
+                    std::set<uint_fast64_t> result;
+                    for (auto const& entry : synchronizingActionToDecisionDiagramMap) {
+                        result.insert(entry.first);
+                    }
+                    return result;
+                }
+                
                 // The decision diagram for the independent action.
                 ActionDecisionDiagram independentAction;
                 
@@ -210,7 +218,11 @@ namespace storm {
              * Structure to store the result of the system creation phase.
              */
             struct SystemResult;
+            
         private:
+            template <storm::dd::DdType TypePrime, typename ValueTypePrime>
+            friend class ModuleComposer;
+            
             static std::set<storm::expressions::Variable> equalizeAssignedGlobalVariables(GenerationInformation const& generationInfo, ActionDecisionDiagram& action1, ActionDecisionDiagram& action2);
             
             static std::set<storm::expressions::Variable> equalizeAssignedGlobalVariables(GenerationInformation const& generationInfo, std::vector<ActionDecisionDiagram>& actionDds);
@@ -231,6 +243,8 @@ namespace storm {
 
             static ActionDecisionDiagram combineUnsynchronizedActions(GenerationInformation const& generationInfo, ActionDecisionDiagram& action1, ActionDecisionDiagram& action2, storm::dd::Add<Type, ValueType> const& identityDd1, storm::dd::Add<Type, ValueType> const& identityDd2);
             
+            static ActionDecisionDiagram combineUnsynchronizedActions(GenerationInformation const& generationInfo, ActionDecisionDiagram& action1, ActionDecisionDiagram& action2);
+
             static ModuleDecisionDiagram createModuleDecisionDiagram(GenerationInformation& generationInfo, storm::prism::Module const& module, std::map<uint_fast64_t, uint_fast64_t> const& synchronizingActionToOffsetMap);
 
             static storm::dd::Add<Type, ValueType> getSynchronizationDecisionDiagram(GenerationInformation& generationInfo, uint_fast64_t actionIndex = 0);

src/storage/prism/HidingComposition.cpp

@@ -17,6 +17,10 @@ namespace storm {
             return *sub;
         }
         
+        std::set<std::string> const& HidingComposition::getActionsToHide() const {
+            return actionsToHide;
+        }
+        
         void HidingComposition::writeToStream(std::ostream& stream) const {
             stream << "(" << *sub << ")" << " " << "{" << boost::join(actionsToHide, ", ") << "}";
         }

src/storage/prism/HidingComposition.h

@@ -16,6 +16,8 @@ namespace storm {
             
             Composition const& getSubcomposition() const;
             
+            std::set<std::string> const& getActionsToHide() const;
+            
         protected:
             virtual void writeToStream(std::ostream& stream) const override;
             

src/storage/prism/InterleavingParallelComposition.cpp

@@ -12,7 +12,7 @@ namespace storm {
         }
         
         void InterleavingParallelComposition::writeToStream(std::ostream& stream) const {
-            stream << "(" << *left << " ||| " << *right << ")";
+            stream << "(" << this->getLeftSubcomposition() << " ||| " << this->getRightSubcomposition() << ")";
         }
         
     }

src/storage/prism/InterleavingParallelComposition.h

@@ -13,10 +13,6 @@ namespace storm {
 
         protected:
             virtual void writeToStream(std::ostream& stream) const override;
-            
-        private:
-            std::shared_ptr<Composition> left;
-            std::shared_ptr<Composition> right;
         };
     }
 }

src/storage/prism/Program.cpp

@@ -27,11 +27,21 @@ namespace storm {
             }
             
             bool isValid(Composition const& composition) {
-                return boost::any_cast<bool>(composition.accept(*this));
+                bool isValid = boost::any_cast<bool>(composition.accept(*this));
+                if (appearingModules.size() != program.getNumberOfModules()) {
+                    isValid = false;
+                    STORM_LOG_THROW(isValid, storm::exceptions::WrongFormatException, "Not every module is used in the system composition.");
+                }
+                return isValid;
             }
             
             virtual boost::any visit(ModuleComposition const& composition) override {
-                return program.hasModule(composition.getModuleName());
+                bool isValid = program.hasModule(composition.getModuleName());
+                STORM_LOG_THROW(isValid, storm::exceptions::WrongFormatException, "The module \"" << composition.getModuleName() << "\" referred to in the system composition does not exist.");
+                isValid = appearingModules.find(composition.getModuleName()) == appearingModules.end();
+                STORM_LOG_THROW(isValid, storm::exceptions::WrongFormatException, "The module \"" << composition.getModuleName() << "\" is referred to more than once in the system composition.");
+                appearingModules.insert(composition.getModuleName());
+                return isValid;
             }
             
             virtual boost::any visit(RenamingComposition const& composition) override {
@@ -51,11 +61,20 @@ namespace storm {
             }
             
             virtual boost::any visit(RestrictedParallelComposition const& composition) override {
-                return boost::any_cast<bool>(composition.getLeftSubcomposition().accept(*this)) && boost::any_cast<bool>(composition.getRightSubcomposition().accept(*this));
+                bool isValid = boost::any_cast<bool>(composition.getLeftSubcomposition().accept(*this)) && boost::any_cast<bool>(composition.getRightSubcomposition().accept(*this));
+                
+                for (auto const& action : composition.getSynchronizingActions()) {
+                    if (!program.hasAction(action)) {
+                        STORM_LOG_THROW(false, storm::exceptions::WrongFormatException, "System composition refers to unknown action '" << action << "'.");
+                    }
+                }
+                
+                return isValid;
             }
             
         private:
             storm::prism::Program const& program;
+            std::set<std::string> appearingModules;
         };
         
         Program::Program(std::shared_ptr<storm::expressions::ExpressionManager> manager, ModelType modelType, std::vector<Constant> const& constants, std::vector<BooleanVariable> const& globalBooleanVariables, std::vector<IntegerVariable> const& globalIntegerVariables, std::vector<Formula> const& formulas, std::vector<Module> const& modules, std::map<std::string, uint_fast64_t> const& actionToIndexMap, std::vector<RewardModel> const& rewardModels, std::vector<Label> const& labels, boost::optional<InitialConstruct> const& initialConstruct, boost::optional<SystemCompositionConstruct> const& compositionConstruct, std::string const& filename, uint_fast64_t lineNumber, bool finalModel)
@@ -352,6 +371,18 @@ namespace storm {
             return systemCompositionConstruct;
         }
         
+        std::shared_ptr<Composition> Program::getDefaultSystemComposition() const {
+            std::shared_ptr<Composition> current = std::make_shared<ModuleComposition>(this->modules.front().getName());
+            
+            for (uint_fast64_t index = 1; index < this->modules.size(); ++index) {
+                std::shared_ptr<Composition> newComposition = std::make_shared<SynchronizingParallelComposition>(current, std::make_shared<ModuleComposition>(this->modules[index].getName()));
+                current = newComposition;
+            }
+            
+            
+            return current;
+        }
+        
         std::set<std::string> const& Program::getActions() const {
             return this->actions;
         }
@@ -366,6 +397,20 @@ namespace storm {
             return indexNamePair->second;
         }
         
+        uint_fast64_t Program::getActionIndex(std::string const& actionName) const {
+            auto const& nameIndexPair = this->actionToIndexMap.find(actionName);
+            STORM_LOG_THROW(nameIndexPair != this->actionToIndexMap.end(), storm::exceptions::InvalidArgumentException, "Unknown action name '" << actionName << "'.");
+            return nameIndexPair->second;
+        }
+        
+        bool Program::hasAction(std::string const& actionName) const {
+            return this->actionToIndexMap.find(actionName) != this->actionToIndexMap.end();
+        }
+        
+        bool Program::hasAction(uint_fast64_t const& actionIndex) const {
+            return this->indexToActionMap.find(actionIndex) != this->indexToActionMap.end();
+        }
+        
         std::set<uint_fast64_t> const& Program::getModuleIndicesByAction(std::string const& action) const {
             auto const& nameIndexPair = this->actionToIndexMap.find(action);
             STORM_LOG_THROW(nameIndexPair != this->actionToIndexMap.end(), storm::exceptions::OutOfRangeException, "Action name '" << action << "' does not exist.");

src/storage/prism/Program.h

@@ -296,6 +296,13 @@ namespace storm {
              */
             boost::optional<SystemCompositionConstruct> getOptionalSystemCompositionConstruct() const;
             
+            /*!
+             * Retrieves the default system composition for this program.
+             *
+             * @return The default system composition.
+             */
+            std::shared_ptr<Composition> getDefaultSystemComposition() const;
+            
             /*!
              * Retrieves the set of actions present in the program.
              *
@@ -318,6 +325,28 @@ namespace storm {
              */
             std::string const& getActionName(uint_fast64_t actionIndex) const;
             
+            /*!
+             * Retrieves the index of the action with the given name.
+             *
+             * @param actionName The name of the action.
+             * @return The index of the action.
+             */
+            uint_fast64_t getActionIndex(std::string const& actionName) const;
+            
+            /*!
+             * Retrieves whether the program has an action with the given name.
+             *
+             * @return True iff the program has an action with the given name.
+             */
+            bool hasAction(std::string const& actionName) const;
+
+            /*!
+             * Retrieves whether the program has an action with the given index.
+             *
+             * @return True iff the program has an action with the given index.
+             */
+            bool hasAction(uint_fast64_t const& actionIndex) const;
+            
             /*!
              * Retrieves the indices of all modules within this program that contain commands that are labelled with the
              * given action.

src/storage/prism/RenamingComposition.cpp

@@ -19,6 +19,10 @@ namespace storm {
             return *sub;
         }
         
+        std::map<std::string, std::string> const& RenamingComposition::getActionRenaming() const {
+            return actionRenaming;
+        }
+        
         void RenamingComposition::writeToStream(std::ostream& stream) const {
             std::vector<std::string> renamings;
             for (auto const& renaming : actionRenaming) {

src/storage/prism/RenamingComposition.h

@@ -17,6 +17,8 @@ namespace storm {
             
             Composition const& getSubcomposition() const;
             
+            std::map<std::string, std::string> const& getActionRenaming() const;
+            
         protected:
             virtual void writeToStream(std::ostream& stream) const override;
             

src/storage/prism/RestrictedParallelComposition.cpp

@@ -13,8 +13,12 @@ namespace storm {
             return visitor.visit(*this);
         }
 
+        std::set<std::string> const& RestrictedParallelComposition::getSynchronizingActions() const {
+            return synchronizingActions;
+        }
+        
         void RestrictedParallelComposition::writeToStream(std::ostream& stream) const {
-            stream << "(" << *left << " |[" << boost::algorithm::join(synchronizingActions, ", ") << "]| " << *right << ")";
+            stream << "(" << this->getLeftSubcomposition() << " |[" << boost::algorithm::join(synchronizingActions, ", ") << "]| " << this->getRightSubcomposition() << ")";
         }
 
     }

src/storage/prism/RestrictedParallelComposition.h

@@ -14,13 +14,13 @@ namespace storm {
             
             virtual boost::any accept(CompositionVisitor& visitor) const override;
 
+            std::set<std::string> const& getSynchronizingActions() const;
+            
         protected:
             virtual void writeToStream(std::ostream& stream) const override;
             
         private:
-            std::shared_ptr<Composition> left;
             std::set<std::string> synchronizingActions;
-            std::shared_ptr<Composition> right;
         };
     }
 }

src/storage/prism/SynchronizingParallelComposition.cpp

@@ -12,7 +12,7 @@ namespace storm {
         }
         
         void SynchronizingParallelComposition::writeToStream(std::ostream& stream) const {
-            stream << "(" << *left << " || " << *right << ")";
+            stream << "(" << this->getLeftSubcomposition() << " || " << this->getRightSubcomposition() << ")";
         }
         
     }

src/storage/prism/SynchronizingParallelComposition.h

@@ -13,10 +13,6 @@ namespace storm {
             
         protected:
             virtual void writeToStream(std::ostream& stream) const override;
-            
-        private:
-            std::shared_ptr<Composition> left;
-            std::shared_ptr<Composition> right;
         };
     }
 }