moved parameter lifting related code out of the main library/executable

src/storm/modelchecker/parametric/RegionChecker.cpp → src/storm-pars/modelchecker/region/RegionModelChecker.cpp

@@ -68,8 +68,8 @@ namespace storm {
             }
     
             template <typename SparseModelType, typename ConstantType, typename ExactConstantType>
-            RegionCheckResult RegionChecker<SparseModelType, ConstantType, ExactConstantType>::analyzeRegion(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, RegionCheckResult const& initialResult, bool sampleVerticesOfRegion) {
-                      RegionCheckResult result = initialResult;
+            RegionResult RegionChecker<SparseModelType, ConstantType, ExactConstantType>::analyzeRegion(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, RegionResult const& initialResult, bool sampleVerticesOfRegion) {
+                      RegionResult result = initialResult;
 
                 // Check if we need to check the formula on one point to decide whether to show AllSat or AllViolated
                 instantiationCheckerStopwatch.start();
@@ -120,8 +120,8 @@ namespace storm {
             }
             
             template <typename SparseModelType, typename ConstantType, typename ExactConstantType>
-            RegionCheckResult RegionChecker<SparseModelType, ConstantType, ExactConstantType>::analyzeRegionExactValidation(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, RegionCheckResult const& initialResult) {
-                RegionCheckResult numericResult = analyzeRegion(region, initialResult, false);
+            RegionResult RegionChecker<SparseModelType, ConstantType, ExactConstantType>::analyzeRegionExactValidation(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, RegionResult const& initialResult) {
+                RegionResult numericResult = analyzeRegion(region, initialResult, false);
                 parameterLiftingCheckerStopwatch.start();
                 if (numericResult == RegionCheckResult::AllSat || numericResult == RegionCheckResult::AllViolated) {
                     applyHintsToExactChecker();
@@ -159,7 +159,7 @@ namespace storm {
 
     
             template <typename SparseModelType, typename ConstantType, typename ExactConstantType>
-            std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionCheckResult>> RegionChecker<SparseModelType, ConstantType, ExactConstantType>::performRegionRefinement(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, CoefficientType const& threshold) {
+            std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionResult>> RegionChecker<SparseModelType, ConstantType, ExactConstantType>::performRegionRefinement(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, CoefficientType const& threshold) {
                 STORM_LOG_INFO("Applying refinement on region: " << region.toString(true) << " .");
                 
                 auto areaOfParameterSpace = region.area();
@@ -167,8 +167,8 @@ namespace storm {
                 auto fractionOfAllSatArea = storm::utility::zero<CoefficientType>();
                 auto fractionOfAllViolatedArea = storm::utility::zero<CoefficientType>();
                 
-                std::queue<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionCheckResult>> unprocessedRegions;
-                std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionCheckResult>> result;
+                std::queue<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionResult>> unprocessedRegions;
+                std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionResult>> result;
                 unprocessedRegions.emplace(region, RegionCheckResult::Unknown);
                 uint_fast64_t numOfAnalyzedRegions = 0;
                 numOfCorrectedRegions = 0;
@@ -211,7 +211,7 @@ namespace storm {
                         default:
                             std::vector<storm::storage::ParameterRegion<typename SparseModelType::ValueType>> newRegions;
                             currentRegion.split(currentRegion.getCenterPoint(), newRegions);
-                            RegionCheckResult initResForNewRegions = (res == RegionCheckResult::CenterSat) ? RegionCheckResult::ExistsSat :
+                            RegionResult initResForNewRegions = (res == RegionCheckResult::CenterSat) ? RegionCheckResult::ExistsSat :
                                                                      ((res == RegionCheckResult::CenterViolated) ? RegionCheckResult::ExistsViolated :
                                                                       RegionCheckResult::Unknown);
                             for(auto& newRegion : newRegions) {
@@ -258,7 +258,7 @@ namespace storm {
             }
     
             template <typename SparseModelType, typename ConstantType, typename ExactConstantType>
-            std::string RegionChecker<SparseModelType, ConstantType, ExactConstantType>::visualizeResult(std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionCheckResult>> const& result, storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& parameterSpace, typename storm::storage::ParameterRegion<typename SparseModelType::ValueType>::VariableType const& x, typename storm::storage::ParameterRegion<typename SparseModelType::ValueType>::VariableType const& y) {
+            std::string RegionChecker<SparseModelType, ConstantType, ExactConstantType>::visualizeResult(std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionResult>> const& result, storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& parameterSpace, typename storm::storage::ParameterRegion<typename SparseModelType::ValueType>::VariableType const& x, typename storm::storage::ParameterRegion<typename SparseModelType::ValueType>::VariableType const& y) {
                 
                 std::stringstream stream;
                 

src/storm/modelchecker/parametric/RegionChecker.h → src/storm-pars/modelchecker/region/RegionModelChecker.h

@@ -43,19 +43,19 @@ namespace storm {
                  * Then, we check whether ALL points in the region violate/satisfy the property
                  *
                  */
-                RegionCheckResult analyzeRegion(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, RegionCheckResult const& initialResult = RegionCheckResult::Unknown, bool sampleVerticesOfRegion = false);
+                RegionResult analyzeRegion(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, RegionResult const& initialResult = RegionCheckResult::Unknown, bool sampleVerticesOfRegion = false);
                 /*!
                  * Similar to analyze region but additionaly invokes exact parameter lifting to validate results AllSat or AllViolated
                  */
-                RegionCheckResult analyzeRegionExactValidation(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, RegionCheckResult const& initialResult = RegionCheckResult::Unknown);
+                RegionResult analyzeRegionExactValidation(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, RegionResult const& initialResult = RegionCheckResult::Unknown);
                 
                 /*!
                  * Iteratively refines the region until parameter lifting yields a conclusive result (AllSat or AllViolated).
                  * The refinement stops as soon as the fraction of the area of the subregions with inconclusive result is less then the given threshold
                  */
-                std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionCheckResult>> performRegionRefinement(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, CoefficientType const& threshold);
+                std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionResult>> performRegionRefinement(storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& region, CoefficientType const& threshold);
                 
-                static std::string visualizeResult(std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionCheckResult>> const& result, storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& parameterSpace, typename storm::storage::ParameterRegion<typename SparseModelType::ValueType>::VariableType const& x, typename storm::storage::ParameterRegion<typename SparseModelType::ValueType>::VariableType const& y);
+                static std::string visualizeResult(std::vector<std::pair<storm::storage::ParameterRegion<typename SparseModelType::ValueType>, RegionResult>> const& result, storm::storage::ParameterRegion<typename SparseModelType::ValueType> const& parameterSpace, typename storm::storage::ParameterRegion<typename SparseModelType::ValueType>::VariableType const& x, typename storm::storage::ParameterRegion<typename SparseModelType::ValueType>::VariableType const& y);
                 
             protected:
                 SparseModelType const& getConsideredParametricModel() const;

src/storm/settings/modules/ParametricSettings.h → src/storm-pars/settings/modules/ParametricSettings.h

@@ -12,15 +12,6 @@ namespace storm {
              */
             class ParametricSettings : public ModuleSettings {
             public:
-				/**
-				 * A type for saving the Smt2EncondingStrategy.
-				 * 
-				 * FULL_TRANSITION_SYSTEM: The transition system should be reduced only with very basic operations.
-				 * ONLY_SCC_ENTRY_STATES: Scc elimination should be performed, but no further reduction.
-				 * HIGH_INDEGREE:  State elimination but for states with a high indegree.
-				 * RATIONAL_FUNCTION: The smt file should contain only the rational function.
-				 */
-				enum class Smt2EncodingStrategy {FULL_TRANSITION_SYSTEM, ONLY_SCC_ENTRY_STATES, HIGH_INDEGREE, RATIONAL_FUNCTION};
                 
                 /*!
                  * Creates a new set of parametric model checking settings.
@@ -42,12 +33,12 @@ namespace storm {
 				/*!
 				 * Retrieves whether the parameter space was declared
 				 */
-				bool isParameterSpaceSet() const;
+				bool isRegionSet() const;
 				
 				/*!
 				 * Retrieves the given parameter spcae
 				 */
-				std::string getParameterSpace() const;
+				std::string getRegionString() const;
 				
 				/*!
 				 * Retrieves the threshold considered for iterative region refinement.
@@ -60,24 +51,6 @@ namespace storm {
 				 */
 				bool isExactValidationSet() const;
 				
-				/**
-				 * Retrieves whether the encoding of the transition system should be exported to a file. 
-				 * @return True iff the smt file should be encoded.
-				 */
-				bool exportToSmt2File() const;
-				
-				/**
-				 * The path to a file location which should contain the smt2 encoding.
-                 * @return A path to a file location.
-                 */
-				std::string exportSmt2Path() const;
-				
-				/**
-				 * Retrieves which encoding strategy should be used for generating the smt2 file.
-                 * @return The encoding strategy to be used.
-                 */
-				Smt2EncodingStrategy smt2EncodingStrategy() const;
-                
                 /*!
                  * Retrieves whether or not derivatives of the resulting rational function are to be generated.
                  *
@@ -91,7 +64,7 @@ namespace storm {
 				const static std::string encodeSmt2StrategyOptionName;
 				const static std::string exportSmt2DestinationPathOptionName;
 				const static std::string exportResultDestinationPathOptionName;
-				const static std::string parameterSpaceOptionName;
+				const static std::string regionOptionName;
 				const static std::string refinementThresholdOptionName;
 				const static std::string exactValidationOptionName;
                 const static std::string derivativesOptionName;

src/storm/api/verification.h

@@ -255,131 +255,5 @@ namespace storm {
             return result;
         }
         
-        template<typename ParametricType>
-        std::unique_ptr<storm::modelchecker::CheckResult> verifyWithParameterLifting(std::shared_ptr<storm::models::sparse::Model<ParametricType>>, std::shared_ptr<storm::logic::Formula const> const&) {
-            STORM_LOG_THROW(false, storm::exceptions::NotSupportedException, "Parameter-lifting is unavailable for this data-type.");
-        }
-            
-        template<>
-        inline std::unique_ptr<storm::modelchecker::CheckResult> verifyWithParameterLifting(std::shared_ptr<storm::models::sparse::Model<storm::RationalFunction>> markovModel, std::shared_ptr<storm::logic::Formula const> const& formula) {
-            STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "Parameter-lifting is currently unavailable from the API.");
-//                storm::utility::Stopwatch parameterLiftingStopWatch(true);
-//                std::shared_ptr<storm::logic::Formula const> consideredFormula = formula;
-//                
-//                STORM_LOG_WARN_COND(storm::utility::parameterlifting::validateParameterLiftingSound(markovModel, formula), "Could not validate whether parameter lifting is sound on the input model and the formula " << *formula);
-//                
-//                if (markovModel->isOfType(storm::models::ModelType::Ctmc) || markovModel->isOfType(storm::models::ModelType::MarkovAutomaton)) {
-//                    STORM_PRINT_AND_LOG("Transforming continuous model to discrete model...");
-//                    storm::transformer::transformContinuousToDiscreteModelInPlace(markovModel, consideredFormula);
-//                    STORM_PRINT_AND_LOG(" done!" << std::endl);
-//                    markovModel->printModelInformationToStream(std::cout);
-//                }
-//                
-//                auto modelParameters = storm::models::sparse::getProbabilityParameters(*markovModel);
-//                auto rewParameters = storm::models::sparse::getRewardParameters(*markovModel);
-//                modelParameters.insert(rewParameters.begin(), rewParameters.end());
-//                
-//                STORM_LOG_THROW(storm::settings::getModule<storm::settings::modules::ParametricSettings>().isParameterSpaceSet(), storm::exceptions::InvalidSettingsException, "Invoked Parameter lifting but no parameter space was defined.");
-//                auto parameterSpaceAsString = storm::settings::getModule<storm::settings::modules::ParametricSettings>().getParameterSpace();
-//                auto parameterSpace = storm::storage::ParameterRegion<storm::RationalFunction>::parseRegion(parameterSpaceAsString, modelParameters);
-//                auto refinementThreshold = storm::utility::convertNumber<typename storm::storage::ParameterRegion<storm::RationalFunction>::CoefficientType>(storm::settings::getModule<storm::settings::modules::ParametricSettings>().getRefinementThreshold());
-//                std::vector<std::pair<storm::storage::ParameterRegion<storm::RationalFunction>, storm::modelchecker::parametric::RegionCheckResult>> result;
-//                
-//                STORM_PRINT_AND_LOG("Performing parameter lifting for property " << *consideredFormula << " with parameter space " << parameterSpace.toString(true) << " and refinement threshold " << storm::utility::convertNumber<double>(refinementThreshold) << " ..." << std::endl);
-//                
-//                storm::modelchecker::CheckTask<storm::logic::Formula, storm::RationalFunction> task(*consideredFormula, true);
-//                std::string resultVisualization;
-//                
-//                if (markovModel->isOfType(storm::models::ModelType::Dtmc)) {
-//                    if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isExactSet()) {
-//                        storm::modelchecker::parametric::SparseDtmcRegionChecker <storm::models::sparse::Dtmc<storm::RationalFunction>, storm::RationalNumber> regionChecker(*markovModel->template as<storm::models::sparse::Dtmc<storm::RationalFunction>>());
-//                        regionChecker.specifyFormula(task);
-//                        result = regionChecker.performRegionRefinement(parameterSpace, refinementThreshold);
-//                        parameterLiftingStopWatch.stop();
-//                        if (modelParameters.size() == 2) {
-//                            resultVisualization = regionChecker.visualizeResult(result, parameterSpace, *modelParameters.begin(), *(modelParameters.rbegin()));
-//                        }
-//                    } else {
-//                        storm::modelchecker::parametric::SparseDtmcRegionChecker <storm::models::sparse::Dtmc<storm::RationalFunction>, double, storm::RationalNumber> regionChecker(*markovModel->template as<storm::models::sparse::Dtmc<storm::RationalFunction>>());
-//                        regionChecker.specifyFormula(task);
-//                        result = regionChecker.performRegionRefinement(parameterSpace, refinementThreshold);
-//                        parameterLiftingStopWatch.stop();
-//                        if (modelParameters.size() == 2) {
-//                            resultVisualization = regionChecker.visualizeResult(result, parameterSpace, *modelParameters.begin(), *(modelParameters.rbegin()));
-//                        }
-//                    }
-//                } else if (markovModel->isOfType(storm::models::ModelType::Mdp)) {
-//                    if (storm::settings::getModule<storm::settings::modules::GeneralSettings>().isExactSet()) {
-//                        storm::modelchecker::parametric::SparseMdpRegionChecker<storm::models::sparse::Mdp<storm::RationalFunction>, storm::RationalNumber> regionChecker(*markovModel->template as<storm::models::sparse::Mdp<storm::RationalFunction>>());
-//                        regionChecker.specifyFormula(task);
-//                        result = regionChecker.performRegionRefinement(parameterSpace, refinementThreshold);
-//                        parameterLiftingStopWatch.stop();
-//                        if (modelParameters.size() == 2) {
-//                            resultVisualization = regionChecker.visualizeResult(result, parameterSpace, *modelParameters.begin(), *(modelParameters.rbegin()));
-//                        }
-//                    } else {
-//                        storm::modelchecker::parametric::SparseMdpRegionChecker<storm::models::sparse::Mdp<storm::RationalFunction>, double, storm::RationalNumber> regionChecker(*markovModel->template as<storm::models::sparse::Mdp<storm::RationalFunction>>());
-//                        regionChecker.specifyFormula(task);
-//                        result = regionChecker.performRegionRefinement(parameterSpace, refinementThreshold);
-//                        parameterLiftingStopWatch.stop();
-//                        if (modelParameters.size() == 2) {
-//                            resultVisualization = regionChecker.visualizeResult(result, parameterSpace, *modelParameters.begin(), *(modelParameters.rbegin()));
-//                        }
-//                    }
-//                } else {
-//                    STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Unable to perform parameterLifting on the provided model type.");
-//                }
-//                
-//                
-//                auto satArea = storm::utility::zero<typename storm::storage::ParameterRegion<storm::RationalFunction>::CoefficientType>();
-//                auto unsatArea = storm::utility::zero<typename storm::storage::ParameterRegion<storm::RationalFunction>::CoefficientType>();
-//                uint_fast64_t numOfSatRegions = 0;
-//                uint_fast64_t numOfUnsatRegions = 0;
-//                for (auto const& res : result) {
-//                    switch (res.second) {
-//                        case storm::modelchecker::parametric::RegionCheckResult::AllSat:
-//                            satArea += res.first.area();
-//                            ++numOfSatRegions;
-//                            break;
-//                        case storm::modelchecker::parametric::RegionCheckResult::AllViolated:
-//                            unsatArea += res.first.area();
-//                            ++numOfUnsatRegions;
-//                            break;
-//                        default:
-//                            STORM_LOG_ERROR("Unexpected result for region " << res.first.toString(true) << " : " << res.second << ".");
-//                            break;
-//                    }
-//                }
-//                typename storm::storage::ParameterRegion<storm::RationalFunction>::CoefficientType satAreaFraction = satArea / parameterSpace.area();
-//                typename storm::storage::ParameterRegion<storm::RationalFunction>::CoefficientType unsatAreaFraction = unsatArea / parameterSpace.area();
-//                STORM_PRINT_AND_LOG("Done! Found " << numOfSatRegions << " safe regions and "
-//                                    << numOfUnsatRegions << " unsafe regions." << std::endl);
-//                STORM_PRINT_AND_LOG(storm::utility::convertNumber<double>(satAreaFraction) * 100 << "% of the parameter space is safe, and "
-//                                    << storm::utility::convertNumber<double>(unsatAreaFraction) * 100 << "% of the parameter space is unsafe." << std::endl);
-//                STORM_PRINT_AND_LOG("Model checking with parameter lifting took " << parameterLiftingStopWatch << " seconds." << std::endl);
-//                STORM_PRINT_AND_LOG(resultVisualization);
-//                
-//                if (storm::settings::getModule<storm::settings::modules::ParametricSettings>().exportResultToFile()) {
-//                    std::string path = storm::settings::getModule<storm::settings::modules::ParametricSettings>().exportResultPath();
-//                    STORM_PRINT_AND_LOG("Exporting result to path " << path << "." << std::endl);
-//                    std::ofstream filestream;
-//                    storm::utility::openFile(path, filestream);
-//                    
-//                    for (auto const& res : result) {
-//                        switch (res.second) {
-//                            case storm::modelchecker::parametric::RegionCheckResult::AllSat:
-//                                filestream << "safe: " << res.first.toString(true) << std::endl;
-//                                break;
-//                            case storm::modelchecker::parametric::RegionCheckResult::AllViolated:
-//                                filestream << "unsafe: " << res.first.toString(true) << std::endl;
-//                                break;
-//                            default:
-//                                break;
-//                        }
-//                    }
-//                }
-//            }
-        }
-        
     }
 }

src/storm/cli/cli.cpp

@@ -26,7 +26,6 @@
 
 #include "storm/settings/SettingsManager.h"
 #include "storm/settings/modules/ResourceSettings.h"
-#include "storm/settings/modules/ParametricSettings.h"
 
 #include <type_traits>
 
@@ -658,13 +657,6 @@ namespace storm {
                                             std::unique_ptr<storm::modelchecker::CheckResult> result = storm::api::verifyWithSparseEngine<ValueType>(sparseModel, storm::api::createTask<ValueType>(formula, true));
                                             result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(sparseModel->getInitialStates()));
                                             return result;
-                                        },
-                                        [&sparseModel] (std::unique_ptr<storm::modelchecker::CheckResult> const& result) {
-                                            auto parametricSettings = storm::settings::getModule<storm::settings::modules::ParametricSettings>();
-                                            if (std::is_same<ValueType, storm::RationalFunction>::value && sparseModel->isOfType(storm::models::ModelType::Dtmc) && parametricSettings.exportResultToFile()) {
-                                                auto dtmc = sparseModel->template as<storm::models::sparse::Dtmc<storm::RationalFunction>>();
-                                                storm::api::exportParametricResultToFile(result->asExplicitQuantitativeCheckResult<storm::RationalFunction>()[*sparseModel->getInitialStates().begin()], storm::analysis::ConstraintCollector<storm::RationalFunction>(*dtmc), parametricSettings.exportResultPath());
-                                            }
                                         });
         }
 

src/storm/settings/SettingsManager.cpp

@@ -30,7 +30,6 @@
 #include "storm/settings/modules/GlpkSettings.h"
 #include "storm/settings/modules/GurobiSettings.h"
 #include "storm/settings/modules/Smt2SmtSolverSettings.h"
-#include "storm/settings/modules/ParametricSettings.h"
 #include "storm/settings/modules/TopologicalValueIterationEquationSolverSettings.h"
 #include "storm/settings/modules/ExplorationSettings.h"
 #include "storm/settings/modules/ResourceSettings.h"
@@ -527,7 +526,6 @@ namespace storm {
             storm::settings::addModule<storm::settings::modules::GlpkSettings>();
             storm::settings::addModule<storm::settings::modules::GurobiSettings>();
             storm::settings::addModule<storm::settings::modules::TopologicalValueIterationEquationSolverSettings>();
-            storm::settings::addModule<storm::settings::modules::ParametricSettings>();
             storm::settings::addModule<storm::settings::modules::Smt2SmtSolverSettings>();
             storm::settings::addModule<storm::settings::modules::ExplorationSettings>();
             storm::settings::addModule<storm::settings::modules::ResourceSettings>();

src/storm/settings/modules/CoreSettings.cpp

@@ -24,7 +24,6 @@ namespace storm {
             const std::string CoreSettings::dontFixDeadlockOptionShortName = "ndl";
             const std::string CoreSettings::eqSolverOptionName = "eqsolver";
             const std::string CoreSettings::lpSolverOptionName = "lpsolver";
-            const std::string CoreSettings::parameterLiftingOptionName = "parameterlifting";
             const std::string CoreSettings::smtSolverOptionName = "smtsolver";
             const std::string CoreSettings::statisticsOptionName = "statistics";
             const std::string CoreSettings::statisticsOptionShortName = "stats";
@@ -53,8 +52,6 @@ namespace storm {
                 this->addOption(storm::settings::OptionBuilder(moduleName, lpSolverOptionName, false, "Sets which LP solver is preferred.")
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of an LP solver.").addValidatorString(ArgumentValidatorFactory::createMultipleChoiceValidator(lpSolvers)).setDefaultValueString("glpk").build()).build());
                 
-                this->addOption(storm::settings::OptionBuilder(moduleName, parameterLiftingOptionName, false, "Sets whether parameter lifting is applied.").build());
-                
                 std::vector<std::string> smtSolvers = {"z3", "mathsat"};
                 this->addOption(storm::settings::OptionBuilder(moduleName, smtSolverOptionName, false, "Sets which SMT solver is preferred.")
                                 .addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of an SMT solver.").addValidatorString(ArgumentValidatorFactory::createMultipleChoiceValidator(smtSolvers)).setDefaultValueString("z3").build()).build());
@@ -92,10 +89,6 @@ namespace storm {
                 return this->getOption(eqSolverOptionName).getHasOptionBeenSet();
             }
             
-            bool CoreSettings::isParameterLiftingSet() const {
-                return this->getOption(parameterLiftingOptionName).getHasOptionBeenSet();
-            }
-            
             storm::solver::LpSolverType CoreSettings::getLpSolver() const {
                 std::string lpSolverName = this->getOption(lpSolverOptionName).getArgumentByName("name").getValueAsString();
                 if (lpSolverName == "gurobi") {

src/storm/settings/modules/CoreSettings.h

@@ -81,12 +81,6 @@ namespace storm {
                  */
                 bool isEquationSolverSet() const;
 
-                /*!
-                 * Retrieves whether parameter lifting should be applied.
-                 * @return True iff parameter lifting should be applied.
-                 */
-                bool isParameterLiftingSet() const;
-                
                 /*!
                  * Retrieves the selected LP solver.
                  *
@@ -150,7 +144,6 @@ namespace storm {
                 static const std::string dontFixDeadlockOptionShortName;
                 static const std::string eqSolverOptionName;
                 static const std::string lpSolverOptionName;
-                static const std::string parameterLiftingOptionName;
                 static const std::string smtSolverOptionName;
                 static const std::string statisticsOptionName;
                 static const std::string statisticsOptionShortName;