From a8cf21c44782939b92b0244c540768c4a27209be Mon Sep 17 00:00:00 2001 From: dehnert Date: Thu, 1 Dec 2016 16:17:17 +0100 Subject: [PATCH] added some options --- src/storm/abstraction/MenuGameRefiner.cpp | 147 +++++++++++------- src/storm/abstraction/MenuGameRefiner.h | 21 ++- .../abstraction/GameBasedMdpModelChecker.cpp | 2 +- .../settings/modules/AbstractionSettings.cpp | 14 ++ .../settings/modules/AbstractionSettings.h | 17 ++ 5 files changed, 143 insertions(+), 58 deletions(-) diff --git a/src/storm/abstraction/MenuGameRefiner.cpp b/src/storm/abstraction/MenuGameRefiner.cpp index ddb5bd1d4..a062a33c2 100644 --- a/src/storm/abstraction/MenuGameRefiner.cpp +++ b/src/storm/abstraction/MenuGameRefiner.cpp @@ -9,6 +9,8 @@ #include "storm/solver/MathsatSmtSolver.h" +#include "storm/exceptions/InvalidStateException.h" + #include "storm/settings/SettingsManager.h" #include "storm/settings/modules/AbstractionSettings.h" @@ -27,6 +29,10 @@ namespace storm { return predicates; } + void RefinementPredicates::addPredicates(std::vector const& newPredicates) { + this->predicates.insert(this->predicates.end(), newPredicates.begin(), newPredicates.end()); + } + template struct PivotStateCandidatesResult { storm::dd::Bdd reachableTransitionsMin; @@ -40,7 +46,7 @@ namespace storm { } template - MenuGameRefiner::MenuGameRefiner(MenuGameAbstractor& abstractor, std::unique_ptr&& smtSolver) : abstractor(abstractor), splitPredicates(storm::settings::getModule().isSplitPredicatesSet()), splitGuards(storm::settings::getModule().isSplitGuardsSet()), splitter(), equivalenceChecker(std::move(smtSolver)) { + MenuGameRefiner::MenuGameRefiner(MenuGameAbstractor& abstractor, std::unique_ptr&& smtSolver) : abstractor(abstractor), useInterpolation(storm::settings::getModule().isUseInterpolationSet()), splitAll(storm::settings::getModule().isSplitAllSet()), splitPredicates(storm::settings::getModule().isSplitPredicatesSet()), splitGuards(storm::settings::getModule().isSplitGuardsSet()), splitInitialGuards(storm::settings::getModule().isSplitInitialGuardsSet()), splitter(), equivalenceChecker(std::move(smtSolver)) { if (storm::settings::getModule().isAddAllGuardsSet()) { std::vector guards; @@ -49,7 +55,7 @@ namespace storm { for (uint64_t index = player1Choices.first; index < player1Choices.second; ++index) { guards.push_back(this->abstractor.get().getGuard(index)); } - performRefinement(createGlobalRefinement(preprocessPredicates(guards, storm::settings::getModule().isSplitInitialGuardsSet()))); + performRefinement(createGlobalRefinement(preprocessPredicates(guards, RefinementPredicates::Source::InitialGuard))); } } @@ -58,6 +64,8 @@ namespace storm { performRefinement(createGlobalRefinement(predicates)); } +// static int cnt = 0; + template storm::dd::Bdd getMostProbablePathSpanningTree(storm::abstraction::MenuGame const& game, storm::dd::Bdd const& targetState, storm::dd::Bdd const& transitionFilter) { storm::dd::Add maxProbabilities = game.getInitialStates().template toAdd(); @@ -70,7 +78,7 @@ namespace storm { std::set variablesToAbstract(game.getRowVariables()); variablesToAbstract.insert(game.getPlayer1Variables().begin(), game.getPlayer1Variables().end()); variablesToAbstract.insert(game.getProbabilisticBranchingVariables().begin(), game.getProbabilisticBranchingVariables().end()); - while (!border.isZero() && (border && targetState).isZero()) { + while (!border.isZero()) { // Determine the new maximal probabilities to all states. storm::dd::Add tmp = border.template toAdd() * transitionMatrix * maxProbabilities; storm::dd::Bdd newMaxProbabilityChoices = tmp.maxAbstractRepresentative(variablesToAbstract); @@ -213,10 +221,6 @@ namespace storm { STORM_LOG_DEBUG("Derived new predicate (based on weakest-precondition): " << newPredicate); } - STORM_LOG_TRACE("Current set of predicates:"); - for (auto const& predicate : abstractionInformation.getPredicates()) { - STORM_LOG_TRACE(predicate); - } return RefinementPredicates(fromGuard ? RefinementPredicates::Source::Guard : RefinementPredicates::Source::WeakestPrecondition, {newPredicate}); } @@ -253,36 +257,49 @@ namespace storm { // Compute the lower and the upper choice for the pivot state. std::set variablesToAbstract = game.getNondeterminismVariables(); variablesToAbstract.insert(game.getRowVariables().begin(), game.getRowVariables().end()); + + bool player1ChoicesDifferent = !(pivotState && minPlayer1Strategy).exclusiveOr(pivotState && maxPlayer1Strategy).isZero(); + + boost::optional predicates; + + // Derive predicates from lower choice. storm::dd::Bdd lowerChoice = pivotState && game.getExtendedTransitionMatrix().toBdd() && minPlayer1Strategy; storm::dd::Bdd lowerChoice1 = (lowerChoice && minPlayer2Strategy).existsAbstract(variablesToAbstract); storm::dd::Bdd lowerChoice2 = (lowerChoice && maxPlayer2Strategy).existsAbstract(variablesToAbstract); bool lowerChoicesDifferent = !lowerChoice1.exclusiveOr(lowerChoice2).isZero(); if (lowerChoicesDifferent) { - STORM_LOG_TRACE("Refining based on lower choice."); - auto refinementStart = std::chrono::high_resolution_clock::now(); - - RefinementPredicates predicates = derivePredicatesFromDifferingChoices(pivotState, (pivotState && minPlayer1Strategy).existsAbstract(game.getRowVariables()), lowerChoice1, lowerChoice2); - auto refinementEnd = std::chrono::high_resolution_clock::now(); - STORM_LOG_TRACE("Refinement completed in " << std::chrono::duration_cast(refinementEnd - refinementStart).count() << "ms."); - return predicates; + STORM_LOG_TRACE("Deriving predicate based on lower choice."); + predicates = derivePredicatesFromDifferingChoices(pivotState, (pivotState && minPlayer1Strategy).existsAbstract(game.getRowVariables()), lowerChoice1, lowerChoice2); + } + + if (predicates && (!player1ChoicesDifferent || predicates.get().getSource() == RefinementPredicates::Source::Guard)) { + return predicates.get(); } else { + boost::optional additionalPredicates; + storm::dd::Bdd upperChoice = pivotState && game.getExtendedTransitionMatrix().toBdd() && maxPlayer1Strategy; storm::dd::Bdd upperChoice1 = (upperChoice && minPlayer2Strategy).existsAbstract(variablesToAbstract); storm::dd::Bdd upperChoice2 = (upperChoice && maxPlayer2Strategy).existsAbstract(variablesToAbstract); bool upperChoicesDifferent = !upperChoice1.exclusiveOr(upperChoice2).isZero(); if (upperChoicesDifferent) { - STORM_LOG_TRACE("Refining based on upper choice."); - auto refinementStart = std::chrono::high_resolution_clock::now(); - RefinementPredicates predicates = derivePredicatesFromDifferingChoices(pivotState, (pivotState && maxPlayer1Strategy).existsAbstract(game.getRowVariables()), upperChoice1, upperChoice2); - auto refinementEnd = std::chrono::high_resolution_clock::now(); - STORM_LOG_TRACE("Refinement completed in " << std::chrono::duration_cast(refinementEnd - refinementStart).count() << "ms."); - return predicates; - } else { - STORM_LOG_ASSERT(false, "Did not find choices from which to derive predicates."); + STORM_LOG_TRACE("Deriving predicate based on upper choice."); + additionalPredicates = derivePredicatesFromDifferingChoices(pivotState, (pivotState && maxPlayer1Strategy).existsAbstract(game.getRowVariables()), upperChoice1, upperChoice2); + } + + if (additionalPredicates) { + if (additionalPredicates.get().getSource() == RefinementPredicates::Source::Guard) { + return additionalPredicates.get(); + } else { + predicates.get().addPredicates(additionalPredicates.get().getPredicates()); + } } } + + STORM_LOG_THROW(static_cast(predicates), storm::exceptions::InvalidStateException, "Could not derive predicates for refinement."); + + return predicates.get(); } template @@ -295,8 +312,16 @@ namespace storm { variablesToAbstract.insert(game.getPlayer1Variables().begin(), game.getPlayer1Variables().end()); variablesToAbstract.insert(game.getProbabilisticBranchingVariables().begin(), game.getProbabilisticBranchingVariables().end()); + storm::expressions::Expression initialExpression = abstractor.get().getInitialExpression(); + + std::set oldVariables = initialExpression.getVariables(); + for (auto const& predicate : abstractionInformation.getPredicates()) { + std::set usedVariables = predicate.getVariables(); + oldVariables.insert(usedVariables.begin(), usedVariables.end()); + } + std::map oldToNewVariables; - for (auto const& variable : abstractionInformation.getExpressionManager().getVariables()) { + for (auto const& variable : oldVariables) { oldToNewVariables[variable] = expressionManager.getVariable(variable.getName()); } std::map lastSubstitution; @@ -312,7 +337,7 @@ namespace storm { predicate = predicate.changeManager(expressionManager); } - pivotState.template toAdd().exportToDot("pivot.dot"); +// pivotState.template toAdd().exportToDot("pivot.dot"); // Perform a backward search for an initial state. storm::dd::Bdd currentState = pivotState; @@ -320,7 +345,6 @@ namespace storm { while ((currentState && game.getInitialStates()).isZero()) { storm::dd::Bdd predecessorTransition = currentState.swapVariables(game.getRowColumnMetaVariablePairs()) && spanningTree; std::tuple decodedPredecessor = abstractionInformation.decodeStatePlayer1ChoiceAndUpdate(predecessorTransition); - std::cout << "got predecessor " << std::get<0>(decodedPredecessor) << ", choice " << std::get<1>(decodedPredecessor) << " and update " << std::get<2>(decodedPredecessor) << std::endl; // predecessorTransition.template toAdd().exportToDot("pred_" + std::to_string(cnt) + ".dot"); @@ -358,12 +382,12 @@ namespace storm { ++cnt; } - result.back().push_back(abstractor.get().getInitialExpression().changeManager(expressionManager).substitute(lastSubstitution)); + result.back().push_back(initialExpression.changeManager(expressionManager).substitute(lastSubstitution)); return result; } template - boost::optional> MenuGameRefiner::derivePredicatesFromInterpolation(storm::abstraction::MenuGame const& game, PivotStateResult const& pivotStateResult, storm::dd::Bdd const& minPlayer1Strategy, storm::dd::Bdd const& minPlayer2Strategy, storm::dd::Bdd const& maxPlayer1Strategy, storm::dd::Bdd const& maxPlayer2Strategy) const { + boost::optional MenuGameRefiner::derivePredicatesFromInterpolation(storm::abstraction::MenuGame const& game, PivotStateResult const& pivotStateResult, storm::dd::Bdd const& minPlayer1Strategy, storm::dd::Bdd const& minPlayer2Strategy, storm::dd::Bdd const& maxPlayer1Strategy, storm::dd::Bdd const& maxPlayer2Strategy) const { // Compute the most probable path from any initial state to the pivot state. storm::dd::Bdd spanningTree = getMostProbablePathSpanningTree(game, pivotStateResult.pivotState, pivotStateResult.fromDirection == storm::OptimizationDirection::Minimize ? minPlayer1Strategy && minPlayer2Strategy : maxPlayer1Strategy && maxPlayer2Strategy); @@ -374,20 +398,18 @@ namespace storm { // Build the trace of the most probable path in terms of which predicates hold in each step. std::vector> trace = buildTrace(*interpolationManager, game, spanningTree, pivotStateResult.pivotState); - // Now encode the trace as an SMT problem. + // Create solver and interpolation groups. storm::solver::MathsatSmtSolver interpolatingSolver(*interpolationManager, storm::solver::MathsatSmtSolver::Options(true, false, true)); - uint64_t stepCounter = 0; for (auto const& step : trace) { - std::cout << "group " << stepCounter << std::endl; interpolatingSolver.setInterpolationGroup(stepCounter); for (auto const& predicate : step) { - std::cout << predicate << std::endl; interpolatingSolver.add(predicate); } ++stepCounter; } + // Now encode the trace as an SMT problem. storm::solver::SmtSolver::CheckResult result = interpolatingSolver.check(); if (result == storm::solver::SmtSolver::CheckResult::Unsat) { STORM_LOG_TRACE("Trace formula is unsatisfiable. Starting interpolation."); @@ -400,10 +422,9 @@ namespace storm { STORM_LOG_ASSERT(!interpolant.isTrue() && !interpolant.isFalse(), "Expected other interpolant."); interpolants.push_back(interpolant); } - return boost::make_optional(interpolants); + return boost::make_optional(RefinementPredicates(RefinementPredicates::Source::Interpolation, interpolants)); } else { - STORM_LOG_TRACE("Trace formula is satisfiable."); - std::cout << interpolatingSolver.getModelAsValuation().toString(true) << std::endl; + STORM_LOG_TRACE("Trace formula is satisfiable, not using interpolation."); } return boost::none; @@ -437,17 +458,28 @@ namespace storm { // Now that we have the pivot state candidates, we need to pick one. PivotStateResult pivotStateResult = pickPivotState(game.getInitialStates(), pivotStateCandidatesResult.reachableTransitionsMin, pivotStateCandidatesResult.reachableTransitionsMax, game.getRowVariables(), game.getColumnVariables(), pivotStateCandidatesResult.pivotStates); - boost::optional> interpolationPredicates = derivePredicatesFromInterpolation(game, pivotStateResult, minPlayer1Strategy, minPlayer2Strategy, maxPlayer1Strategy, maxPlayer2Strategy); - if (interpolationPredicates) { - std::cout << "Got interpolation predicates!" << std::endl; - for (auto const& pred : interpolationPredicates.get()) { - std::cout << "pred: " << pred << std::endl; - } +// pivotStateResult.pivotState.template toAdd().exportToDot("pivot__" + std::to_string(cnt) + ".dot"); +// (pivotStateResult.pivotState && minPlayer1Strategy).template toAdd().exportToDot("pivotmin_pl1__" + std::to_string(cnt) + ".dot"); +// (pivotStateResult.pivotState && minPlayer1Strategy && minPlayer2Strategy).template toAdd().exportToDot("pivotmin_pl1pl2__" + std::to_string(cnt) + ".dot"); +// ((pivotStateResult.pivotState && minPlayer1Strategy && minPlayer2Strategy).template toAdd() * game.getExtendedTransitionMatrix()).exportToDot("pivotmin_succ__" + std::to_string(cnt) + ".dot"); +// (pivotStateResult.pivotState && maxPlayer1Strategy).template toAdd().exportToDot("pivotmax_pl1__" + std::to_string(cnt) + ".dot"); +// (pivotStateResult.pivotState && maxPlayer1Strategy && maxPlayer2Strategy).template toAdd().exportToDot("pivotmax_pl1pl2__" + std::to_string(cnt) + ".dot"); +// ((pivotStateResult.pivotState && maxPlayer1Strategy && maxPlayer2Strategy).template toAdd() * game.getExtendedTransitionMatrix()).exportToDot("pivotmax_succ__" + std::to_string(cnt) + ".dot"); +// ++cnt; + + boost::optional predicates; + if (useInterpolation) { + predicates = derivePredicatesFromInterpolation(game, pivotStateResult, minPlayer1Strategy, minPlayer2Strategy, maxPlayer1Strategy, maxPlayer2Strategy); + } + if (predicates) { + STORM_LOG_TRACE("Obtained predicates by interpolation."); + } else { + predicates = derivePredicatesFromPivotState(game, pivotStateResult.pivotState, minPlayer1Strategy, minPlayer2Strategy, maxPlayer1Strategy, maxPlayer2Strategy); } + STORM_LOG_THROW(static_cast(predicates), storm::exceptions::InvalidStateException, "Predicates needed to continue."); // Derive predicate based on the selected pivot state. - RefinementPredicates predicates = derivePredicatesFromPivotState(game, pivotStateResult.pivotState, minPlayer1Strategy, minPlayer2Strategy, maxPlayer1Strategy, maxPlayer2Strategy); - std::vector preparedPredicates = preprocessPredicates(predicates.getPredicates(), (predicates.getSource() == RefinementPredicates::Source::Guard && splitGuards) || (predicates.getSource() == RefinementPredicates::Source::WeakestPrecondition && splitPredicates)); + std::vector preparedPredicates = preprocessPredicates(predicates.get().getPredicates(), predicates.get().getSource()); performRefinement(createGlobalRefinement(preparedPredicates)); return true; } @@ -469,23 +501,29 @@ namespace storm { // Now that we have the pivot state candidates, we need to pick one. PivotStateResult pivotStateResult = pickPivotState(game.getInitialStates(), pivotStateCandidatesResult.reachableTransitionsMin, pivotStateCandidatesResult.reachableTransitionsMax, game.getRowVariables(), game.getColumnVariables(), pivotStateCandidatesResult.pivotStates); - boost::optional> interpolationPredicates = derivePredicatesFromInterpolation(game, pivotStateResult, minPlayer1Strategy, minPlayer2Strategy, maxPlayer1Strategy, maxPlayer2Strategy); - if (interpolationPredicates) { - std::cout << "Got interpolation predicates!" << std::endl; - for (auto const& pred : interpolationPredicates.get()) { - std::cout << "pred: " << pred << std::endl; - } + boost::optional predicates; + if (useInterpolation) { + predicates = derivePredicatesFromInterpolation(game, pivotStateResult, minPlayer1Strategy, minPlayer2Strategy, maxPlayer1Strategy, maxPlayer2Strategy); } + if (predicates) { + STORM_LOG_TRACE("Obtained predicates by interpolation."); + } else { + predicates = derivePredicatesFromPivotState(game, pivotStateResult.pivotState, minPlayer1Strategy, minPlayer2Strategy, maxPlayer1Strategy, maxPlayer2Strategy); + } + STORM_LOG_THROW(static_cast(predicates), storm::exceptions::InvalidStateException, "Predicates needed to continue."); - // Derive predicate based on the selected pivot state. - RefinementPredicates predicates = derivePredicatesFromPivotState(game, pivotStateResult.pivotState, minPlayer1Strategy, minPlayer2Strategy, maxPlayer1Strategy, maxPlayer2Strategy); - std::vector preparedPredicates = preprocessPredicates(predicates.getPredicates(), (predicates.getSource() == RefinementPredicates::Source::Guard && splitGuards) || (predicates.getSource() == RefinementPredicates::Source::WeakestPrecondition && splitPredicates)); + std::vector preparedPredicates = preprocessPredicates(predicates.get().getPredicates(), predicates.get().getSource()); performRefinement(createGlobalRefinement(preparedPredicates)); return true; } template - std::vector MenuGameRefiner::preprocessPredicates(std::vector const& predicates, bool split) const { + std::vector MenuGameRefiner::preprocessPredicates(std::vector const& predicates, RefinementPredicates::Source const& source) const { + bool split = source == RefinementPredicates::Source::Guard && splitGuards; + split |= source == RefinementPredicates::Source::WeakestPrecondition && splitPredicates; + split |= source == RefinementPredicates::Source::Interpolation && splitPredicates; + split |= splitAll; + if (split) { AbstractionInformation const& abstractionInformation = abstractor.get().getAbstractionInformation(); std::vector cleanedAtoms; @@ -539,6 +577,11 @@ namespace storm { for (auto const& command : refinementCommands) { abstractor.get().refine(command); } + + STORM_LOG_TRACE("Current set of predicates:"); + for (auto const& predicate : abstractor.get().getAbstractionInformation().getPredicates()) { + STORM_LOG_TRACE(predicate); + } } template class MenuGameRefiner; diff --git a/src/storm/abstraction/MenuGameRefiner.h b/src/storm/abstraction/MenuGameRefiner.h index 3260e254e..84745aa4a 100644 --- a/src/storm/abstraction/MenuGameRefiner.h +++ b/src/storm/abstraction/MenuGameRefiner.h @@ -30,13 +30,15 @@ namespace storm { class RefinementPredicates { public: enum class Source { - WeakestPrecondition, Guard, Interpolation + WeakestPrecondition, InitialGuard, Guard, Interpolation }; + RefinementPredicates() = default; RefinementPredicates(Source const& source, std::vector const& predicates); Source getSource() const; std::vector const& getPredicates() const; + void addPredicates(std::vector const& newPredicates); private: Source source; @@ -85,14 +87,14 @@ namespace storm { /*! * Preprocesses the predicates. */ - std::vector preprocessPredicates(std::vector const& predicates, bool split) const; + std::vector preprocessPredicates(std::vector const& predicates, RefinementPredicates::Source const& source) const; /*! * Creates a set of refinement commands that amounts to splitting all player 1 choices with the given set of predicates. */ std::vector createGlobalRefinement(std::vector const& predicates) const; - boost::optional> derivePredicatesFromInterpolation(storm::abstraction::MenuGame const& game, PivotStateResult const& pivotStateResult, storm::dd::Bdd const& minPlayer1Strategy, storm::dd::Bdd const& minPlayer2Strategy, storm::dd::Bdd const& maxPlayer1Strategy, storm::dd::Bdd const& maxPlayer2Strategy) const; + boost::optional derivePredicatesFromInterpolation(storm::abstraction::MenuGame const& game, PivotStateResult const& pivotStateResult, storm::dd::Bdd const& minPlayer1Strategy, storm::dd::Bdd const& minPlayer2Strategy, storm::dd::Bdd const& maxPlayer1Strategy, storm::dd::Bdd const& maxPlayer2Strategy) const; std::vector> buildTrace(storm::expressions::ExpressionManager& expressionManager, storm::abstraction::MenuGame const& game, storm::dd::Bdd const& spanningTree, storm::dd::Bdd const& pivotState) const; void performRefinement(std::vector const& refinementCommands) const; @@ -100,11 +102,20 @@ namespace storm { /// The underlying abstractor to refine. std::reference_wrapper> abstractor; - /// A flag indicating whether predicates shall be split before using them for refinement. + /// A flag indicating whether interpolation shall be used to rule out spurious pivot blocks. + bool useInterpolation; + + /// A flag indicating whether all predicates shall be split before using them for refinement. + bool splitAll; + + /// A flag indicating whether predicates derived from weakest preconditions shall be split before using them for refinement. bool splitPredicates; - /// A flag indicating whether predicates shall be split before using them for refinement. + /// A flag indicating whether guards shall be split before using them for refinement. bool splitGuards; + + /// A flag indicating whether the initially added guards shall be split before using them for refinement. + bool splitInitialGuards; /// An object that can be used for splitting predicates. mutable storm::expressions::PredicateSplitter splitter; diff --git a/src/storm/modelchecker/abstraction/GameBasedMdpModelChecker.cpp b/src/storm/modelchecker/abstraction/GameBasedMdpModelChecker.cpp index dedd850a9..04c4ac82a 100644 --- a/src/storm/modelchecker/abstraction/GameBasedMdpModelChecker.cpp +++ b/src/storm/modelchecker/abstraction/GameBasedMdpModelChecker.cpp @@ -304,7 +304,7 @@ namespace storm { } // #ifdef LOCAL_DEBUG - // abstractor.exportToDot("game" + std::to_string(iterations) + ".dot", targetStates, game.getManager().getBddOne()); + abstractor.exportToDot("game" + std::to_string(iterations) + ".dot", targetStates, game.getManager().getBddOne()); // #endif // (3) compute all states with probability 0/1 wrt. to the two different player 2 goals (min/max). diff --git a/src/storm/settings/modules/AbstractionSettings.cpp b/src/storm/settings/modules/AbstractionSettings.cpp index 84299e260..7f55ffd56 100644 --- a/src/storm/settings/modules/AbstractionSettings.cpp +++ b/src/storm/settings/modules/AbstractionSettings.cpp @@ -12,12 +12,17 @@ namespace storm { const std::string AbstractionSettings::splitPredicatesOptionName = "split-preds"; const std::string AbstractionSettings::splitInitialGuardsOptionName = "split-init-guards"; const std::string AbstractionSettings::splitGuardsOptionName = "split-guards"; + const std::string AbstractionSettings::useInterpolationOptionName = "interpolation"; + const std::string AbstractionSettings::splitInterpolantsOptionName = "split-interpolants"; + const std::string AbstractionSettings::splitAllOptionName = "split-all"; AbstractionSettings::AbstractionSettings() : ModuleSettings(moduleName) { this->addOption(storm::settings::OptionBuilder(moduleName, addAllGuardsOptionName, true, "Sets whether all guards are added as initial predicates.").build()); this->addOption(storm::settings::OptionBuilder(moduleName, splitPredicatesOptionName, true, "Sets whether the predicates are split into atoms before they are added.").build()); this->addOption(storm::settings::OptionBuilder(moduleName, splitInitialGuardsOptionName, true, "Sets whether the initial guards are split into atoms before they are added.").build()); this->addOption(storm::settings::OptionBuilder(moduleName, splitGuardsOptionName, true, "Sets whether the guards are split into atoms before they are added.").build()); + this->addOption(storm::settings::OptionBuilder(moduleName, splitAllOptionName, true, "Sets whether all predicates are split into atoms before they are added.").build()); + this->addOption(storm::settings::OptionBuilder(moduleName, useInterpolationOptionName, true, "Sets whether interpolation is to be used to eliminate spurious pivot blocks.").build()); } bool AbstractionSettings::isAddAllGuardsSet() const { @@ -35,6 +40,15 @@ namespace storm { bool AbstractionSettings::isSplitGuardsSet() const { return this->getOption(splitGuardsOptionName).getHasOptionBeenSet(); } + + bool AbstractionSettings::isSplitAllSet() const { + return this->getOption(splitAllOptionName).getHasOptionBeenSet(); + } + + bool AbstractionSettings::isUseInterpolationSet() const { + return this->getOption(useInterpolationOptionName).getHasOptionBeenSet(); + } + } } } diff --git a/src/storm/settings/modules/AbstractionSettings.h b/src/storm/settings/modules/AbstractionSettings.h index 30c699ac1..35f577cfd 100644 --- a/src/storm/settings/modules/AbstractionSettings.h +++ b/src/storm/settings/modules/AbstractionSettings.h @@ -44,6 +44,20 @@ namespace storm { */ bool isSplitGuardsSet() const; + /*! + * Retrieves whether the option to split all predicates to atoms was set. + * + * @return True iff the option was set. + */ + bool isSplitAllSet() const; + + /*! + * Retrieves whether the option to use interpolation was set. + * + * @return True iff the option was set. + */ + bool isUseInterpolationSet() const; + const static std::string moduleName; private: @@ -51,6 +65,9 @@ namespace storm { const static std::string splitPredicatesOptionName; const static std::string splitInitialGuardsOptionName; const static std::string splitGuardsOptionName; + const static std::string useInterpolationOptionName; + const static std::string splitInterpolantsOptionName; + const static std::string splitAllOptionName; }; }