diff --git a/src/cli/cli.cpp b/src/cli/cli.cpp
index cfc88468b..c9e0aa7e6 100644
--- a/src/cli/cli.cpp
+++ b/src/cli/cli.cpp
@@ -214,27 +214,20 @@ namespace storm {
boost::optional<storm::prism::Program> program;
if (settings.isSymbolicSet()) {
std::string const& programFile = settings.getSymbolicModelFilename();
- program = storm::parser::PrismParser::parse(programFile).simplify().simplify();
-
- program->checkValidity();
+ program = storm::parseProgram(programFile);
}
// Then proceed to parsing the property (if given), since the model we are building may depend on the property.
std::vector<std::shared_ptr<storm::logic::Formula>> formulas;
if (settings.isPropertySet()) {
- storm::parser::FormulaParser formulaParser;
- if (program) {
- formulaParser = storm::parser::FormulaParser(program.get().getManager().getSharedPointer());
- }
+ std::string properties = settings.getProperty();
- // If the given property looks like a file (containing a dot and there exists a file with that name),
- // we try to parse it as a file, otherwise we assume it's a property.
- std::string property = settings.getProperty();
- if (property.find(".") != std::string::npos && std::ifstream(property).good()) {
- formulas = formulaParser.parseFromFile(settings.getProperty());
+ if(program) {
+ formulas = storm::parseFormulasForProgram(properties, program.get());
} else {
- formulas = formulaParser.parseFromString(settings.getProperty());
+ formulas = storm::parseFormulasForExplicit(properties);
}
+
}
if (settings.isSymbolicSet()) {
diff --git a/src/parser/FormulaParser.cpp b/src/parser/FormulaParser.cpp
index 2d3fa0198..082474187 100644
--- a/src/parser/FormulaParser.cpp
+++ b/src/parser/FormulaParser.cpp
@@ -184,13 +184,13 @@ namespace storm {
return *this;
}
- std::shared_ptr<storm::logic::Formula> FormulaParser::parseSingleFormulaFromString(std::string const& formulaString) {
+ std::shared_ptr<storm::logic::Formula> FormulaParser::parseSingleFormulaFromString(std::string const& formulaString) const {
std::vector<std::shared_ptr<storm::logic::Formula>> formulas = parseFromString(formulaString);
STORM_LOG_THROW(formulas.size() == 1, storm::exceptions::WrongFormatException, "Expected exactly one formula, but found " << formulas.size() << " instead.");
return formulas.front();
}
- std::vector<std::shared_ptr<storm::logic::Formula>> FormulaParser::parseFromFile(std::string const& filename) {
+ std::vector<std::shared_ptr<storm::logic::Formula>> FormulaParser::parseFromFile(std::string const& filename) const {
// Open file and initialize result.
std::ifstream inputFileStream(filename, std::ios::in);
STORM_LOG_THROW(inputFileStream.good(), storm::exceptions::WrongFormatException, "Unable to read from file '" << filename << "'.");
@@ -212,7 +212,7 @@ namespace storm {
return formulas;
}
- std::vector<std::shared_ptr<storm::logic::Formula>> FormulaParser::parseFromString(std::string const& formulaString) {
+ std::vector<std::shared_ptr<storm::logic::Formula>> FormulaParser::parseFromString(std::string const& formulaString) const {
PositionIteratorType first(formulaString.begin());
PositionIteratorType iter = first;
PositionIteratorType last(formulaString.end());
diff --git a/src/parser/FormulaParser.h b/src/parser/FormulaParser.h
index 895d84cd5..25dc6514f 100644
--- a/src/parser/FormulaParser.h
+++ b/src/parser/FormulaParser.h
@@ -28,7 +28,7 @@ namespace storm {
* @param formulaString The formula as a string.
* @return The resulting formula.
*/
- std::shared_ptr<storm::logic::Formula> parseSingleFormulaFromString(std::string const& formulaString);
+ std::shared_ptr<storm::logic::Formula> parseSingleFormulaFromString(std::string const& formulaString) const;
/*!
* Parses the formula given by the provided string.
@@ -36,7 +36,7 @@ namespace storm {
* @param formulaString The formula as a string.
* @return The contained formulas.
*/
- std::vector<std::shared_ptr<storm::logic::Formula>> parseFromString(std::string const& formulaString);
+ std::vector<std::shared_ptr<storm::logic::Formula>> parseFromString(std::string const& formulaString) const;
/*!
* Parses the formulas in the given file.
@@ -44,7 +44,7 @@ namespace storm {
* @param filename The name of the file to parse.
* @return The contained formulas.
*/
- std::vector<std::shared_ptr<storm::logic::Formula>> parseFromFile(std::string const& filename);
+ std::vector<std::shared_ptr<storm::logic::Formula>> parseFromFile(std::string const& filename) const;
/*!
* Adds an identifier and the expression it is supposed to be replaced with. This can, for example be used
diff --git a/src/utility/storm.cpp b/src/utility/storm.cpp
new file mode 100644
index 000000000..49ca3e48a
--- /dev/null
+++ b/src/utility/storm.cpp
@@ -0,0 +1,41 @@
+#include "storm.h"
+
+// Headers related to parsing.
+#include "src/parser/PrismParser.h"
+#include "src/parser/FormulaParser.h"
+
+
+
+namespace storm {
+
+ storm::prism::Program parseProgram(std::string const& path) {
+ storm::prism::Program program= storm::parser::PrismParser::parse(path).simplify().simplify();
+ program.checkValidity();
+ return program;
+ }
+
+ /**
+ * Helper
+ * @param FormulaParser
+ * @return The formulas.
+ */
+ std::vector<std::shared_ptr<storm::logic::Formula>> parseFormulas(storm::parser::FormulaParser & formulaParser, std::string const& inputString) {
+ // If the given property looks like a file (containing a dot and there exists a file with that name),
+ // we try to parse it as a file, otherwise we assume it's a property.
+ if (inputString.find(".") != std::string::npos && std::ifstream(inputString).good()) {
+ return formulaParser.parseFromFile(inputString);
+ } else {
+ return formulaParser.parseFromString(inputString);
+ }
+ }
+
+ std::vector<std::shared_ptr<storm::logic::Formula>> parseFormulasForExplicit(std::string const& inputString) {
+ storm::parser::FormulaParser formulaParser;
+ return parseFormulas(formulaParser, inputString);
+ }
+
+ std::vector<std::shared_ptr<storm::logic::Formula>> parseFormulasForProgram(std::string const& inputString, storm::prism::Program const& program) {
+ storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer());
+ return parseFormulas(formulaParser, inputString);
+ }
+}
\ No newline at end of file
diff --git a/src/utility/storm.h b/src/utility/storm.h
index 34cf1122c..7fa547588 100644
--- a/src/utility/storm.h
+++ b/src/utility/storm.h
@@ -22,10 +22,6 @@
#include "src/settings/modules/BisimulationSettings.h"
#include "src/settings/modules/ParametricSettings.h"
-// Headers related to parsing.
-#include "src/parser/AutoParser.h"
-#include "src/parser/PrismParser.h"
-#include "src/parser/FormulaParser.h"
// Formula headers.
#include "src/logic/Formulas.h"
@@ -40,6 +36,8 @@
#include "src/storage/dd/CuddAdd.h"
#include "src/storage/dd/CuddBdd.h"
+#include "src/parser/AutoParser.h"
+
// Headers of builders.
#include "src/builder/ExplicitPrismModelBuilder.h"
#include "src/builder/DdPrismModelBuilder.h"
@@ -72,328 +70,330 @@
#include "src/exceptions/NotImplementedException.h"
namespace storm {
-
- template<typename ValueType>
- std::shared_ptr<storm::models::sparse::Model<ValueType>> buildExplicitModel(std::string const& transitionsFile, std::string const& labelingFile, boost::optional<std::string> const& stateRewardsFile = boost::optional<std::string>(), boost::optional<std::string> const& transitionRewardsFile = boost::optional<std::string>(), boost::optional<std::string> const& choiceLabelingFile = boost::optional<std::string>()) {
- return storm::parser::AutoParser<>::parseModel(transitionsFile, labelingFile, stateRewardsFile ? stateRewardsFile.get() : "", transitionRewardsFile ? transitionRewardsFile.get() : "", choiceLabelingFile ? choiceLabelingFile.get() : "" );
- }
+ template<typename ValueType>
+ std::shared_ptr<storm::models::sparse::Model<ValueType>> buildExplicitModel(std::string const& transitionsFile, std::string const& labelingFile, boost::optional<std::string> const& stateRewardsFile = boost::optional<std::string>(), boost::optional<std::string> const& transitionRewardsFile = boost::optional<std::string>(), boost::optional<std::string> const& choiceLabelingFile = boost::optional<std::string>()) {
+ return storm::parser::AutoParser<>::parseModel(transitionsFile, labelingFile, stateRewardsFile ? stateRewardsFile.get() : "", transitionRewardsFile ? transitionRewardsFile.get() : "", choiceLabelingFile ? choiceLabelingFile.get() : "" );
+ }
- template<typename ValueType>
- std::shared_ptr<storm::models::ModelBase> buildSymbolicModel(storm::prism::Program const& program, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
- std::shared_ptr<storm::models::ModelBase> result(nullptr);
-
- storm::settings::modules::GeneralSettings settings = storm::settings::generalSettings();
-
- // Get the string that assigns values to the unknown currently undefined constants in the model.
- std::string constants = settings.getConstantDefinitionString();
-
- // Customize and perform model-building.
- if (settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::Sparse) {
- typename storm::builder::ExplicitPrismModelBuilder<ValueType>::Options options;
- options = typename storm::builder::ExplicitPrismModelBuilder<ValueType>::Options(formulas);
- options.addConstantDefinitionsFromString(program, settings.getConstantDefinitionString());
-
- // Generate command labels if we are going to build a counterexample later.
- if (storm::settings::counterexampleGeneratorSettings().isMinimalCommandSetGenerationSet()) {
- options.buildCommandLabels = true;
- }
-
- result = storm::builder::ExplicitPrismModelBuilder<ValueType>::translateProgram(program, options);
- } else if (settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::Dd || settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
- typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options;
- options = typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options(formulas);
- options.addConstantDefinitionsFromString(program, settings.getConstantDefinitionString());
-
- result = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::translateProgram(program, options);
- }
-
- // Then, build the model from the symbolic description.
- return result;
+ storm::prism::Program parseProgram(std::string const& path);
+ std::vector<std::shared_ptr<storm::logic::Formula>> parseFormulasForExplicit(std::string const& inputString);
+ std::vector<std::shared_ptr<storm::logic::Formula>> parseFormulasForProgram(std::string const& inputString, storm::prism::Program const& program);
+
+
+
+ template<typename ValueType>
+ std::shared_ptr<storm::models::ModelBase> buildSymbolicModel(storm::prism::Program const& program, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
+ std::shared_ptr<storm::models::ModelBase> result(nullptr);
+
+ storm::settings::modules::GeneralSettings settings = storm::settings::generalSettings();
+
+ // Get the string that assigns values to the unknown currently undefined constants in the model.
+ std::string constants = settings.getConstantDefinitionString();
+
+ // Customize and perform model-building.
+ if (settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::Sparse) {
+ typename storm::builder::ExplicitPrismModelBuilder<ValueType>::Options options;
+ options = typename storm::builder::ExplicitPrismModelBuilder<ValueType>::Options(formulas);
+ options.addConstantDefinitionsFromString(program, constants);
+
+ // Generate command labels if we are going to build a counterexample later.
+ if (storm::settings::counterexampleGeneratorSettings().isMinimalCommandSetGenerationSet()) {
+ options.buildCommandLabels = true;
}
+
+ result = storm::builder::ExplicitPrismModelBuilder<ValueType>::translateProgram(program, options);
+ } else if (settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::Dd || settings.getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
+ typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options;
+ options = typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options(formulas);
+ options.addConstantDefinitionsFromString(program, constants);
+
+ result = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::translateProgram(program, options);
+ }
+
+ // Then, build the model from the symbolic description.
+ return result;
+ }
- template<typename ValueType>
- std::shared_ptr<storm::models::ModelBase> preprocessModel(std::shared_ptr<storm::models::ModelBase> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
- if (storm::settings::generalSettings().isBisimulationSet()) {
- STORM_LOG_THROW(model->isSparseModel(), storm::exceptions::InvalidSettingsException, "Bisimulation minimization is currently only available for sparse models.");
- std::shared_ptr<storm::models::sparse::Model<ValueType>> sparseModel = model->template as<storm::models::sparse::Model<ValueType>>();
- STORM_LOG_THROW(model->getType() == storm::models::ModelType::Dtmc || model->getType() == storm::models::ModelType::Ctmc, storm::exceptions::InvalidSettingsException, "Bisimulation minimization is currently only available for DTMCs.");
- std::shared_ptr<storm::models::sparse::Dtmc<ValueType>> dtmc = sparseModel->template as<storm::models::sparse::Dtmc<ValueType>>();
-
- dtmc->reduceToStateBasedRewards();
-
- std::cout << "Performing bisimulation minimization... ";
- typename storm::storage::DeterministicModelBisimulationDecomposition<ValueType>::Options options;
- if (!formulas.empty()) {
- options = typename storm::storage::DeterministicModelBisimulationDecomposition<ValueType>::Options(*sparseModel, formulas);
- }
- if (storm::settings::bisimulationSettings().isWeakBisimulationSet()) {
- options.weak = true;
- options.bounded = false;
- }
-
- storm::storage::DeterministicModelBisimulationDecomposition<ValueType> bisimulationDecomposition(*dtmc, options);
- model = bisimulationDecomposition.getQuotient();
- std::cout << "done." << std::endl << std::endl;
- }
- return model;
+ template<typename ValueType>
+ std::shared_ptr<storm::models::ModelBase> preprocessModel(std::shared_ptr<storm::models::ModelBase> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
+ if (storm::settings::generalSettings().isBisimulationSet()) {
+ STORM_LOG_THROW(model->isSparseModel(), storm::exceptions::InvalidSettingsException, "Bisimulation minimization is currently only available for sparse models.");
+ std::shared_ptr<storm::models::sparse::Model<ValueType>> sparseModel = model->template as<storm::models::sparse::Model<ValueType>>();
+ STORM_LOG_THROW(model->getType() == storm::models::ModelType::Dtmc || model->getType() == storm::models::ModelType::Ctmc, storm::exceptions::InvalidSettingsException, "Bisimulation minimization is currently only available for DTMCs.");
+ std::shared_ptr<storm::models::sparse::Dtmc<ValueType>> dtmc = sparseModel->template as<storm::models::sparse::Dtmc<ValueType>>();
+
+ dtmc->reduceToStateBasedRewards();
+
+ std::cout << "Performing bisimulation minimization... ";
+ typename storm::storage::DeterministicModelBisimulationDecomposition<ValueType>::Options options;
+ if (!formulas.empty()) {
+ options = typename storm::storage::DeterministicModelBisimulationDecomposition<ValueType>::Options(*sparseModel, formulas);
}
+ if (storm::settings::bisimulationSettings().isWeakBisimulationSet()) {
+ options.weak = true;
+ options.bounded = false;
+ }
+
+ storm::storage::DeterministicModelBisimulationDecomposition<ValueType> bisimulationDecomposition(*dtmc, options);
+ model = bisimulationDecomposition.getQuotient();
+ std::cout << "done." << std::endl << std::endl;
+ }
+ return model;
+ }
- template<typename ValueType>
- void generateCounterexample(storm::prism::Program const& program, std::shared_ptr<storm::models::sparse::Model<ValueType>> model, std::shared_ptr<storm::logic::Formula> const& formula) {
- if (storm::settings::counterexampleGeneratorSettings().isMinimalCommandSetGenerationSet()) {
- STORM_LOG_THROW(model->getType() == storm::models::ModelType::Mdp, storm::exceptions::InvalidTypeException, "Minimal command set generation is only available for MDPs.");
- STORM_LOG_THROW(storm::settings::generalSettings().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "Minimal command set generation is only available for symbolic models.");
-
- std::shared_ptr<storm::models::sparse::Mdp<ValueType>> mdp = model->template as<storm::models::sparse::Mdp<ValueType>>();
-
- // Determine whether we are required to use the MILP-version or the SAT-version.
- bool useMILP = storm::settings::counterexampleGeneratorSettings().isUseMilpBasedMinimalCommandSetGenerationSet();
-
- if (useMILP) {
- storm::counterexamples::MILPMinimalLabelSetGenerator<ValueType>::computeCounterexample(program, *mdp, formula);
- } else {
- storm::counterexamples::SMTMinimalCommandSetGenerator<ValueType>::computeCounterexample(program, storm::settings::generalSettings().getConstantDefinitionString(), *mdp, formula);
- }
-
- } else {
- STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "No suitable counterexample representation selected.");
- }
+ template<typename ValueType>
+ void generateCounterexample(storm::prism::Program const& program, std::shared_ptr<storm::models::sparse::Model<ValueType>> model, std::shared_ptr<storm::logic::Formula> const& formula) {
+ if (storm::settings::counterexampleGeneratorSettings().isMinimalCommandSetGenerationSet()) {
+ STORM_LOG_THROW(model->getType() == storm::models::ModelType::Mdp, storm::exceptions::InvalidTypeException, "Minimal command set generation is only available for MDPs.");
+ STORM_LOG_THROW(storm::settings::generalSettings().isSymbolicSet(), storm::exceptions::InvalidSettingsException, "Minimal command set generation is only available for symbolic models.");
+
+ std::shared_ptr<storm::models::sparse::Mdp<ValueType>> mdp = model->template as<storm::models::sparse::Mdp<ValueType>>();
+
+ // Determine whether we are required to use the MILP-version or the SAT-version.
+ bool useMILP = storm::settings::counterexampleGeneratorSettings().isUseMilpBasedMinimalCommandSetGenerationSet();
+
+ if (useMILP) {
+ storm::counterexamples::MILPMinimalLabelSetGenerator<ValueType>::computeCounterexample(program, *mdp, formula);
+ } else {
+ storm::counterexamples::SMTMinimalCommandSetGenerator<ValueType>::computeCounterexample(program, storm::settings::generalSettings().getConstantDefinitionString(), *mdp, formula);
}
+
+ } else {
+ STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "No suitable counterexample representation selected.");
+ }
+ }
#ifdef STORM_HAVE_CARL
- template<>
- inline void generateCounterexample(storm::prism::Program const& program, std::shared_ptr<storm::models::sparse::Model<storm::RationalFunction>> model, std::shared_ptr<storm::logic::Formula> const& formula) {
- STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Unable to generate counterexample for parametric model.");
- }
+ template<>
+ inline void generateCounterexample(storm::prism::Program const& program, std::shared_ptr<storm::models::sparse::Model<storm::RationalFunction>> model, std::shared_ptr<storm::logic::Formula> const& formula) {
+ STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Unable to generate counterexample for parametric model.");
+ }
#endif
- template<typename ValueType>
- void verifySparseModel(boost::optional<storm::prism::Program> const& program, std::shared_ptr<storm::models::sparse::Model<ValueType>> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
- storm::settings::modules::GeneralSettings const& settings = storm::settings::generalSettings();
-
- for (auto const& formula : formulas) {
- // If we were requested to generate a counterexample, we now do so.
- if (settings.isCounterexampleSet()) {
- STORM_LOG_THROW(program, storm::exceptions::InvalidSettingsException, "Unable to generate counterexample for non-symbolic model.");
- generateCounterexample<ValueType>(program.get(), model, formula);
- } else {
- std::cout << std::endl << "Model checking property: " << *formula << " ...";
- std::unique_ptr<storm::modelchecker::CheckResult> result;
- if (model->getType() == storm::models::ModelType::Dtmc) {
- std::shared_ptr<storm::models::sparse::Dtmc<ValueType>> dtmc = model->template as<storm::models::sparse::Dtmc<ValueType>>();
- storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ValueType>> modelchecker(*dtmc);
- if (modelchecker.canHandle(*formula)) {
- result = modelchecker.check(*formula);
- } else {
- storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<ValueType>> modelchecker2(*dtmc);
- if (modelchecker2.canHandle(*formula)) {
- result = modelchecker2.check(*formula);
- }
- }
- } else if (model->getType() == storm::models::ModelType::Mdp) {
- std::shared_ptr<storm::models::sparse::Mdp<ValueType>> mdp = model->template as<storm::models::sparse::Mdp<ValueType>>();
+ template<typename ValueType>
+ void verifySparseModel(std::shared_ptr<storm::models::sparse::Model<ValueType>> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
+ for (auto const& formula : formulas) {
+
+ std::cout << std::endl << "Model checking property: " << *formula << " ...";
+ std::unique_ptr<storm::modelchecker::CheckResult> result;
+ if (model->getType() == storm::models::ModelType::Dtmc) {
+ std::shared_ptr<storm::models::sparse::Dtmc<ValueType>> dtmc = model->template as<storm::models::sparse::Dtmc<ValueType>>();
+ storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ValueType>> modelchecker(*dtmc);
+ if (modelchecker.canHandle(*formula)) {
+ result = modelchecker.check(*formula);
+ } else {
+ storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<ValueType>> modelchecker2(*dtmc);
+ if (modelchecker2.canHandle(*formula)) {
+ result = modelchecker2.check(*formula);
+ }
+ }
+ } else if (model->getType() == storm::models::ModelType::Mdp) {
+ std::shared_ptr<storm::models::sparse::Mdp<ValueType>> mdp = model->template as<storm::models::sparse::Mdp<ValueType>>();
#ifdef STORM_HAVE_CUDA
- if (settings.isCudaSet()) {
- storm::modelchecker::TopologicalValueIterationMdpPrctlModelChecker<ValueType> modelchecker(*mdp);
- result = modelchecker.check(*formula);
- } else {
- storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ValueType>> modelchecker(*mdp);
- result = modelchecker.check(*formula);
- }
+ if (settings.isCudaSet()) {
+ storm::modelchecker::TopologicalValueIterationMdpPrctlModelChecker<ValueType> modelchecker(*mdp);
+ result = modelchecker.check(*formula);
+ } else {
+ storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ValueType>> modelchecker(*mdp);
+ result = modelchecker.check(*formula);
+ }
#else
- storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ValueType>> modelchecker(*mdp);
- result = modelchecker.check(*formula);
+ storm::modelchecker::SparseMdpPrctlModelChecker<storm::models::sparse::Mdp<ValueType>> modelchecker(*mdp);
+ result = modelchecker.check(*formula);
#endif
- } else if (model->getType() == storm::models::ModelType::Ctmc) {
- std::shared_ptr<storm::models::sparse::Ctmc<ValueType>> ctmc = model->template as<storm::models::sparse::Ctmc<ValueType>>();
-
- storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<ValueType>> modelchecker(*ctmc);
- result = modelchecker.check(*formula);
- }
-
- if (result) {
- std::cout << " done." << std::endl;
- std::cout << "Result (initial states): ";
- result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
- std::cout << *result << std::endl;
- } else {
- std::cout << " skipped, because the modelling formalism is currently unsupported." << std::endl;
- }
- }
- }
+ } else if (model->getType() == storm::models::ModelType::Ctmc) {
+ std::shared_ptr<storm::models::sparse::Ctmc<ValueType>> ctmc = model->template as<storm::models::sparse::Ctmc<ValueType>>();
+
+ storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<ValueType>> modelchecker(*ctmc);
+ result = modelchecker.check(*formula);
+ }
+
+ if (result) {
+ std::cout << " done." << std::endl;
+ std::cout << "Result (initial states): ";
+ result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
+ std::cout << *result << std::endl;
+ } else {
+ std::cout << " skipped, because the modelling formalism is currently unsupported." << std::endl;
}
+ }
+ }
#ifdef STORM_HAVE_CARL
- inline void exportParametricResultToFile(storm::RationalFunction const& result, storm::models::sparse::Dtmc<storm::RationalFunction>::ConstraintCollector const& constraintCollector, std::string const& path) {
- std::ofstream filestream;
- filestream.open(path);
- // TODO: add checks.
- filestream << "!Parameters: ";
- std::set<storm::Variable> vars = result.gatherVariables();
- std::copy(vars.begin(), vars.end(), std::ostream_iterator<storm::Variable>(filestream, ", "));
- filestream << std::endl;
- filestream << "!Result: " << result << std::endl;
- filestream << "!Well-formed Constraints: " << std::endl;
- std::copy(constraintCollector.getWellformedConstraints().begin(), constraintCollector.getWellformedConstraints().end(), std::ostream_iterator<storm::ArithConstraint<storm::RationalFunction>>(filestream, "\n"));
- filestream << "!Graph-preserving Constraints: " << std::endl;
- std::copy(constraintCollector.getGraphPreservingConstraints().begin(), constraintCollector.getGraphPreservingConstraints().end(), std::ostream_iterator<storm::ArithConstraint<storm::RationalFunction>>(filestream, "\n"));
- filestream.close();
- }
+ inline void exportParametricResultToFile(storm::RationalFunction const& result, storm::models::sparse::Dtmc<storm::RationalFunction>::ConstraintCollector const& constraintCollector, std::string const& path) {
+ std::ofstream filestream;
+ filestream.open(path);
+ // TODO: add checks.
+ filestream << "!Parameters: ";
+ std::set<storm::Variable> vars = result.gatherVariables();
+ std::copy(vars.begin(), vars.end(), std::ostream_iterator<storm::Variable>(filestream, ", "));
+ filestream << std::endl;
+ filestream << "!Result: " << result << std::endl;
+ filestream << "!Well-formed Constraints: " << std::endl;
+ std::copy(constraintCollector.getWellformedConstraints().begin(), constraintCollector.getWellformedConstraints().end(), std::ostream_iterator<storm::ArithConstraint<storm::RationalFunction>>(filestream, "\n"));
+ filestream << "!Graph-preserving Constraints: " << std::endl;
+ std::copy(constraintCollector.getGraphPreservingConstraints().begin(), constraintCollector.getGraphPreservingConstraints().end(), std::ostream_iterator<storm::ArithConstraint<storm::RationalFunction>>(filestream, "\n"));
+ filestream.close();
+ }
- template<>
- inline void verifySparseModel(boost::optional<storm::prism::Program> const& program, std::shared_ptr<storm::models::sparse::Model<storm::RationalFunction>> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
-
- for (auto const& formula : formulas) {
- STORM_LOG_THROW(model->getType() == storm::models::ModelType::Dtmc, storm::exceptions::InvalidSettingsException, "Currently parametric verification is only available for DTMCs.");
- std::shared_ptr<storm::models::sparse::Dtmc<storm::RationalFunction>> dtmc = model->template as<storm::models::sparse::Dtmc<storm::RationalFunction>>();
-
- std::cout << std::endl << "Model checking property: " << *formula << " ...";
- std::unique_ptr<storm::modelchecker::CheckResult> result;
-
- storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<storm::RationalFunction>> modelchecker(*dtmc);
- if (modelchecker.canHandle(*formula)) {
- result = modelchecker.check(*formula);
- } else {
- STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "The parametric engine currently does not support this property.");
- }
-
- if (result) {
- std::cout << " done." << std::endl;
- std::cout << "Result (initial states): ";
- result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(dtmc->getInitialStates()));
- std::cout << *result << std::endl;
- } else {
- std::cout << " skipped, because the modelling formalism is currently unsupported." << std::endl;
- }
-
- storm::settings::modules::ParametricSettings const& parametricSettings = storm::settings::parametricSettings();
- if (parametricSettings.exportResultToFile()) {
- exportParametricResultToFile(result->asExplicitQuantitativeCheckResult<storm::RationalFunction>()[*dtmc->getInitialStates().begin()], storm::models::sparse::Dtmc<storm::RationalFunction>::ConstraintCollector(*dtmc), parametricSettings.exportResultPath());
- }
- }
+ template<>
+ inline void verifySparseModel(std::shared_ptr<storm::models::sparse::Model<storm::RationalFunction>> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
+
+ for (auto const& formula : formulas) {
+ STORM_LOG_THROW(model->getType() == storm::models::ModelType::Dtmc, storm::exceptions::InvalidSettingsException, "Currently parametric verification is only available for DTMCs.");
+ std::shared_ptr<storm::models::sparse::Dtmc<storm::RationalFunction>> dtmc = model->template as<storm::models::sparse::Dtmc<storm::RationalFunction>>();
+
+ std::cout << std::endl << "Model checking property: " << *formula << " ...";
+ std::unique_ptr<storm::modelchecker::CheckResult> result;
+
+ storm::modelchecker::SparseDtmcEliminationModelChecker<storm::models::sparse::Dtmc<storm::RationalFunction>> modelchecker(*dtmc);
+ if (modelchecker.canHandle(*formula)) {
+ result = modelchecker.check(*formula);
+ } else {
+ STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "The parametric engine currently does not support this property.");
+ }
+
+ if (result) {
+ std::cout << " done." << std::endl;
+ std::cout << "Result (initial states): ";
+ result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(dtmc->getInitialStates()));
+ std::cout << *result << std::endl;
+ } else {
+ std::cout << " skipped, because the modelling formalism is currently unsupported." << std::endl;
+ }
+
+ storm::settings::modules::ParametricSettings const& parametricSettings = storm::settings::parametricSettings();
+ if (parametricSettings.exportResultToFile()) {
+ exportParametricResultToFile(result->asExplicitQuantitativeCheckResult<storm::RationalFunction>()[*dtmc->getInitialStates().begin()], storm::models::sparse::Dtmc<storm::RationalFunction>::ConstraintCollector(*dtmc), parametricSettings.exportResultPath());
}
+ }
+ }
#endif
- template<storm::dd::DdType DdType>
- void verifySymbolicModelWithHybridEngine(boost::optional<storm::prism::Program> const& program, std::shared_ptr<storm::models::symbolic::Model<DdType>> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
- for (auto const& formula : formulas) {
- std::cout << std::endl << "Model checking property: " << *formula << " ...";
- std::unique_ptr<storm::modelchecker::CheckResult> result;
- if (model->getType() == storm::models::ModelType::Dtmc) {
- std::shared_ptr<storm::models::symbolic::Dtmc<DdType>> dtmc = model->template as<storm::models::symbolic::Dtmc<DdType>>();
- storm::modelchecker::HybridDtmcPrctlModelChecker<DdType, double> modelchecker(*dtmc);
- if (modelchecker.canHandle(*formula)) {
- result = modelchecker.check(*formula);
- }
- } else if (model->getType() == storm::models::ModelType::Ctmc) {
- std::shared_ptr<storm::models::symbolic::Ctmc<DdType>> ctmc = model->template as<storm::models::symbolic::Ctmc<DdType>>();
- storm::modelchecker::HybridCtmcCslModelChecker<DdType, double> modelchecker(*ctmc);
- if (modelchecker.canHandle(*formula)) {
- result = modelchecker.check(*formula);
- }
- } else if (model->getType() == storm::models::ModelType::Mdp) {
- std::shared_ptr<storm::models::symbolic::Mdp<DdType>> mdp = model->template as<storm::models::symbolic::Mdp<DdType>>();
- storm::modelchecker::HybridMdpPrctlModelChecker<DdType, double> modelchecker(*mdp);
- if (modelchecker.canHandle(*formula)) {
- result = modelchecker.check(*formula);
- }
- } else {
- STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "This functionality is not yet implemented.");
- }
-
- if (result) {
- std::cout << " done." << std::endl;
- std::cout << "Result (initial states): ";
- result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<DdType>(model->getReachableStates(), model->getInitialStates()));
- std::cout << *result << std::endl;
- } else {
- std::cout << " skipped, because the modelling formalism is currently unsupported." << std::endl;
- }
+ template<storm::dd::DdType DdType>
+ void verifySymbolicModelWithHybridEngine(std::shared_ptr<storm::models::symbolic::Model<DdType>> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
+ for (auto const& formula : formulas) {
+ std::cout << std::endl << "Model checking property: " << *formula << " ...";
+ std::unique_ptr<storm::modelchecker::CheckResult> result;
+ if (model->getType() == storm::models::ModelType::Dtmc) {
+ std::shared_ptr<storm::models::symbolic::Dtmc<DdType>> dtmc = model->template as<storm::models::symbolic::Dtmc<DdType>>();
+ storm::modelchecker::HybridDtmcPrctlModelChecker<DdType, double> modelchecker(*dtmc);
+ if (modelchecker.canHandle(*formula)) {
+ result = modelchecker.check(*formula);
+ }
+ } else if (model->getType() == storm::models::ModelType::Ctmc) {
+ std::shared_ptr<storm::models::symbolic::Ctmc<DdType>> ctmc = model->template as<storm::models::symbolic::Ctmc<DdType>>();
+ storm::modelchecker::HybridCtmcCslModelChecker<DdType, double> modelchecker(*ctmc);
+ if (modelchecker.canHandle(*formula)) {
+ result = modelchecker.check(*formula);
+ }
+ } else if (model->getType() == storm::models::ModelType::Mdp) {
+ std::shared_ptr<storm::models::symbolic::Mdp<DdType>> mdp = model->template as<storm::models::symbolic::Mdp<DdType>>();
+ storm::modelchecker::HybridMdpPrctlModelChecker<DdType, double> modelchecker(*mdp);
+ if (modelchecker.canHandle(*formula)) {
+ result = modelchecker.check(*formula);
}
+ } else {
+ STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "This functionality is not yet implemented.");
}
+
+ if (result) {
+ std::cout << " done." << std::endl;
+ std::cout << "Result (initial states): ";
+ result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<DdType>(model->getReachableStates(), model->getInitialStates()));
+ std::cout << *result << std::endl;
+ } else {
+ std::cout << " skipped, because the modelling formalism is currently unsupported." << std::endl;
+ }
+ }
+ }
- template<storm::dd::DdType DdType>
- void verifySymbolicModelWithSymbolicEngine(boost::optional<storm::prism::Program> const& program, std::shared_ptr<storm::models::symbolic::Model<DdType>> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
- for (auto const& formula : formulas) {
- std::cout << std::endl << "Model checking property: " << *formula << " ...";
- std::unique_ptr<storm::modelchecker::CheckResult> result;
- if (model->getType() == storm::models::ModelType::Dtmc) {
- std::shared_ptr<storm::models::symbolic::Dtmc<DdType>> dtmc = model->template as<storm::models::symbolic::Dtmc<DdType>>();
- storm::modelchecker::SymbolicDtmcPrctlModelChecker<DdType, double> modelchecker(*dtmc);
- if (modelchecker.canHandle(*formula)) {
- result = modelchecker.check(*formula);
- }
- } else if (model->getType() == storm::models::ModelType::Mdp) {
- std::shared_ptr<storm::models::symbolic::Mdp<DdType>> mdp = model->template as<storm::models::symbolic::Mdp<DdType>>();
- storm::modelchecker::SymbolicMdpPrctlModelChecker<DdType, double> modelchecker(*mdp);
- if (modelchecker.canHandle(*formula)) {
- result = modelchecker.check(*formula);
- }
- } else {
- STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "This functionality is not yet implemented.");
- }
-
- if (result) {
- std::cout << " done." << std::endl;
- std::cout << "Result (initial states): ";
- result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<DdType>(model->getReachableStates(), model->getInitialStates()));
- std::cout << *result << std::endl;
- } else {
- std::cout << " skipped, because the modelling formalism is currently unsupported." << std::endl;
- }
+ template<storm::dd::DdType DdType>
+ void verifySymbolicModelWithSymbolicEngine(std::shared_ptr<storm::models::symbolic::Model<DdType>> model, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
+ for (auto const& formula : formulas) {
+ std::cout << std::endl << "Model checking property: " << *formula << " ...";
+ std::unique_ptr<storm::modelchecker::CheckResult> result;
+ if (model->getType() == storm::models::ModelType::Dtmc) {
+ std::shared_ptr<storm::models::symbolic::Dtmc<DdType>> dtmc = model->template as<storm::models::symbolic::Dtmc<DdType>>();
+ storm::modelchecker::SymbolicDtmcPrctlModelChecker<DdType, double> modelchecker(*dtmc);
+ if (modelchecker.canHandle(*formula)) {
+ result = modelchecker.check(*formula);
+ }
+ } else if (model->getType() == storm::models::ModelType::Mdp) {
+ std::shared_ptr<storm::models::symbolic::Mdp<DdType>> mdp = model->template as<storm::models::symbolic::Mdp<DdType>>();
+ storm::modelchecker::SymbolicMdpPrctlModelChecker<DdType, double> modelchecker(*mdp);
+ if (modelchecker.canHandle(*formula)) {
+ result = modelchecker.check(*formula);
}
+ } else {
+ STORM_LOG_THROW(false, storm::exceptions::NotImplementedException, "This functionality is not yet implemented.");
}
+
+ if (result) {
+ std::cout << " done." << std::endl;
+ std::cout << "Result (initial states): ";
+ result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<DdType>(model->getReachableStates(), model->getInitialStates()));
+ std::cout << *result << std::endl;
+ } else {
+ std::cout << " skipped, because the modelling formalism is currently unsupported." << std::endl;
+ }
+ }
+ }
- template<typename ValueType>
- void buildAndCheckSymbolicModel(boost::optional<storm::prism::Program> const& program, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
- // Now we are ready to actually build the model.
- STORM_LOG_THROW(program, storm::exceptions::InvalidStateException, "Program has not been successfully parsed.");
- std::shared_ptr<storm::models::ModelBase> model = buildSymbolicModel<ValueType>(program.get(), formulas);
-
- STORM_LOG_THROW(model != nullptr, storm::exceptions::InvalidStateException, "Model could not be constructed for an unknown reason.");
-
- // Preprocess the model if needed.
- model = preprocessModel<ValueType>(model, formulas);
-
- // Print some information about the model.
- model->printModelInformationToStream(std::cout);
-
- // Verify the model, if a formula was given.
- if (!formulas.empty()) {
- if (model->isSparseModel()) {
- verifySparseModel<ValueType>(program, model->as<storm::models::sparse::Model<ValueType>>(), formulas);
- } else if (model->isSymbolicModel()) {
- if (storm::settings::generalSettings().getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
- verifySymbolicModelWithHybridEngine(program, model->as<storm::models::symbolic::Model<storm::dd::DdType::CUDD>>(), formulas);
- } else {
- verifySymbolicModelWithSymbolicEngine(program, model->as<storm::models::symbolic::Model<storm::dd::DdType::CUDD>>(), formulas);
- }
- } else {
- STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Invalid input model type.");
+
+ template<typename ValueType>
+ void buildAndCheckSymbolicModel(storm::prism::Program const& program, std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
+ std::shared_ptr<storm::models::ModelBase> model = buildSymbolicModel<ValueType>(program, formulas);
+ STORM_LOG_THROW(model != nullptr, storm::exceptions::InvalidStateException, "Model could not be constructed for an unknown reason.");
+
+ // Preprocess the model if needed.
+ model = preprocessModel<ValueType>(model, formulas);
+
+ // Print some information about the model.
+ model->printModelInformationToStream(std::cout);
+
+ // Verify the model, if a formula was given.
+ if (!formulas.empty()) {
+ if (model->isSparseModel()) {
+ if(storm::settings::generalSettings().isCounterexampleSet()) {
+ // If we were requested to generate a counterexample, we now do so for each formula.
+ for(auto const& formula : formulas) {
+ generateCounterexample<ValueType>(program, model->as<storm::models::sparse::Model<ValueType>>(), formula);
}
+ } else {
+ verifySparseModel<ValueType>(model->as<storm::models::sparse::Model<ValueType>>(), formulas);
}
- }
-
- template<typename ValueType>
- void buildAndCheckExplicitModel(std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
- storm::settings::modules::GeneralSettings const& settings = storm::settings::generalSettings();
-
- STORM_LOG_THROW(settings.isExplicitSet(), storm::exceptions::InvalidStateException, "Unable to build explicit model without model files.");
- std::shared_ptr<storm::models::ModelBase> model = buildExplicitModel<ValueType>(settings.getTransitionFilename(), settings.getLabelingFilename(), settings.isStateRewardsSet() ? settings.getStateRewardsFilename() : boost::optional<std::string>(), settings.isTransitionRewardsSet() ? settings.getTransitionRewardsFilename() : boost::optional<std::string>(), settings.isChoiceLabelingSet() ? settings.getChoiceLabelingFilename() : boost::optional<std::string>());
-
- // Preprocess the model if needed.
- model = preprocessModel<ValueType>(model, formulas);
-
- // Print some information about the model.
- model->printModelInformationToStream(std::cout);
-
- // Verify the model, if a formula was given.
- if (!formulas.empty()) {
- STORM_LOG_THROW(model->isSparseModel(), storm::exceptions::InvalidStateException, "Expected sparse model.");
- verifySparseModel<ValueType>(boost::optional<storm::prism::Program>(), model->as<storm::models::sparse::Model<ValueType>>(), formulas);
+ } else if (model->isSymbolicModel()) {
+ if (storm::settings::generalSettings().getEngine() == storm::settings::modules::GeneralSettings::Engine::Hybrid) {
+ verifySymbolicModelWithHybridEngine(model->as<storm::models::symbolic::Model<storm::dd::DdType::CUDD>>(), formulas);
+ } else {
+ verifySymbolicModelWithSymbolicEngine(model->as<storm::models::symbolic::Model<storm::dd::DdType::CUDD>>(), formulas);
}
+ } else {
+ STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Invalid input model type.");
}
+ }
+ }
+
+ template<typename ValueType>
+ void buildAndCheckExplicitModel(std::vector<std::shared_ptr<storm::logic::Formula>> const& formulas) {
+ storm::settings::modules::GeneralSettings const& settings = storm::settings::generalSettings();
+
+ STORM_LOG_THROW(settings.isExplicitSet(), storm::exceptions::InvalidStateException, "Unable to build explicit model without model files.");
+ std::shared_ptr<storm::models::ModelBase> model = buildExplicitModel<ValueType>(settings.getTransitionFilename(), settings.getLabelingFilename(), settings.isStateRewardsSet() ? settings.getStateRewardsFilename() : boost::optional<std::string>(), settings.isTransitionRewardsSet() ? settings.getTransitionRewardsFilename() : boost::optional<std::string>(), settings.isChoiceLabelingSet() ? settings.getChoiceLabelingFilename() : boost::optional<std::string>());
+ // Preprocess the model if needed.
+ model = preprocessModel<ValueType>(model, formulas);
+
+ // Print some information about the model.
+ model->printModelInformationToStream(std::cout);
+
+ // Verify the model, if a formula was given.
+ if (!formulas.empty()) {
+ STORM_LOG_THROW(model->isSparseModel(), storm::exceptions::InvalidStateException, "Expected sparse model.");
+ verifySparseModel<ValueType>(model->as<storm::models::sparse::Model<ValueType>>(), formulas);
+ }
+ }
}