extended model checker hint functionality to bypass the maybestates computations

src/storm/modelchecker/CheckTask.h

@@ -218,11 +218,8 @@ namespace storm {
             /*!
              * sets a hint that might contain information that speeds up the modelchecking process (if supported by the model checker)
              */
-            void setHint(ModelCheckerHint const& hint) {
-                this->hint = std::make_shared<ModelCheckerHint>(hint);
-            }
-            void setHint(ModelCheckerHint&& hint){
-                this->hint = std::make_shared<ModelCheckerHint>(hint);
+            void setHint(std::shared_ptr<ModelCheckerHint> const& hint) {
+                this->hint = hint;
             }
             
             /*!

src/storm/modelchecker/hints/ExplicitModelCheckerHint.cpp

@@ -1,21 +1,15 @@
 #include "storm/modelchecker/hints/ExplicitModelCheckerHint.h"
 #include "storm/adapters/CarlAdapter.h"
-namespace storm {
-    namespace modelchecker {
+#include "storm/utility/macros.h"
 
-        template<typename ValueType>
-        ExplicitModelCheckerHint<ValueType>::ExplicitModelCheckerHint(boost::optional<std::vector<ValueType>> const& resultHint, boost::optional<storm::storage::TotalScheduler> const& schedulerHint) : resultHint(resultHint), schedulerHint(schedulerHint), forceApplicationOfHints(false) {
-            // Intentionally left empty
-        }
+#include "storm/exceptions/InvalidOperationException.h"
 
-        template<typename ValueType>
-        ExplicitModelCheckerHint<ValueType>::ExplicitModelCheckerHint(boost::optional<std::vector<ValueType>>&& resultHint, boost::optional<storm::storage::TotalScheduler>&& schedulerHint) : resultHint(resultHint), schedulerHint(schedulerHint), forceApplicationOfHints(false) {
-            // Intentionally left empty
-        }
+namespace storm {
+    namespace modelchecker {
            
         template<typename ValueType>
         bool ExplicitModelCheckerHint<ValueType>::isEmpty() const {
-            return !resultHint.is_initialized() && !schedulerHint.is_initialized();
+            return !hasResultHint() && !hasSchedulerHint() && !hasMaybeStates();
         }
         
         template<typename ValueType>
@@ -48,6 +42,43 @@ namespace storm {
             this->resultHint = resultHint;
         }
         
+        template<typename ValueType>
+        bool ExplicitModelCheckerHint<ValueType>::getComputeOnlyMaybeStates() const {
+            STORM_LOG_THROW(!computeOnlyMaybeStates || (hasMaybeStates() && hasResultHint()), storm::exceptions::InvalidOperationException, "Computing only maybestates is activated but no maybestates or no result hint is specified.");
+            return computeOnlyMaybeStates;
+        }
+        
+        template<typename ValueType>
+        void ExplicitModelCheckerHint<ValueType>::setComputeOnlyMaybeStates(bool value) {
+            STORM_LOG_THROW(!value || (hasMaybeStates() && hasResultHint()), storm::exceptions::InvalidOperationException, "Tried to activate that only maybestates need to be computed, but no maybestates or no result hint was given before.");
+            this->computeOnlyMaybeStates = value;
+        }
+        
+        template<typename ValueType>
+        bool ExplicitModelCheckerHint<ValueType>::hasMaybeStates() const {
+            return maybeStates.is_initialized();
+        }
+        
+        template<typename ValueType>
+        storm::storage::BitVector const& ExplicitModelCheckerHint<ValueType>::getMaybeStates() const {
+            return maybeStates.get();
+        }
+        
+        template<typename ValueType>
+        storm::storage::BitVector& ExplicitModelCheckerHint<ValueType>::getMaybeStates() {
+            return maybeStates.get();
+        }
+        
+        template<typename ValueType>
+        void ExplicitModelCheckerHint<ValueType>::setMaybeStates(storm::storage::BitVector const& newMaybeStates) {
+            this->maybeStates = newMaybeStates;
+        }
+        
+        template<typename ValueType>
+        void ExplicitModelCheckerHint<ValueType>::setMaybeStates(storm::storage::BitVector&& newMaybeStates) {
+            this->maybeStates = std::move(newMaybeStates);
+        }
+        
         template<typename ValueType>
         bool ExplicitModelCheckerHint<ValueType>::hasSchedulerHint() const {
             return schedulerHint.is_initialized();
@@ -74,13 +105,13 @@ namespace storm {
         }
     
         template<typename ValueType>
-        bool ExplicitModelCheckerHint<ValueType>::getForceApplicationOfHints() const {
-            return forceApplicationOfHints;
+        bool ExplicitModelCheckerHint<ValueType>::getNoEndComponentsInMaybeStates() const {
+            return noEndComponentsInMaybeStates;
         }
     
         template<typename ValueType>
-        void ExplicitModelCheckerHint<ValueType>::setForceApplicationOfHints(bool value) {
-            forceApplicationOfHints = value;
+        void ExplicitModelCheckerHint<ValueType>::setNoEndComponentsInMaybeStates(bool value) {
+            noEndComponentsInMaybeStates = value;
         }
     
         template class ExplicitModelCheckerHint<double>;

src/storm/modelchecker/hints/ExplicitModelCheckerHint.h

@@ -18,10 +18,9 @@ namespace storm {
         class ExplicitModelCheckerHint : public ModelCheckerHint {
         public:
             
+            ExplicitModelCheckerHint() = default;
             ExplicitModelCheckerHint(ExplicitModelCheckerHint<ValueType> const& other) = default;
             ExplicitModelCheckerHint(ExplicitModelCheckerHint<ValueType>&& other) = default;
-            ExplicitModelCheckerHint(boost::optional<std::vector<ValueType>> const& resultHint = boost::none, boost::optional<storm::storage::TotalScheduler> const& schedulerHint = boost::none);
-            ExplicitModelCheckerHint(boost::optional<std::vector<ValueType>>&& resultHint, boost::optional<storm::storage::TotalScheduler>&& schedulerHint = boost::none);
             
             // Returns true iff this hint does not contain any information
             virtual bool isEmpty() const override;
@@ -35,22 +34,35 @@ namespace storm {
             void setResultHint(boost::optional<std::vector<ValueType>> const& resultHint);
             void setResultHint(boost::optional<std::vector<ValueType>>&& resultHint);
     
+            // Set whether only the maybestates need to be computed, i.e., skips the qualitative check.
+            // The result for non-maybe states is taken from the result hint.
+            // Hence, this option may only be enabled iff a resultHint and a set of maybestates are given.
+            bool getComputeOnlyMaybeStates() const;
+            void setComputeOnlyMaybeStates(bool value);
+            bool hasMaybeStates() const;
+            storm::storage::BitVector const& getMaybeStates() const;
+            storm::storage::BitVector& getMaybeStates();
+            void setMaybeStates(storm::storage::BitVector const& maybeStates);
+            void setMaybeStates(storm::storage::BitVector&& maybeStates);
+            
             bool hasSchedulerHint() const;
             storm::storage::TotalScheduler const& getSchedulerHint() const;
             storm::storage::TotalScheduler& getSchedulerHint();
             void setSchedulerHint(boost::optional<storage::TotalScheduler> const& schedulerHint);
             void setSchedulerHint(boost::optional<storage::TotalScheduler>&& schedulerHint);
             
-            // If set, this option forces the application of the specified hints. This means that the model checker may skip some checks to increase performance.
-            // This might yield wrong results on certain models, e.g., when computing maximal probabilities on an MDP that has an end component consisting only of maybestates.
-            bool getForceApplicationOfHints() const;
-            void setForceApplicationOfHints(bool value);
+            // If set, it is assumed that there are no end components that consist only of maybestates.
+            // May only be enabled iff maybestates are given.
+            bool getNoEndComponentsInMaybeStates() const;
+            void setNoEndComponentsInMaybeStates(bool value);
             
         private:
             boost::optional<std::vector<ValueType>> resultHint;
             boost::optional<storm::storage::TotalScheduler> schedulerHint;
             
-            bool forceApplicationOfHints;
+            bool computeOnlyMaybeStates;
+            boost::optional<storm::storage::BitVector> maybeStates;
+            bool noEndComponentsInMaybeStates;
         };
         
     }

src/storm/modelchecker/parametric/SparseDtmcInstantiationModelChecker.cpp

@@ -2,6 +2,7 @@
 
 #include "storm/logic/FragmentSpecification.h"
 #include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h"
+#include "storm/modelchecker/results/ExplicitQualitativeCheckResult.h"
 #include "storm/modelchecker/hints/ExplicitModelCheckerHint.h"
 
 #include "storm/exceptions/InvalidArgumentException.h"
@@ -23,37 +24,140 @@ namespace storm {
                 storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ConstantType>> modelChecker(instantiatedModel);
 
                 // Check if there are some optimizations implemented for the specified property
-                if(!this->currentCheckTask->isQualitativeSet() && this->currentCheckTask->getFormula().isInFragment(storm::logic::reachability().setRewardOperatorsAllowed(true).setReachabilityRewardFormulasAllowed(true))) {
-                    return checkWithHint(modelChecker);
+                if(this->currentCheckTask->getFormula().isInFragment(storm::logic::reachability())) {
+                    return checkReachabilityProbabilityFormula(modelChecker);
+                } else if (this->currentCheckTask->getFormula().isInFragment(storm::logic::propositional().setRewardOperatorsAllowed(true).setReachabilityRewardFormulasAllowed(true).setOperatorAtTopLevelRequired(true).setNestedOperatorsAllowed(false))) {
+                    return checkReachabilityRewardFormula(modelChecker);
+                } else if (this->currentCheckTask->getFormula().isInFragment(storm::logic::propositional().setProbabilityOperatorsAllowed(true).setBoundedUntilFormulasAllowed(true).setStepBoundedUntilFormulasAllowed(true).setTimeBoundedUntilFormulasAllowed(true).setOperatorAtTopLevelRequired(true).setNestedOperatorsAllowed(false))) {
+                    return checkBoundedUntilFormula(modelChecker);
                 } else {
                     return modelChecker.check(*this->currentCheckTask);
                 }
             }
                 
             template <typename SparseModelType, typename ConstantType>
-            std::unique_ptr<CheckResult> SparseDtmcInstantiationModelChecker<SparseModelType, ConstantType>::checkWithHint(storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ConstantType>>& modelchecker) {
+            std::unique_ptr<CheckResult> SparseDtmcInstantiationModelChecker<SparseModelType, ConstantType>::checkReachabilityProbabilityFormula(storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ConstantType>>& modelChecker) {
+                
+                if (!this->currentCheckTask->getHint().isExplicitModelCheckerHint()) {
+                    this->currentCheckTask->setHint(std::make_shared<ExplicitModelCheckerHint<ConstantType>>());
+                }
+                ExplicitModelCheckerHint<ConstantType>& hint = this->currentCheckTask->getHint().template asExplicitModelCheckerHint<ConstantType>();
+                std::unique_ptr<CheckResult> result;
+                
                 // Check the formula and store the result as a hint for the next call.
                 // For qualitative properties, we still want a quantitative result hint. Hence we perform the check on the subformula
                 if (this->currentCheckTask->getFormula().asOperatorFormula().hasQuantitativeResult()) {
-                    std::unique_ptr<storm::modelchecker::CheckResult> result = modelchecker.check(*this->currentCheckTask);
-                    this->currentCheckTask->setHint(ExplicitModelCheckerHint<ConstantType>(result->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector()));
+                    result = modelChecker.check(*this->currentCheckTask);
+                    hint.setResultHint(result->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector());
+                } else {
+                    auto newCheckTask = this->currentCheckTask->substituteFormula(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula()).setOnlyInitialStatesRelevant(false);
+                    std::unique_ptr<CheckResult> quantitativeResult = modelChecker.computeProbabilities(newCheckTask);
+                    result = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().compareAgainstBound(this->currentCheckTask->getFormula().asOperatorFormula().getComparisonType(), this->currentCheckTask->getFormula().asOperatorFormula().template getThresholdAs<ConstantType>());
+                    hint.setResultHint(std::move(quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector()));
+                }
+                
+                if (this->getInstantiationsAreGraphPreserving() && !hint.hasMaybeStates()) {
+                    // Extract the maybe states from the current result.
+                    assert(hint.hasResultHint());
+                    storm::storage::BitVector maybeStates(hint.getResultHint().size(), true);
+                    uint_fast64_t stateIndex = 0;
+                    for (auto const& value : hint.getResultHint()) {
+                        if (storm::utility::isZero(value) || storm::utility::isOne(value)) {
+                            maybeStates.set(stateIndex, false);
+                        }
+                        ++stateIndex;
+                    }
+                    hint.setMaybeStates(std::move(maybeStates));
+                    hint.setComputeOnlyMaybeStates(true);
+                }
+                
                 return result;
+            }
+            
+            template <typename SparseModelType, typename ConstantType>
+            std::unique_ptr<CheckResult> SparseDtmcInstantiationModelChecker<SparseModelType, ConstantType>::checkReachabilityRewardFormula(storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ConstantType>>& modelChecker) {
+                
+                if (!this->currentCheckTask->getHint().isExplicitModelCheckerHint()) {
+                    this->currentCheckTask->setHint(std::make_shared<ExplicitModelCheckerHint<ConstantType>>());
+                }
+                ExplicitModelCheckerHint<ConstantType>& hint = this->currentCheckTask->getHint().template asExplicitModelCheckerHint<ConstantType>();
+                std::unique_ptr<CheckResult> result;
+                
+                // Check the formula and store the result as a hint for the next call.
+                // For qualitative properties, we still want a quantitative result hint. Hence we perform the check on the subformula
+                if (this->currentCheckTask->getFormula().asOperatorFormula().hasQuantitativeResult()) {
+                    result = modelChecker.check(*this->currentCheckTask);
+                    this->currentCheckTask->getHint().template asExplicitModelCheckerHint<ConstantType>().setResultHint(result->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector());
                 } else {
-                    std::unique_ptr<storm::modelchecker::CheckResult> quantitativeResult;
                     auto newCheckTask = this->currentCheckTask->substituteFormula(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula()).setOnlyInitialStatesRelevant(false);
-                    if(this->currentCheckTask->getFormula().isProbabilityOperatorFormula()) {
-                        quantitativeResult = modelchecker.computeProbabilities(newCheckTask);
-                    } else if (this->currentCheckTask->getFormula().isRewardOperatorFormula()) {
-                        quantitativeResult = modelchecker.computeRewards(this->currentCheckTask->getFormula().asRewardOperatorFormula().getMeasureType(), newCheckTask);
+                    std::unique_ptr<CheckResult> quantitativeResult = modelChecker.computeRewards(this->currentCheckTask->getFormula().asRewardOperatorFormula().getMeasureType(), newCheckTask);
+                    result = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().compareAgainstBound(this->currentCheckTask->getFormula().asOperatorFormula().getComparisonType(), this->currentCheckTask->getFormula().asOperatorFormula().template getThresholdAs<ConstantType>());
+                    this->currentCheckTask->getHint().template asExplicitModelCheckerHint<ConstantType>().setResultHint(std::move(quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector()));
+                }
+                                
+                if (this->getInstantiationsAreGraphPreserving() && !hint.hasMaybeStates()) {
+                    // Extract the maybe states from the current result.
+                    assert(hint.hasResultHint());
+                    storm::storage::BitVector maybeStates(hint.getResultHint().size(), true);
+                    uint_fast64_t stateIndex = 0;
+                    for (auto const& value : hint.getResultHint()) {
+                        if (storm::utility::isInfinity(value)) {
+                            maybeStates.set(stateIndex, false);
+                        }
+                        ++stateIndex;
+                    }
+                    // We need to exclude the target states from the maybe states.
+                    // Note that we can not consider the states with reward zero since a valuation might set a reward to zero
+                    std::unique_ptr<CheckResult> subFormulaResult = modelChecker.check(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula().asEventuallyFormula().getSubformula());
+                    maybeStates = maybeStates & ~(subFormulaResult->asExplicitQualitativeCheckResult().getTruthValuesVector());
+                    hint.setMaybeStates(std::move(maybeStates));
+                    hint.setComputeOnlyMaybeStates(true);
+                }
+                
+                return result;
+            }
+            
+            template <typename SparseModelType, typename ConstantType>
+            std::unique_ptr<CheckResult> SparseDtmcInstantiationModelChecker<SparseModelType, ConstantType>::checkBoundedUntilFormula(storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ConstantType>>& modelChecker) {
+                
+                if (!this->currentCheckTask->getHint().isExplicitModelCheckerHint()) {
+                    this->currentCheckTask->setHint(std::make_shared<ExplicitModelCheckerHint<ConstantType>>());
+                }
+                std::unique_ptr<CheckResult> result;
+                ExplicitModelCheckerHint<ConstantType>& hint = this->currentCheckTask->getHint().template asExplicitModelCheckerHint<ConstantType>();
+                
+                if (this->getInstantiationsAreGraphPreserving() && !hint.hasMaybeStates()) {
+                    // We extract the maybestates from the quantitative result
+                    // For qualitative properties, we still need a quantitative result. Hence we perform the check on the subformula
+                    if (this->currentCheckTask->getFormula().asOperatorFormula().hasQuantitativeResult()) {
+                        result = modelChecker.check(*this->currentCheckTask);
+                        hint.setResultHint(result->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector());
                     } else {
-                        STORM_LOG_THROW(false, storm::exceptions::InvalidArgumentException, "Checking with result hint is only implemented for probability or reward operator formulas");
+                        auto newCheckTask = this->currentCheckTask->substituteFormula(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula()).setOnlyInitialStatesRelevant(false);
+                        std::unique_ptr<CheckResult> quantitativeResult = modelChecker.computeProbabilities(newCheckTask);
+                        result = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().compareAgainstBound(this->currentCheckTask->getFormula().asOperatorFormula().getComparisonType(), this->currentCheckTask->getFormula().asOperatorFormula().template getThresholdAs<ConstantType>());
+                        hint.setResultHint(std::move(quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector()));
                     }
-                    std::unique_ptr<storm::modelchecker::CheckResult> qualitativeResult = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().compareAgainstBound(this->currentCheckTask->getFormula().asOperatorFormula().getComparisonType(), this->currentCheckTask->getFormula().asOperatorFormula().template getThresholdAs<ConstantType>());
-                    this->currentCheckTask->setHint(ExplicitModelCheckerHint<ConstantType>(std::move(quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector())));
-                    return qualitativeResult;
+                    storm::storage::BitVector maybeStates(hint.getResultHint().size(), true);
+                    uint_fast64_t stateIndex = 0;
+                    for (auto const& value : hint.getResultHint()) {
+                        if (storm::utility::isZero(value)) {
+                            maybeStates.set(stateIndex, false);
                         }
+                        ++stateIndex;
+                    }
+                    // We need to exclude the target states from the maybe states.
+                    // Note that we can not consider the states with probability one since a state might reach a target state with prob 1 within >0 steps
+                    std::unique_ptr<CheckResult> subFormulaResult = modelChecker.check(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula().asBoundedUntilFormula().getRightSubformula());
+                    maybeStates = maybeStates & ~(subFormulaResult->asExplicitQualitativeCheckResult().getTruthValuesVector());
+                    hint.setMaybeStates(std::move(maybeStates));
+                    hint.setComputeOnlyMaybeStates(true);
+                } else {
+                    result = modelChecker.check(*this->currentCheckTask);
                 }
                 
+                return result;
+            }
             
             template class SparseDtmcInstantiationModelChecker<storm::models::sparse::Dtmc<storm::RationalFunction>, double>;
             template class SparseDtmcInstantiationModelChecker<storm::models::sparse::Dtmc<storm::RationalFunction>, storm::RationalNumber>;

src/storm/modelchecker/parametric/SparseDtmcInstantiationModelChecker.h

@@ -25,8 +25,10 @@ namespace storm {
 
             protected:
                 
-                // Considers the result of the last check as a hint for the current check
-                std::unique_ptr<CheckResult> checkWithHint(storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ConstantType>>& modelChecker);
+                // Optimizations for the different formula types
+                std::unique_ptr<CheckResult> checkReachabilityProbabilityFormula(storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ConstantType>>& modelChecker);
+                std::unique_ptr<CheckResult> checkReachabilityRewardFormula(storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ConstantType>>& modelChecker);
+                std::unique_ptr<CheckResult> checkBoundedUntilFormula(storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ConstantType>>& modelChecker);
                 
                 storm::utility::ModelInstantiator<SparseModelType, storm::models::sparse::Dtmc<ConstantType>> modelInstantiator;
             };

src/storm/modelchecker/parametric/SparseDtmcParameterLifting.cpp

@@ -40,6 +40,7 @@ namespace storm {
                 }
                 this->parameterLiftingChecker = std::make_unique<SparseDtmcParameterLiftingModelChecker<SparseModelType, ConstantType>>(this->getConsideredParametricModel());
                 this->instantiationChecker = std::make_unique<SparseDtmcInstantiationModelChecker<SparseModelType, ConstantType>>(this->getConsideredParametricModel());
+                this->instantiationChecker->setInstantiationsAreGraphPreserving(true);
             }
     
             template <typename SparseModelType, typename ConstantType>

src/storm/modelchecker/parametric/SparseInstantiationModelChecker.cpp

@@ -12,7 +12,7 @@ namespace storm {
         namespace parametric {
             
             template <typename SparseModelType, typename ConstantType>
-            SparseInstantiationModelChecker<SparseModelType, ConstantType>::SparseInstantiationModelChecker(SparseModelType const& parametricModel) : parametricModel(parametricModel) {
+            SparseInstantiationModelChecker<SparseModelType, ConstantType>::SparseInstantiationModelChecker(SparseModelType const& parametricModel) : parametricModel(parametricModel), instantiationsAreGraphPreserving(false) {
                 //Intentionally left empty
             }
             
@@ -24,16 +24,15 @@ namespace storm {
             }
             
             template <typename SparseModelType, typename ConstantType>
-            storm::modelchecker::ModelCheckerHint& SparseInstantiationModelChecker<SparseModelType, ConstantType>::getHint() {
-                return currentCheckTask->getHint();
+            void SparseInstantiationModelChecker<SparseModelType, ConstantType>::setInstantiationsAreGraphPreserving(bool value) {
+                instantiationsAreGraphPreserving = value;
             }
             
             template <typename SparseModelType, typename ConstantType>
-            storm::modelchecker::ModelCheckerHint const& SparseInstantiationModelChecker<SparseModelType, ConstantType>::getHint() const {
-                return currentCheckTask->getHint();
+            bool SparseInstantiationModelChecker<SparseModelType, ConstantType>::getInstantiationsAreGraphPreserving() const {
+                return instantiationsAreGraphPreserving;
             }
             
-            
             template class SparseInstantiationModelChecker<storm::models::sparse::Dtmc<storm::RationalFunction>, double>;
             template class SparseInstantiationModelChecker<storm::models::sparse::Mdp<storm::RationalFunction>, double>;
             

src/storm/modelchecker/parametric/SparseInstantiationModelChecker.h

@@ -22,8 +22,10 @@ namespace storm {
                 
                 virtual std::unique_ptr<CheckResult> check(storm::utility::parametric::Valuation<typename SparseModelType::ValueType> const& valuation) = 0;
                 
-                storm::modelchecker::ModelCheckerHint& getHint();
-                storm::modelchecker::ModelCheckerHint const& getHint() const;
+                // If set, it is assumed that all considered model instantiations have the same underlying graph structure.
+                // This bypasses the graph analysis for the different instantiations.
+                void setInstantiationsAreGraphPreserving(bool value);
+                bool getInstantiationsAreGraphPreserving() const;
                 
             protected:
                 
@@ -34,6 +36,7 @@ namespace storm {
                 // store the current formula. Note that currentCheckTask only stores a reference to the formula.
                 std::shared_ptr<storm::logic::Formula const> currentFormula;
 
+                bool instantiationsAreGraphPreserving;
             };
         }
     }

src/storm/modelchecker/parametric/SparseMdpInstantiationModelChecker.cpp

@@ -1,8 +1,10 @@
 #include "SparseMdpInstantiationModelChecker.h"
 
 #include "storm/logic/FragmentSpecification.h"
-#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h"
-#include "storm/modelchecker/hints/ExplicitModelCheckerHint.h"
+#include "storm/modelChecker/results/ExplicitQuantitativeCheckResult.h"
+#include "storm/modelChecker/results/ExplicitQualitativeCheckResult.h"
+#include "storm/modelChecker/hints/ExplicitModelCheckerHint.h"
+#include "storm/utility/graph.h"
 
 #include "storm/exceptions/InvalidArgumentException.h"
 #include "storm/exceptions/InvalidStateException.h"
@@ -24,42 +26,162 @@ namespace storm {
                 storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ConstantType>> modelChecker(instantiatedModel);
 
                 // Check if there are some optimizations implemented for the specified property
-                if(!this->currentCheckTask->isQualitativeSet() && this->currentCheckTask->getFormula().isInFragment(storm::logic::reachability().setRewardOperatorsAllowed(true).setReachabilityRewardFormulasAllowed(true))) {
-                    return checkWithResultHint(modelChecker);
+                if(this->currentCheckTask->getFormula().isInFragment(storm::logic::reachability())) {
+                    return checkReachabilityProbabilityFormula(modelChecker, instantiatedModel);
+                } else if (this->currentCheckTask->getFormula().isInFragment(storm::logic::propositional().setRewardOperatorsAllowed(true).setReachabilityRewardFormulasAllowed(true).setOperatorAtTopLevelRequired(true).setNestedOperatorsAllowed(false))) {
+                    return checkReachabilityRewardFormula(modelChecker, instantiatedModel);
+                } else if (this->currentCheckTask->getFormula().isInFragment(storm::logic::propositional().setProbabilityOperatorsAllowed(true).setBoundedUntilFormulasAllowed(true).setStepBoundedUntilFormulasAllowed(true).setTimeBoundedUntilFormulasAllowed(true).setOperatorAtTopLevelRequired(true).setNestedOperatorsAllowed(false))) {
+                    return checkBoundedUntilFormula(modelChecker);
                 } else {
                     return modelChecker.check(*this->currentCheckTask);
                 }
             }
             
             template <typename SparseModelType, typename ConstantType>
-            std::unique_ptr<CheckResult> SparseMdpInstantiationModelChecker<SparseModelType, ConstantType>::checkWithResultHint(storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ConstantType>>& modelchecker) {
+            std::unique_ptr<CheckResult> SparseMdpInstantiationModelChecker<SparseModelType, ConstantType>::checkReachabilityProbabilityFormula(storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ConstantType>>& modelChecker, storm::models::sparse::Mdp<ConstantType> const& instantiatedModel) {
                 
                 this->currentCheckTask->setProduceSchedulers(true);
                 
+                if (!this->currentCheckTask->getHint().isExplicitModelCheckerHint()) {
+                    this->currentCheckTask->setHint(std::make_shared<ExplicitModelCheckerHint<ConstantType>>());
+                }
+                ExplicitModelCheckerHint<ConstantType>& hint = this->currentCheckTask->getHint().template asExplicitModelCheckerHint<ConstantType>();
+                std::unique_ptr<CheckResult> result;
+                
                 // Check the formula and store the result as a hint for the next call.
                 // For qualitative properties, we still want a quantitative result hint. Hence we perform the check on the subformula
                 if(this->currentCheckTask->getFormula().asOperatorFormula().hasQuantitativeResult()) {
-                    std::unique_ptr<storm::modelchecker::CheckResult> result = modelchecker.check(*this->currentCheckTask);
+                    result = modelChecker.check(*this->currentCheckTask);
                     storm::storage::Scheduler const& scheduler = result->template asExplicitQuantitativeCheckResult<ConstantType>().getScheduler();
-                    this->currentCheckTask->setHint(ExplicitModelCheckerHint<ConstantType>(result->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector(),
-                                                                                           dynamic_cast<storm::storage::TotalScheduler const&>(scheduler)));
+                    hint.setResultHint(result->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector());
+                    hint.setSchedulerHint(dynamic_cast<storm::storage::TotalScheduler const&>(scheduler));
+                } else {
+                    auto newCheckTask = this->currentCheckTask->substituteFormula(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula()).setOnlyInitialStatesRelevant(false);
+                    std::unique_ptr<storm::modelchecker::CheckResult> quantitativeResult = modelChecker.computeProbabilities(newCheckTask);
+                    result = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().compareAgainstBound(this->currentCheckTask->getFormula().asOperatorFormula().getComparisonType(), this->currentCheckTask->getFormula().asOperatorFormula().template getThresholdAs<ConstantType>());
+                    storm::storage::Scheduler& scheduler = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getScheduler();
+                    hint.setResultHint(std::move(quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector()));
+                    hint.setSchedulerHint(std::move(dynamic_cast<storm::storage::TotalScheduler&>(scheduler)));
+                }
+                
+                if (this->getInstantiationsAreGraphPreserving() && !hint.hasMaybeStates()) {
+                    // Extract the maybe states from the current result.
+                    assert(hint.hasResultHint());
+                    storm::storage::BitVector maybeStates(hint.getResultHint().size(), true);
+                    uint_fast64_t stateIndex = 0;
+                    for (auto const& value : hint.getResultHint()) {
+                        if (storm::utility::isZero(value) || storm::utility::isOne(value)) {
+                            maybeStates.set(stateIndex, false);
+                        }
+                        ++stateIndex;
+                    }
+
+                    hint.setMaybeStates(std::move(maybeStates));
+                    hint.setComputeOnlyMaybeStates(true);
+                    
+                    // Check if there can be end components within the maybestates
+                    if (storm::solver::minimize(this->currentCheckTask->getOptimizationDirection()) ||
+                    storm::utility::graph::performProb1A(instantiatedModel.getTransitionMatrix(), instantiatedModel.getTransitionMatrix().getRowGroupIndices(), instantiatedModel.getBackwardTransitions(), hint.getMaybeStates(), ~hint.getMaybeStates()).full()) {
+                        hint.setNoEndComponentsInMaybeStates(true);
+                    }
+                }
+                
                 return result;
+            }
+            
+            template <typename SparseModelType, typename ConstantType>
+            std::unique_ptr<CheckResult> SparseMdpInstantiationModelChecker<SparseModelType, ConstantType>::checkReachabilityRewardFormula(storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ConstantType>>& modelChecker, storm::models::sparse::Mdp<ConstantType> const& instantiatedModel) {
+                
+                this->currentCheckTask->setProduceSchedulers(true);
+                
+                if (!this->currentCheckTask->getHint().isExplicitModelCheckerHint()) {
+                    this->currentCheckTask->setHint(std::make_shared<ExplicitModelCheckerHint<ConstantType>>());
+                }
+                ExplicitModelCheckerHint<ConstantType>& hint = this->currentCheckTask->getHint().template asExplicitModelCheckerHint<ConstantType>();
+                std::unique_ptr<CheckResult> result;
+                
+                // Check the formula and store the result as a hint for the next call.
+                // For qualitative properties, we still want a quantitative result hint. Hence we perform the check on the subformula
+                if(this->currentCheckTask->getFormula().asOperatorFormula().hasQuantitativeResult()) {
+                    std::unique_ptr<storm::modelchecker::CheckResult> result = modelChecker.check(*this->currentCheckTask);
+                    storm::storage::Scheduler const& scheduler = result->template asExplicitQuantitativeCheckResult<ConstantType>().getScheduler();
+                    hint.setResultHint(result->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector());
+                    hint.setSchedulerHint(dynamic_cast<storm::storage::TotalScheduler const&>(scheduler));
                 } else {
-                    std::unique_ptr<storm::modelchecker::CheckResult> quantitativeResult;
                     auto newCheckTask = this->currentCheckTask->substituteFormula(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula()).setOnlyInitialStatesRelevant(false);
-                    if(this->currentCheckTask->getFormula().isProbabilityOperatorFormula()) {
-                        quantitativeResult = modelchecker.computeProbabilities(newCheckTask);
-                    } else if (this->currentCheckTask->getFormula().isRewardOperatorFormula()) {
-                        quantitativeResult = modelchecker.computeRewards(this->currentCheckTask->getFormula().asRewardOperatorFormula().getMeasureType(), newCheckTask);
+                    std::unique_ptr<storm::modelchecker::CheckResult> quantitativeResult = modelChecker.computeRewards(this->currentCheckTask->getFormula().asRewardOperatorFormula().getMeasureType(), newCheckTask);
+                    result = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().compareAgainstBound(this->currentCheckTask->getFormula().asOperatorFormula().getComparisonType(), this->currentCheckTask->getFormula().asOperatorFormula().template getThresholdAs<ConstantType>());
+                    storm::storage::Scheduler& scheduler = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getScheduler();
+                    hint.setResultHint(std::move(quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector()));
+                    hint.setSchedulerHint(std::move(dynamic_cast<storm::storage::TotalScheduler&>(scheduler)));
+                }
+                
+                if (this->getInstantiationsAreGraphPreserving() && !hint.hasMaybeStates()) {
+                    // Extract the maybe states from the current result.
+                    assert(hint.hasResultHint());
+                    storm::storage::BitVector maybeStates(hint.getResultHint().size(), true);
+                    uint_fast64_t stateIndex = 0;
+                    for (auto const& value : hint.getResultHint()) {
+                        if (storm::utility::isInfinity(value)) {
+                            maybeStates.set(stateIndex, false);
+                        }
+                        ++stateIndex;
+                    }
+                    // We need to exclude the target states from the maybe states.
+                    // Note that we can not consider the states with reward zero since a valuation might set a reward to zero
+                    std::unique_ptr<CheckResult> subFormulaResult = modelChecker.check(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula().asEventuallyFormula().getSubformula());
+                    maybeStates = maybeStates & ~(subFormulaResult->asExplicitQualitativeCheckResult().getTruthValuesVector());
+                    hint.setMaybeStates(std::move(maybeStates));
+                    hint.setComputeOnlyMaybeStates(true);
+                    
+                    // Check if there can be end components within the maybestates
+                    if (storm::solver::maximize(this->currentCheckTask->getOptimizationDirection()) ||
+                    storm::utility::graph::performProb1A(instantiatedModel.getTransitionMatrix(), instantiatedModel.getTransitionMatrix().getRowGroupIndices(), instantiatedModel.getBackwardTransitions(), hint.getMaybeStates(), ~hint.getMaybeStates()).full()) {
+                        hint.setNoEndComponentsInMaybeStates(true);
+                    }
+                }
+                return result;
+            }
+            
+            template <typename SparseModelType, typename ConstantType>
+            std::unique_ptr<CheckResult> SparseMdpInstantiationModelChecker<SparseModelType, ConstantType>::checkBoundedUntilFormula(storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ConstantType>>& modelChecker) {
+                 
+                if (!this->currentCheckTask->getHint().isExplicitModelCheckerHint()) {
+                    this->currentCheckTask->setHint(std::make_shared<ExplicitModelCheckerHint<ConstantType>>());
+                }
+                std::unique_ptr<CheckResult> result;
+                ExplicitModelCheckerHint<ConstantType>& hint = this->currentCheckTask->getHint().template asExplicitModelCheckerHint<ConstantType>();
+                
+                if (this->getInstantiationsAreGraphPreserving() && !hint.hasMaybeStates()) {
+                    // We extract the maybestates from the quantitative result
+                    // For qualitative properties, we still need a quantitative result. Hence we perform the check on the subformula
+                    if (this->currentCheckTask->getFormula().asOperatorFormula().hasQuantitativeResult()) {
+                        result = modelChecker.check(*this->currentCheckTask);
+                        hint.setResultHint(result->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector());
                     } else {
-                        STORM_LOG_THROW(false, storm::exceptions::InvalidArgumentException, "Checking with hint is only implemented for probability or reward operator formulas");
+                        auto newCheckTask = this->currentCheckTask->substituteFormula(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula()).setOnlyInitialStatesRelevant(false);
+                        std::unique_ptr<CheckResult> quantitativeResult = modelChecker.computeProbabilities(newCheckTask);
+                        result = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().compareAgainstBound(this->currentCheckTask->getFormula().asOperatorFormula().getComparisonType(), this->currentCheckTask->getFormula().asOperatorFormula().template getThresholdAs<ConstantType>());
+                        hint.setResultHint(std::move(quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector()));
                     }
-                    std::unique_ptr<storm::modelchecker::CheckResult> qualitativeResult = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().compareAgainstBound(this->currentCheckTask->getFormula().asOperatorFormula().getComparisonType(), this->currentCheckTask->getFormula().asOperatorFormula().template getThresholdAs<ConstantType>());
-                    storm::storage::Scheduler& scheduler = quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getScheduler();
-                    this->currentCheckTask->setHint(ExplicitModelCheckerHint<ConstantType>(std::move(quantitativeResult->template asExplicitQuantitativeCheckResult<ConstantType>().getValueVector()),
-                                                                                           std::move(dynamic_cast<storm::storage::TotalScheduler&>(scheduler))));
-                    return qualitativeResult;
+                    storm::storage::BitVector maybeStates(hint.getResultHint().size(), true);
+                    uint_fast64_t stateIndex = 0;
+                    for (auto const& value : hint.getResultHint()) {
+                        if (storm::utility::isZero(value)) {
+                            maybeStates.set(stateIndex, false);
+                        }
+                        ++stateIndex;
                     }
+                    // We need to exclude the target states from the maybe states.
+                    // Note that we can not consider the states with probability one since a state might reach a target state with prob 1 within >0 steps
+                    std::unique_ptr<CheckResult> subFormulaResult = modelChecker.check(this->currentCheckTask->getFormula().asOperatorFormula().getSubformula().asBoundedUntilFormula().getRightSubformula());
+                    maybeStates = maybeStates & ~(subFormulaResult->asExplicitQualitativeCheckResult().getTruthValuesVector());
+                    hint.setMaybeStates(std::move(maybeStates));
+                    hint.setComputeOnlyMaybeStates(true);
+                } else {
+                    result = modelChecker.check(*this->currentCheckTask);
+                }
+                return result;
             }
             
             template class SparseMdpInstantiationModelChecker<storm::models::sparse::Mdp<storm::RationalFunction>, double>;

src/storm/modelchecker/parametric/SparseMdpInstantiationModelChecker.h

@@ -25,8 +25,10 @@ namespace storm {
                 virtual std::unique_ptr<CheckResult> check(storm::utility::parametric::Valuation<typename SparseModelType::ValueType> const& valuation) override;
 
             protected:
-                // Considers the result of the last check as a hint for the current check
-                std::unique_ptr<CheckResult> checkWithResultHint(storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ConstantType>>& modelChecker);
+                // Optimizations for the different formula types
+                std::unique_ptr<CheckResult> checkReachabilityProbabilityFormula(storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ConstantType>>& modelChecker, storm::models::sparse::Mdp<ConstantType> const& instantiatedModel);
+                std::unique_ptr<CheckResult> checkReachabilityRewardFormula(storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ConstantType>>& modelChecker, storm::models::sparse::Mdp<ConstantType> const& instantiatedModel);
+                std::unique_ptr<CheckResult> checkBoundedUntilFormula(storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ConstantType>>& modelChecker);
                 
                 storm::utility::ModelInstantiator<SparseModelType, storm::models::sparse::Mdp<ConstantType>> modelInstantiator;
             };

src/storm/modelchecker/parametric/SparseMdpParameterLifting.cpp

@@ -40,6 +40,7 @@ namespace storm {
                 }
                 this->parameterLiftingChecker = std::make_unique<SparseMdpParameterLiftingModelChecker<SparseModelType, ConstantType>>(this->getConsideredParametricModel());
                 this->instantiationChecker = std::make_unique<SparseMdpInstantiationModelChecker<SparseModelType, ConstantType>>(this->getConsideredParametricModel());
+                this->instantiationChecker->setInstantiationsAreGraphPreserving(true);
             }
     
             template <typename SparseModelType, typename ConstantType>

src/storm/modelchecker/prctl/SparseDtmcPrctlModelChecker.cpp

@@ -48,7 +48,7 @@ namespace storm {
             std::unique_ptr<CheckResult> rightResultPointer = this->check(pathFormula.getRightSubformula());
             ExplicitQualitativeCheckResult const& leftResult = leftResultPointer->asExplicitQualitativeCheckResult();
             ExplicitQualitativeCheckResult const& rightResult = rightResultPointer->asExplicitQualitativeCheckResult();
-            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseDtmcPrctlHelper<ValueType>::computeBoundedUntilProbabilities(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), leftResult.getTruthValuesVector(), rightResult.getTruthValuesVector(), pathFormula.getNonStrictUpperBound<uint64_t>(), *linearEquationSolverFactory);
+            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseDtmcPrctlHelper<ValueType>::computeBoundedUntilProbabilities(this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), leftResult.getTruthValuesVector(), rightResult.getTruthValuesVector(), pathFormula.getNonStrictUpperBound<uint64_t>(), *linearEquationSolverFactory, checkTask.getHint());
             std::unique_ptr<CheckResult> result = std::unique_ptr<CheckResult>(new ExplicitQuantitativeCheckResult<ValueType>(std::move(numericResult)));
             return result;
         }

src/storm/modelchecker/prctl/SparseMdpPrctlModelChecker.cpp

@@ -64,7 +64,7 @@ namespace storm {
             std::unique_ptr<CheckResult> rightResultPointer = this->check(pathFormula.getRightSubformula());
             ExplicitQualitativeCheckResult const& leftResult = leftResultPointer->asExplicitQualitativeCheckResult();
             ExplicitQualitativeCheckResult const& rightResult = rightResultPointer->asExplicitQualitativeCheckResult();
-            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseMdpPrctlHelper<ValueType>::computeBoundedUntilProbabilities(checkTask.getOptimizationDirection(), this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), leftResult.getTruthValuesVector(), rightResult.getTruthValuesVector(), pathFormula.getNonStrictUpperBound<uint64_t>(), *minMaxLinearEquationSolverFactory);
+            std::vector<ValueType> numericResult = storm::modelchecker::helper::SparseMdpPrctlHelper<ValueType>::computeBoundedUntilProbabilities(checkTask.getOptimizationDirection(), this->getModel().getTransitionMatrix(), this->getModel().getBackwardTransitions(), leftResult.getTruthValuesVector(), rightResult.getTruthValuesVector(), pathFormula.getNonStrictUpperBound<uint64_t>(), *minMaxLinearEquationSolverFactory, checkTask.getHint());
             return std::unique_ptr<CheckResult>(new ExplicitQuantitativeCheckResult<ValueType>(std::move(numericResult)));
         }
         

src/storm/modelchecker/prctl/helper/SparseDtmcPrctlHelper.cpp

@@ -13,18 +13,27 @@
 
 #include "storm/exceptions/InvalidStateException.h"
 #include "storm/exceptions/InvalidPropertyException.h"
+#include "storm/exceptions/IllegalArgumentException.h"
 
 namespace storm {
     namespace modelchecker {
         namespace helper {
             template<typename ValueType, typename RewardModelType>
-            std::vector<ValueType> SparseDtmcPrctlHelper<ValueType, RewardModelType>::computeBoundedUntilProbabilities(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, uint_fast64_t stepBound, storm::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory) {
+            std::vector<ValueType> SparseDtmcPrctlHelper<ValueType, RewardModelType>::computeBoundedUntilProbabilities(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, uint_fast64_t stepBound, storm::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory, ModelCheckerHint const& hint) {
                 std::vector<ValueType> result(transitionMatrix.getRowCount(), storm::utility::zero<ValueType>());
                 
                 // If we identify the states that have probability 0 of reaching the target states, we can exclude them in the further analysis.
-                storm::storage::BitVector maybeStates = storm::utility::graph::performProbGreater0(backwardTransitions, phiStates, psiStates, true, stepBound);
+                storm::storage::BitVector maybeStates;
+                  
+                if (hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().getComputeOnlyMaybeStates()) {
+                    maybeStates = hint.template asExplicitModelCheckerHint<ValueType>().getMaybeStates();
+                } else {
+                    maybeStates = storm::utility::graph::performProbGreater0(backwardTransitions, phiStates, psiStates, true, stepBound);
                     maybeStates &= ~psiStates;
                     STORM_LOG_INFO("Found " << maybeStates.getNumberOfSetBits() << " 'maybe' states.");
+                }
+                
+                storm::utility::vector::setVectorValues<ValueType>(result, psiStates, storm::utility::one<ValueType>());
                 
                 if (!maybeStates.empty()) {
                     // We can eliminate the rows and columns from the original transition probability matrix that have probability 0.
@@ -43,7 +52,6 @@ namespace storm {
                     // Set the values of the resulting vector accordingly.
                     storm::utility::vector::setVectorValues(result, maybeStates, subresult);
                 }
-                storm::utility::vector::setVectorValues<ValueType>(result, psiStates, storm::utility::one<ValueType>());
                 
                 return result;
             }
@@ -51,20 +59,44 @@ namespace storm {
             template<typename ValueType, typename RewardModelType>
 
             std::vector<ValueType> SparseDtmcPrctlHelper<ValueType, RewardModelType>::computeUntilProbabilities(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool qualitative, storm::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory, ModelCheckerHint const& hint) {
-                // We need to identify the states which have to be taken out of the matrix, i.e.
-                // all states that have probability 0 and 1 of satisfying the until-formula.
+                
+                std::vector<ValueType> result(transitionMatrix.getRowCount(), storm::utility::zero<ValueType>());
+                
+                // We need to identify the maybe states (states which have a probability for satisfying the until formula
+                // that is strictly between 0 and 1) and the states that satisfy the formula with probablity 1.
+                storm::storage::BitVector maybeStates, statesWithProbability1;
+                
+                if (hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().getComputeOnlyMaybeStates()) {
+                    maybeStates = hint.template asExplicitModelCheckerHint<ValueType>().getMaybeStates();
+                    
+                    // Treat the states with probability one
+                    std::vector<ValueType> const& resultsForNonMaybeStates = hint.template asExplicitModelCheckerHint<ValueType>().getResultHint();
+                    statesWithProbability1 = storm::storage::BitVector(maybeStates.size(), false);
+                    storm::storage::BitVector nonMaybeStates = ~maybeStates;
+                    for (auto const& state : nonMaybeStates) {
+                        if (storm::utility::isOne(resultsForNonMaybeStates[state])) {
+                            statesWithProbability1.set(state, true);
+                            result[state] = storm::utility::one<ValueType>();
+                        } else {
+                            STORM_LOG_THROW(storm::utility::isZero(resultsForNonMaybeStates[state]), storm::exceptions::IllegalArgumentException, "Expected that the result hint specifies probabilities in {0,1} for non-maybe states");
+                        }
+                    }
+                } else {
+                
+                    // Get all states that have probability 0 and 1 of satisfying the until-formula.
                     std::pair<storm::storage::BitVector, storm::storage::BitVector> statesWithProbability01 = storm::utility::graph::performProb01(backwardTransitions, phiStates, psiStates);
                     storm::storage::BitVector statesWithProbability0 = std::move(statesWithProbability01.first);
-                storm::storage::BitVector statesWithProbability1 = std::move(statesWithProbability01.second);
+                    statesWithProbability1 = std::move(statesWithProbability01.second);
+                    maybeStates = ~(statesWithProbability0 | statesWithProbability1);
                                     
-                // Perform some logging.
-                storm::storage::BitVector maybeStates = ~(statesWithProbability0 | statesWithProbability1);
                     STORM_LOG_INFO("Found " << statesWithProbability0.getNumberOfSetBits() << " 'no' states.");
                     STORM_LOG_INFO("Found " << statesWithProbability1.getNumberOfSetBits() << " 'yes' states.");
                     STORM_LOG_INFO("Found " << maybeStates.getNumberOfSetBits() << " 'maybe' states.");
                     
-                // Create resulting vector.
-                std::vector<ValueType> result(transitionMatrix.getRowCount());
+                    // Set values of resulting vector that are known exactly.
+                    storm::utility::vector::setVectorValues<ValueType>(result, statesWithProbability0, storm::utility::zero<ValueType>());
+                    storm::utility::vector::setVectorValues<ValueType>(result, statesWithProbability1, storm::utility::one<ValueType>());
+                }
                 
                 // Check whether we need to compute exact probabilities for some states.
                 if (qualitative) {
@@ -84,9 +116,11 @@ namespace storm {
                         // Initialize the x vector with the hint (if available) or with 0.5 for each element.
                         // This is the initial guess for the iterative solvers. It should be safe as for all
                         // 'maybe' states we know that the probability is strictly larger than 0.
-                        std::vector<ValueType> x(maybeStates.getNumberOfSetBits(), storm::utility::convertNumber<ValueType>(0.5));
+                        std::vector<ValueType> x;
                         if(hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().hasResultHint()) {
-                            storm::utility::vector::selectVectorValues(x, maybeStates, hint.template asExplicitModelCheckerHint<ValueType>().getResultHint());
+                            x = storm::utility::vector::filterVector(hint.template asExplicitModelCheckerHint<ValueType>().getResultHint(), maybeStates);
+                        } else {
+                            x = std::vector<ValueType>(maybeStates.getNumberOfSetBits(), storm::utility::convertNumber<ValueType>(0.5));
                         }
 
                         // Prepare the right-hand side of the equation system. For entry i this corresponds to
@@ -102,11 +136,6 @@ namespace storm {
                         storm::utility::vector::setVectorValues<ValueType>(result, maybeStates, x);
                     }
                 }
-                
-                // Set values of resulting vector that are known exactly.
-                storm::utility::vector::setVectorValues<ValueType>(result, statesWithProbability0, storm::utility::zero<ValueType>());
-                storm::utility::vector::setVectorValues<ValueType>(result, statesWithProbability1, storm::utility::one<ValueType>());
-                
                 return result;
             }
             
@@ -180,17 +209,26 @@ namespace storm {
             
             template<typename ValueType, typename RewardModelType>
             std::vector<ValueType> SparseDtmcPrctlHelper<ValueType, RewardModelType>::computeReachabilityRewards(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::function<std::vector<ValueType>(uint_fast64_t, storm::storage::SparseMatrix<ValueType> const&, storm::storage::BitVector const&)> const& totalStateRewardVectorGetter, storm::storage::BitVector const& targetStates, bool qualitative, storm::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory, ModelCheckerHint const& hint) {
-                // Determine which states have a reward of infinity by definition.
+                
+                std::vector<ValueType> result(transitionMatrix.getRowCount(), storm::utility::zero<ValueType>());
+                
+                // Determine which states have a reward that is less than infinity.
+                storm::storage::BitVector maybeStates;
+                if (hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().getComputeOnlyMaybeStates()) {
+                    maybeStates = hint.template asExplicitModelCheckerHint<ValueType>().getMaybeStates();
+                    storm::utility::vector::setVectorValues(result, ~(maybeStates | targetStates), storm::utility::infinity<ValueType>());
+                } else {
                     storm::storage::BitVector trueStates(transitionMatrix.getRowCount(), true);
                     storm::storage::BitVector infinityStates = storm::utility::graph::performProb1(backwardTransitions, trueStates, targetStates);
                     infinityStates.complement();
-                storm::storage::BitVector maybeStates = ~targetStates & ~infinityStates;
+                    maybeStates = ~(targetStates | infinityStates);
+                    
                     STORM_LOG_INFO("Found " << infinityStates.getNumberOfSetBits() << " 'infinity' states.");
                     STORM_LOG_INFO("Found " << targetStates.getNumberOfSetBits() << " 'target' states.");
                     STORM_LOG_INFO("Found " << maybeStates.getNumberOfSetBits() << " 'maybe' states.");
                     
-                // Create resulting vector.
-                std::vector<ValueType> result(transitionMatrix.getRowCount(), storm::utility::zero<ValueType>());
+                    storm::utility::vector::setVectorValues(result, infinityStates, storm::utility::infinity<ValueType>());
+                }
                 
                 // Check whether we need to compute exact rewards for some states.
                 if (qualitative) {
@@ -209,9 +247,11 @@ namespace storm {
                         
                         // Initialize the x vector with the hint (if available) or with 1 for each element.
                         // This is the initial guess for the iterative solvers.
-                        std::vector<ValueType> x(submatrix.getColumnCount(), storm::utility::one<ValueType>());
+                        std::vector<ValueType> x;
                         if(hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().hasResultHint()) {
-                            storm::utility::vector::selectVectorValues(x, maybeStates, hint.template asExplicitModelCheckerHint<ValueType>().getResultHint());
+                            x = storm::utility::vector::filterVector(hint.template asExplicitModelCheckerHint<ValueType>().getResultHint(), maybeStates);
+                        } else {
+                            x = std::vector<ValueType>(submatrix.getColumnCount(), storm::utility::one<ValueType>());
                         }
                         
                         // Prepare the right-hand side of the equation system.
@@ -226,10 +266,6 @@ namespace storm {
                         storm::utility::vector::setVectorValues<ValueType>(result, maybeStates, x);
                     }
                 }
-                
-                // Set values of resulting vector that are known exactly.
-                storm::utility::vector::setVectorValues(result, infinityStates, storm::utility::infinity<ValueType>());
-                
                 return result;
             }
             

src/storm/modelchecker/prctl/helper/SparseDtmcPrctlHelper.h

@@ -22,7 +22,7 @@ namespace storm {
             template <typename ValueType, typename RewardModelType = storm::models::sparse::StandardRewardModel<ValueType>>
             class SparseDtmcPrctlHelper {
             public:
-                static std::vector<ValueType> computeBoundedUntilProbabilities(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, uint_fast64_t stepBound, storm::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory);
+                static std::vector<ValueType> computeBoundedUntilProbabilities(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, uint_fast64_t stepBound, storm::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory, ModelCheckerHint const& hint = ModelCheckerHint());
                 
                 static std::vector<ValueType> computeNextProbabilities(storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::BitVector const& nextStates, storm::solver::LinearEquationSolverFactory<ValueType> const& linearEquationSolverFactory);
                 

src/storm/modelchecker/prctl/helper/SparseMdpPrctlHelper.cpp

@@ -22,17 +22,21 @@
 #include "storm/exceptions/InvalidPropertyException.h"
 #include "storm/exceptions/InvalidSettingsException.h"
 #include "storm/exceptions/IllegalFunctionCallException.h"
+#include "storm/exceptions/IllegalArgumentException.h"
 
 namespace storm {
     namespace modelchecker {
         namespace helper {
 
             template<typename ValueType>
-            std::vector<ValueType> SparseMdpPrctlHelper<ValueType>::computeBoundedUntilProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, uint_fast64_t stepBound, storm::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory) {
+            std::vector<ValueType> SparseMdpPrctlHelper<ValueType>::computeBoundedUntilProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, uint_fast64_t stepBound, storm::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory, ModelCheckerHint const& hint) {
                 std::vector<ValueType> result(transitionMatrix.getRowGroupCount(), storm::utility::zero<ValueType>());
                 
                 // Determine the states that have 0 probability of reaching the target states.
                 storm::storage::BitVector maybeStates;
+                if (hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().getComputeOnlyMaybeStates()) {
+                    maybeStates = hint.template asExplicitModelCheckerHint<ValueType>().getMaybeStates();
+                } else {
                     if (dir == OptimizationDirection::Minimize) {
                         maybeStates = storm::utility::graph::performProbGreater0A(transitionMatrix, transitionMatrix.getRowGroupIndices(), backwardTransitions, phiStates, psiStates, true, stepBound);
                     } else {
@@ -40,6 +44,7 @@ namespace storm {
                     }
                     maybeStates &= ~psiStates;
                     STORM_LOG_INFO("Found " << maybeStates.getNumberOfSetBits() << " 'maybe' states.");
+                }
                 
                 if (!maybeStates.empty()) {
                     // We can eliminate the rows and columns from the original transition probability matrix that have probability 0.
@@ -77,27 +82,48 @@ namespace storm {
             MDPSparseModelCheckingHelperReturnType<ValueType> SparseMdpPrctlHelper<ValueType>::computeUntilProbabilities(storm::solver::SolveGoal const& goal, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, bool qualitative, bool produceScheduler, storm::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory, ModelCheckerHint const& hint) {
                 STORM_LOG_THROW(!(qualitative && produceScheduler), storm::exceptions::InvalidSettingsException, "Cannot produce scheduler when performing qualitative model checking only.");
                      
-                // We need to identify the states which have to be taken out of the matrix, i.e.
-                // all states that have probability 0 and 1 of satisfying the until-formula.
+                std::vector<ValueType> result(transitionMatrix.getRowGroupCount(), storm::utility::zero<ValueType>());
+                 
+                // We need to identify the maybe states (states which have a probability for satisfying the until formula
+                // that is strictly between 0 and 1) and the states that satisfy the formula with probablity 1 and 0, respectively.
+                storm::storage::BitVector maybeStates, statesWithProbability1, statesWithProbability0;
+                
+                if (hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().getComputeOnlyMaybeStates()) {
+                    maybeStates = hint.template asExplicitModelCheckerHint<ValueType>().getMaybeStates();
+                    
+                    // Treat the states with probability one
+                    std::vector<ValueType> const& resultsForNonMaybeStates = hint.template asExplicitModelCheckerHint<ValueType>().getResultHint();
+                    statesWithProbability1 = storm::storage::BitVector(maybeStates.size(), false);
+                    statesWithProbability0 = storm::storage::BitVector(maybeStates.size(), false);
+                    storm::storage::BitVector nonMaybeStates = ~maybeStates;
+                    for (auto const& state : nonMaybeStates) {
+                        if (storm::utility::isOne(resultsForNonMaybeStates[state])) {
+                            statesWithProbability1.set(state, true);
+                            result[state] = storm::utility::one<ValueType>();
+                        } else {
+                            STORM_LOG_THROW(storm::utility::isZero(resultsForNonMaybeStates[state]), storm::exceptions::IllegalArgumentException, "Expected that the result hint specifies probabilities in {0,1} for non-maybe states");
+                            statesWithProbability0.set(state, true);
+                        }
+                    }
+                } else {
+                    // Get all states that have probability 0 and 1 of satisfying the until-formula.
                      std::pair<storm::storage::BitVector, storm::storage::BitVector> statesWithProbability01;
                     if (goal.minimize()) {
                         statesWithProbability01 = storm::utility::graph::performProb01Min(transitionMatrix, transitionMatrix.getRowGroupIndices(), backwardTransitions, phiStates, psiStates);
                     } else {
                         statesWithProbability01 = storm::utility::graph::performProb01Max(transitionMatrix, transitionMatrix.getRowGroupIndices(), backwardTransitions, phiStates, psiStates);
                     }
-                storm::storage::BitVector statesWithProbability0 = std::move(statesWithProbability01.first);
-                storm::storage::BitVector statesWithProbability1 = std::move(statesWithProbability01.second);
-                storm::storage::BitVector maybeStates = ~(statesWithProbability0 | statesWithProbability1);
+                    statesWithProbability0 = std::move(statesWithProbability01.first);
+                    statesWithProbability1 = std::move(statesWithProbability01.second);
+                    maybeStates = ~(statesWithProbability0 | statesWithProbability1);
                     STORM_LOG_INFO("Found " << statesWithProbability0.getNumberOfSetBits() << " 'no' states.");
                     STORM_LOG_INFO("Found " << statesWithProbability1.getNumberOfSetBits() << " 'yes' states.");
                     STORM_LOG_INFO("Found " << maybeStates.getNumberOfSetBits() << " 'maybe' states.");
                 
-                // Create resulting vector.
-                std::vector<ValueType> result(transitionMatrix.getRowGroupCount());
-                
                     // Set values of resulting vector that are known exactly.
                     storm::utility::vector::setVectorValues<ValueType>(result, statesWithProbability0, storm::utility::zero<ValueType>());
                     storm::utility::vector::setVectorValues<ValueType>(result, statesWithProbability1, storm::utility::one<ValueType>());
+                }
                 
                 // If requested, we will produce a scheduler.
                 std::unique_ptr<storm::storage::TotalScheduler> scheduler;
@@ -122,7 +148,8 @@ namespace storm {
                         std::vector<ValueType> b = transitionMatrix.getConstrainedRowGroupSumVector(maybeStates, statesWithProbability1);
                         
                         // Now compute the results for the maybeStates
-                        MDPSparseModelCheckingHelperReturnType<ValueType> resultForMaybeStates = computeValuesOnlyMaybeStates(goal, transitionMatrix, backwardTransitions, maybeStates, submatrix, b, produceScheduler, minMaxLinearEquationSolverFactory, hint, goal.minimize(), storm::utility::zero<ValueType>(), storm::utility::one<ValueType>());
+                        bool skipEcWithinMaybeStatesCheck = goal.minimize() || (hint.isExplicitModelCheckerHint() && hint.asExplicitModelCheckerHint<ValueType>().getNoEndComponentsInMaybeStates());
+                        MDPSparseModelCheckingHelperReturnType<ValueType> resultForMaybeStates = computeValuesOnlyMaybeStates(goal, transitionMatrix, backwardTransitions, maybeStates, submatrix, b, produceScheduler, minMaxLinearEquationSolverFactory, hint, skipEcWithinMaybeStatesCheck, storm::utility::zero<ValueType>(), storm::utility::one<ValueType>());
                         
                         // Set values of resulting vector according to result.
                         storm::utility::vector::setVectorValues<ValueType>(result, maybeStates, resultForMaybeStates.values);
@@ -168,7 +195,7 @@ namespace storm {
                 }
                 // the scheduler hint is only applicable if it induces no BSCC consisting of maybestates
                 if (hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().hasSchedulerHint() &&
-                   (hint.template asExplicitModelCheckerHint<ValueType>().getForceApplicationOfHints() || skipECWithinMaybeStatesCheck ||
+                   (skipECWithinMaybeStatesCheck ||
                     storm::utility::graph::performProb1(transitionMatrix.transposeSelectedRowsFromRowGroups(hint.template asExplicitModelCheckerHint<ValueType>().getSchedulerHint().getChoices()), maybeStates, ~maybeStates).full())) {
                     solver->setSchedulerHint(hint.template asExplicitModelCheckerHint<ValueType>().getSchedulerHint().getSchedulerForSubsystem(maybeStates));
                 }
@@ -178,7 +205,7 @@ namespace storm {
                 std::vector<ValueType> x;
                 // The result hint is only applicable if there are no End Components consisting of maybestates
                 if (hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().hasResultHint() &&
-                   (hint.template asExplicitModelCheckerHint<ValueType>().getForceApplicationOfHints() || skipECWithinMaybeStatesCheck || solver->hasSchedulerHint() ||
+                   (skipECWithinMaybeStatesCheck || solver->hasSchedulerHint() ||
                     storm::utility::graph::performProb1A(transitionMatrix, transitionMatrix.getRowGroupIndices(), backwardTransitions, maybeStates, ~maybeStates).full())) {
                     x = storm::utility::vector::filterVector(hint.template asExplicitModelCheckerHint<ValueType>().getResultHint(), maybeStates);
                 } else {
@@ -309,10 +336,17 @@ namespace storm {
             template<typename ValueType>
             MDPSparseModelCheckingHelperReturnType<ValueType> SparseMdpPrctlHelper<ValueType>::computeReachabilityRewardsHelper(storm::solver::SolveGoal const& goal, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, std::function<std::vector<ValueType>(uint_fast64_t, storm::storage::SparseMatrix<ValueType> const&, storm::storage::BitVector const&)> const& totalStateRewardVectorGetter, storm::storage::BitVector const& targetStates, bool qualitative, bool produceScheduler, storm::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory, ModelCheckerHint const& hint) {
                 
+                std::vector<ValueType> result(transitionMatrix.getRowGroupCount(), storm::utility::zero<ValueType>());
+
                 std::vector<uint_fast64_t> const& nondeterministicChoiceIndices = transitionMatrix.getRowGroupIndices();
                 
-                // Determine which states have a reward of infinity by definition.
-                storm::storage::BitVector infinityStates;
+                
+                // Determine which states have a reward that is infinity or less than infinity.
+                storm::storage::BitVector maybeStates, infinityStates;
+                if (hint.isExplicitModelCheckerHint() && hint.template asExplicitModelCheckerHint<ValueType>().getComputeOnlyMaybeStates()) {
+                    maybeStates = hint.template asExplicitModelCheckerHint<ValueType>().getMaybeStates();
+                    infinityStates = ~(maybeStates | targetStates);
+                } else {
                     storm::storage::BitVector trueStates(transitionMatrix.getRowGroupCount(), true);
                     if (goal.minimize()) {
                         STORM_LOG_WARN("Results of reward computation may be too low, because of zero-reward loops.");
@@ -321,15 +355,11 @@ namespace storm {
                         infinityStates = storm::utility::graph::performProb1A(transitionMatrix, nondeterministicChoiceIndices, backwardTransitions, trueStates, targetStates);
                     }
                     infinityStates.complement();
-                storm::storage::BitVector maybeStates = ~targetStates & ~infinityStates;
+                    maybeStates = ~(targetStates | infinityStates);
                     STORM_LOG_INFO("Found " << infinityStates.getNumberOfSetBits() << " 'infinity' states.");
                     STORM_LOG_INFO("Found " << targetStates.getNumberOfSetBits() << " 'target' states.");
                     STORM_LOG_INFO("Found " << maybeStates.getNumberOfSetBits() << " 'maybe' states.");
-                
-                // Create resulting vector.
-                std::vector<ValueType> result(transitionMatrix.getRowGroupCount(), storm::utility::zero<ValueType>());
-                
-                // Set values of resulting vector that are known exactly.
+                }
                 storm::utility::vector::setVectorValues(result, infinityStates, storm::utility::infinity<ValueType>());
                 
                 // If requested, we will produce a scheduler.
@@ -369,8 +399,9 @@ namespace storm {
                             }
                         }
                         
+                        bool skipEcWithinMaybeStatesCheck = !goal.minimize() || (hint.isExplicitModelCheckerHint() && hint.asExplicitModelCheckerHint<ValueType>().getNoEndComponentsInMaybeStates());
                         // Now compute the results for the maybeStates
-                        MDPSparseModelCheckingHelperReturnType<ValueType> resultForMaybeStates = computeValuesOnlyMaybeStates(goal, transitionMatrix, backwardTransitions, maybeStates, submatrix, b, produceScheduler, minMaxLinearEquationSolverFactory, hint, !goal.minimize(), storm::utility::zero<ValueType>());
+                        MDPSparseModelCheckingHelperReturnType<ValueType> resultForMaybeStates = computeValuesOnlyMaybeStates(goal, transitionMatrix, backwardTransitions, maybeStates, submatrix, b, produceScheduler, minMaxLinearEquationSolverFactory, hint, skipEcWithinMaybeStatesCheck, storm::utility::zero<ValueType>());
 
                         // Set values of resulting vector according to result.
                         storm::utility::vector::setVectorValues<ValueType>(result, maybeStates, resultForMaybeStates.values);

src/storm/modelchecker/prctl/helper/SparseMdpPrctlHelper.h

@@ -33,7 +33,7 @@ namespace storm {
             template <typename ValueType>
             class SparseMdpPrctlHelper {
             public:
-                static std::vector<ValueType> computeBoundedUntilProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, uint_fast64_t stepBound, storm::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
+                static std::vector<ValueType> computeBoundedUntilProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::SparseMatrix<ValueType> const& backwardTransitions, storm::storage::BitVector const& phiStates, storm::storage::BitVector const& psiStates, uint_fast64_t stepBound, storm::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory, ModelCheckerHint const& hint = ModelCheckerHint());
 
                 static std::vector<ValueType> computeNextProbabilities(OptimizationDirection dir, storm::storage::SparseMatrix<ValueType> const& transitionMatrix, storm::storage::BitVector const& nextStates, storm::solver::MinMaxLinearEquationSolverFactory<ValueType> const& minMaxLinearEquationSolverFactory);
 

src/storm/utility/parameterlifting.h

@@ -45,7 +45,7 @@ namespace storm {
                     }
                 } else if (model->isOfType(storm::models::ModelType::MarkovAutomaton)) {
                     // Markov Automata store the probability matrix and the exit rate vector. However, we need to considert the rate matrix.
-                    if (model->template as<storm::models::sparse::MarkovAutomaton<ValueType>>()->isClosed()) {
+                    if (!model->template as<storm::models::sparse::MarkovAutomaton<ValueType>>()->isClosed()) {
                         STORM_LOG_ERROR("parameter lifting requires a closed Markov automaton.");
                         return false;
                     }
@@ -56,7 +56,7 @@ namespace storm {
                             auto const& exitRate = rateVector[state];
                             for (auto const& entry : model->getTransitionMatrix().getRowGroup(state)) {
                                 if (!storm::utility::parametric::isMultiLinearPolynomial(storm::utility::simplify(entry.getValue() * exitRate))) {
-                                    STORM_LOG_WARN("The input model contains a non-linear polynomial as transition: '" << entry.getValue() << "'. Can not validate that parameter lifting is sound on this model.");
+                                    STORM_LOG_WARN("The input model contains a non-linear polynomial as transition rate: '" << storm::utility::simplify(entry.getValue() * exitRate) << "'. Can not validate that parameter lifting is sound on this model.");
                                     return false;
                                 }
                             }

src/storm/utility/vector.h

@@ -483,6 +483,17 @@ namespace storm {
                 return filter<T>(values, storm::utility::isZero<T>);
             }
                         
+            /*!
+             * Retrieves a bit vector containing all the indices for which the value at this position is equal to one
+             *
+             * @param values The vector of values.
+             * @return The resulting bit vector.
+             */
+            template<class T>
+            storm::storage::BitVector filterOne(std::vector<T> const& values) {
+                return filter<T>(values, storm::utility::isOne<T>);
+            }
+            
             /**
              * Sum the entries from values that are set to one in the filter vector.
              * @param values