You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
363 lines
22 KiB
363 lines
22 KiB
// Include generated headers.
|
|
#include "storm-config.h"
|
|
|
|
#include <tuple>
|
|
|
|
// Include other headers.
|
|
#include "src/exceptions/BaseException.h"
|
|
#include "src/utility/macros.h"
|
|
#include "src/utility/cli.h"
|
|
#include "src/utility/export.h"
|
|
#include "src/modelchecker/reachability/CollectConstraints.h"
|
|
|
|
//#include "src/modelchecker/reachability/DirectEncoding.h"
|
|
#include "src/storage/DeterministicModelStrongBisimulationDecomposition.h"
|
|
#include "src/modelchecker/reachability/SparseSccModelChecker.h"
|
|
#include "src/storage/parameters.h"
|
|
#include "src/models/Dtmc.h"
|
|
#include "src/properties/prctl/PrctlFilter.h"
|
|
|
|
//std::tuple<storm::RationalFunction, boost::optional<storm::storage::SparseMatrix<storm::RationalFunction>>, boost::optional<std::vector<storm::RationalFunction>>, boost::optional<storm::storage::BitVector>, boost::optional<double>, boost::optional<bool>> computeReachabilityProbability(storm::models::Dtmc<storm::RationalFunction> const& dtmc, std::shared_ptr<storm::properties::prctl::PrctlFilter<double>> const& filterFormula) {
|
|
// // The first thing we need to do is to make sure the formula is of the correct form and - if so - extract
|
|
// // the bitvector representation of the atomic propositions.
|
|
//
|
|
// std::shared_ptr<storm::properties::prctl::AbstractStateFormula<double>> stateFormula = std::dynamic_pointer_cast<storm::properties::prctl::AbstractStateFormula<double>>(filterFormula->getChild());
|
|
// std::shared_ptr<storm::properties::prctl::AbstractPathFormula<double>> pathFormula;
|
|
// boost::optional<double> threshold;
|
|
// boost::optional<bool> strict;
|
|
// if (stateFormula != nullptr) {
|
|
// std::shared_ptr<storm::properties::prctl::ProbabilisticBoundOperator<double>> probabilisticBoundFormula = std::dynamic_pointer_cast<storm::properties::prctl::ProbabilisticBoundOperator<double>>(stateFormula);
|
|
// STORM_LOG_THROW(probabilisticBoundFormula != nullptr, storm::exceptions::InvalidPropertyException, "Illegal formula " << *filterFormula << " for parametric model checking. Note that only unbounded reachability properties are permitted.");
|
|
// STORM_LOG_THROW(probabilisticBoundFormula->getComparisonOperator() == storm::properties::ComparisonType::LESS_EQUAL || probabilisticBoundFormula->getComparisonOperator() == storm::properties::ComparisonType::LESS, storm::exceptions::InvalidPropertyException, "Illegal formula " << *filterFormula << " for parametric model checking. Note that only unbounded reachability properties with upper probability bounds are permitted.");
|
|
//
|
|
// threshold = probabilisticBoundFormula->getBound();
|
|
// strict = probabilisticBoundFormula->getComparisonOperator() == storm::properties::ComparisonType::LESS;
|
|
// pathFormula = probabilisticBoundFormula->getChild();
|
|
// } else {
|
|
// pathFormula = std::dynamic_pointer_cast<storm::properties::prctl::AbstractPathFormula<double>>(filterFormula->getChild());
|
|
// }
|
|
//
|
|
// STORM_LOG_THROW(pathFormula != nullptr, storm::exceptions::InvalidPropertyException, "Illegal formula " << *filterFormula << " for parametric model checking. Note that only unbounded reachability properties are permitted.");
|
|
//
|
|
// std::shared_ptr<storm::properties::prctl::Until<double>> untilFormula = std::dynamic_pointer_cast<storm::properties::prctl::Until<double>>(pathFormula);
|
|
// std::shared_ptr<storm::properties::prctl::AbstractStateFormula<double>> phiStateFormula;
|
|
// std::shared_ptr<storm::properties::prctl::AbstractStateFormula<double>> psiStateFormula;
|
|
// if (untilFormula != nullptr) {
|
|
// phiStateFormula = untilFormula->getLeft();
|
|
// psiStateFormula = untilFormula->getRight();
|
|
// } else {
|
|
// std::shared_ptr<storm::properties::prctl::Eventually<double>> eventuallyFormula = std::dynamic_pointer_cast<storm::properties::prctl::Eventually<double>>(pathFormula);
|
|
// STORM_LOG_THROW(eventuallyFormula != nullptr, storm::exceptions::InvalidPropertyException, "Illegal formula " << *filterFormula << " for parametric model checking. Note that only unbounded reachability properties are permitted.");
|
|
// phiStateFormula = std::shared_ptr<storm::properties::prctl::Ap<double>>(new storm::properties::prctl::Ap<double>("true"));
|
|
// psiStateFormula = eventuallyFormula->getChild();
|
|
// }
|
|
//
|
|
// // Now we need to make sure the formulas defining the phi and psi states are just labels.
|
|
// std::shared_ptr<storm::properties::prctl::Ap<double>> phiStateFormulaApFormula = std::dynamic_pointer_cast<storm::properties::prctl::Ap<double>>(phiStateFormula);
|
|
// std::shared_ptr<storm::properties::prctl::Ap<double>> psiStateFormulaApFormula = std::dynamic_pointer_cast<storm::properties::prctl::Ap<double>>(psiStateFormula);
|
|
// STORM_LOG_THROW(phiStateFormulaApFormula.get() != nullptr, storm::exceptions::InvalidPropertyException, "Illegal formula " << *phiStateFormula << " for parametric model checking. Note that only atomic propositions are admitted in that position.");
|
|
// STORM_LOG_THROW(psiStateFormulaApFormula.get() != nullptr, storm::exceptions::InvalidPropertyException, "Illegal formula " << *psiStateFormula << " for parametric model checking. Note that only atomic propositions are admitted in that position.");
|
|
//
|
|
// // Now retrieve the appropriate bitvectors from the atomic propositions.
|
|
// storm::storage::BitVector phiStates = phiStateFormulaApFormula->getAp() != "true" ? dtmc.getLabeledStates(phiStateFormulaApFormula->getAp()) : storm::storage::BitVector(dtmc.getNumberOfStates(), true);
|
|
// storm::storage::BitVector psiStates = dtmc.getLabeledStates(psiStateFormulaApFormula->getAp());
|
|
//
|
|
// // Do some sanity checks to establish some required properties.
|
|
// STORM_LOG_THROW(dtmc.getInitialStates().getNumberOfSetBits() == 1, storm::exceptions::IllegalArgumentException, "Input model is required to have exactly one initial state.");
|
|
//
|
|
// // Then, compute the subset of states that has a probability of 0 or 1, respectively.
|
|
// std::pair<storm::storage::BitVector, storm::storage::BitVector> statesWithProbability01 = storm::utility::graph::performProb01(dtmc, phiStates, psiStates);
|
|
// storm::storage::BitVector statesWithProbability0 = statesWithProbability01.first;
|
|
// storm::storage::BitVector statesWithProbability1 = statesWithProbability01.second;
|
|
// storm::storage::BitVector maybeStates = ~(statesWithProbability0 | statesWithProbability1);
|
|
//
|
|
// // If the initial state is known to have either probability 0 or 1, we can directly return the result.
|
|
// if (dtmc.getInitialStates().isDisjointFrom(maybeStates)) {
|
|
// STORM_LOG_DEBUG("The probability of all initial states was found in a preprocessing step.");
|
|
// return statesWithProbability0.get(*dtmc.getInitialStates().begin()) ? storm::utility::constantZero<storm::RationalFunction>() : storm::utility::constantOne<storm::RationalFunction>();
|
|
// }
|
|
//
|
|
// // Determine the set of states that is reachable from the initial state without jumping over a target state.
|
|
// storm::storage::BitVector reachableStates = storm::utility::graph::getReachableStates(dtmc.getTransitionMatrix(), dtmc.getInitialStates(), maybeStates, statesWithProbability1);
|
|
//
|
|
// // Subtract from the maybe states the set of states that is not reachable (on a path from the initial to a target state).
|
|
// maybeStates &= reachableStates;
|
|
//
|
|
// // Create a vector for the probabilities to go to a state with probability 1 in one step.
|
|
// std::vector<storm::RationalFunction> oneStepProbabilities = dtmc.getTransitionMatrix().getConstrainedRowSumVector(maybeStates, statesWithProbability1);
|
|
//
|
|
// // Determine the set of initial states of the sub-DTMC.
|
|
// storm::storage::BitVector newInitialStates = dtmc.getInitialStates() % maybeStates;
|
|
//
|
|
// // We then build the submatrix that only has the transitions of the maybe states.
|
|
// storm::storage::SparseMatrix<storm::RationalFunction> submatrix = dtmc.getTransitionMatrix().getSubmatrix(false, maybeStates, maybeStates);
|
|
//
|
|
// // To be able to apply heuristics later, we now determine the distance of each state to the initial state.
|
|
// std::vector<std::pair<storm::storage::sparse::state_type, std::size_t>> stateQueue;
|
|
// stateQueue.reserve(submatrix.getRowCount());
|
|
// storm::storage::BitVector statesInQueue(submatrix.getRowCount());
|
|
// std::vector<std::size_t> distances(submatrix.getRowCount());
|
|
//
|
|
// storm::storage::sparse::state_type currentPosition = 0;
|
|
// for (auto const& initialState : newInitialStates) {
|
|
// stateQueue.emplace_back(initialState, 0);
|
|
// statesInQueue.set(initialState);
|
|
// }
|
|
//
|
|
// // Perform a BFS.
|
|
// while (currentPosition < stateQueue.size()) {
|
|
// std::pair<storm::storage::sparse::state_type, std::size_t> const& stateDistancePair = stateQueue[currentPosition];
|
|
// distances[stateDistancePair.first] = stateDistancePair.second;
|
|
//
|
|
// for (auto const& successorEntry : submatrix.getRow(stateDistancePair.first)) {
|
|
// if (!statesInQueue.get(successorEntry.getColumn())) {
|
|
// stateQueue.emplace_back(successorEntry.getColumn(), stateDistancePair.second + 1);
|
|
// statesInQueue.set(successorEntry.getColumn());
|
|
// }
|
|
// }
|
|
// ++currentPosition;
|
|
// }
|
|
//
|
|
// storm::modelchecker::reachability::SparseSccModelChecker<storm::RationalFunction> modelchecker;
|
|
//
|
|
// return std::make_tuple(modelchecker.computeReachabilityProbability(submatrix, oneStepProbabilities, submatrix.transpose(), newInitialStates, phiStates, psiStates, distances),submatrix, oneStepProbabilities, newInitialStates, threshold, strict);
|
|
//}
|
|
|
|
/*!
|
|
* Main entry point of the executable storm.
|
|
*/
|
|
int main(const int argc, const char** argv) {
|
|
// try {
|
|
storm::utility::cli::setUp();
|
|
storm::utility::cli::printHeader(argc, argv);
|
|
bool optionsCorrect = storm::utility::cli::parseOptions(argc, argv);
|
|
if (!optionsCorrect) {
|
|
return -1;
|
|
}
|
|
|
|
// From this point on we are ready to carry out the actual computations.
|
|
// Program Translation Time Measurement, Start
|
|
std::chrono::high_resolution_clock::time_point programTranslationStart = std::chrono::high_resolution_clock::now();
|
|
|
|
// First, we build the model using the given symbolic model description and constant definitions.
|
|
std::string const& programFile = storm::settings::generalSettings().getSymbolicModelFilename();
|
|
std::string const& constants = storm::settings::generalSettings().getConstantDefinitionString();
|
|
storm::prism::Program program = storm::parser::PrismParser::parse(programFile);
|
|
std::shared_ptr<storm::models::AbstractModel<storm::RationalFunction>> model = storm::adapters::ExplicitModelAdapter<storm::RationalFunction>::translateProgram(program, constants);
|
|
|
|
model->printModelInformationToStream(std::cout);
|
|
|
|
// Program Translation Time Measurement, End
|
|
std::chrono::high_resolution_clock::time_point programTranslationEnd = std::chrono::high_resolution_clock::now();
|
|
std::cout << "Parsing and translating the model took " << std::chrono::duration_cast<std::chrono::milliseconds>(programTranslationEnd - programTranslationStart).count() << "ms." << std::endl << std::endl;
|
|
|
|
std::shared_ptr<storm::models::Dtmc<storm::RationalFunction>> dtmc = model->as<storm::models::Dtmc<storm::RationalFunction>>();
|
|
|
|
// Perform bisimulation minimization if requested.
|
|
if (storm::settings::generalSettings().isBisimulationSet()) {
|
|
storm::storage::DeterministicModelStrongBisimulationDecomposition<storm::RationalFunction> bisimulationDecomposition(*dtmc, true);
|
|
dtmc = bisimulationDecomposition.getQuotient()->as<storm::models::Dtmc<storm::RationalFunction>>();
|
|
|
|
dtmc->printModelInformationToStream(std::cout);
|
|
}
|
|
|
|
assert(dtmc);
|
|
storm::modelchecker::reachability::CollectConstraints<storm::RationalFunction> constraintCollector;
|
|
constraintCollector(*dtmc);
|
|
|
|
STORM_LOG_THROW(storm::settings::generalSettings().isPctlPropertySet(), storm::exceptions::InvalidSettingsException, "Unable to perform model checking without a property.");
|
|
std::shared_ptr<storm::properties::prctl::PrctlFilter<double>> filterFormula = storm::parser::PrctlParser::parsePrctlFormula(storm::settings::generalSettings().getPctlProperty());
|
|
|
|
storm::modelchecker::reachability::SparseSccModelChecker<storm::RationalFunction> modelchecker;
|
|
|
|
storm::RationalFunction valueFunction = modelchecker.computeReachabilityProbability(*dtmc, filterFormula);
|
|
// STORM_PRINT_AND_LOG(std::endl << "Result: (" << carl::computePolynomial(valueFunction.nominator()) << ") / (" << carl::computePolynomial(valueFunction.denominator()) << ")" << std::endl);
|
|
STORM_PRINT_AND_LOG(std::endl << "Result: (" << valueFunction.nominator() << ") / (" << valueFunction.denominator() << ")" << std::endl);
|
|
STORM_PRINT_AND_LOG(std::endl << "Result: " << valueFunction << std::endl);
|
|
|
|
// // Perform bisimulation minimization if requested.
|
|
// if (storm::settings::generalSettings().isBisimulationSet()) {
|
|
// storm::storage::DeterministicModelStrongBisimulationDecomposition<storm::RationalFunction> bisimulationDecomposition(*dtmc, true);
|
|
// dtmc = bisimulationDecomposition.getQuotient()->as<storm::models::Dtmc<storm::RationalFunction>>();
|
|
//
|
|
// dtmc->printModelInformationToStream(std::cout);
|
|
// }
|
|
|
|
// storm::RationalFunction valueFunction2 = modelchecker.computeReachabilityProbability(*dtmc, filterFormula);
|
|
// STORM_PRINT_AND_LOG(std::endl << "computed value2 " << valueFunction2 << std::endl);
|
|
//
|
|
// storm::RationalFunction diff = storm::utility::simplify(valueFunction - valueFunction2);
|
|
// STORM_PRINT_AND_LOG(std::endl << "difference: " << diff << std::endl);
|
|
|
|
// Get variables from parameter definitions in prism program.
|
|
std::set<storm::Variable> parameters;
|
|
for(auto constant : program.getConstants())
|
|
{
|
|
if(!constant.isDefined())
|
|
{
|
|
carl::Variable p = carl::VariablePool::getInstance().findVariableWithName(constant.getName());
|
|
assert(p != storm::Variable::NO_VARIABLE);
|
|
parameters.insert(p);
|
|
}
|
|
}
|
|
|
|
STORM_LOG_ASSERT(parameters == valueFunction.gatherVariables(), "Parameters in result and program definition do not coincide.");
|
|
|
|
if(storm::settings::parametricSettings().exportResultToFile()) {
|
|
storm::utility::exportParametricMcResult(valueFunction, constraintCollector);
|
|
}
|
|
|
|
// if (storm::settings::parametricSettings().exportToSmt2File() && std::get<1>(result) && std::get<2>(result) && std::get<3>(result) && std::get<4>(result) && std::get<5>(result)) {
|
|
// storm::modelchecker::reachability::DirectEncoding dec;
|
|
// storm::utility::exportStringStreamToFile(dec.encodeAsSmt2(std::get<1>(result).get(), std::get<2>(result).get(), parameters, std::get<3>(result).get(), carl::rationalize<storm::RationalFunction::CoeffType>(std::get<4>(result).get()), std::get<5>(result).get()), "out.smt");
|
|
// }
|
|
|
|
// All operations have now been performed, so we clean up everything and terminate.
|
|
storm::utility::cli::cleanUp();
|
|
return 0;
|
|
// } catch (storm::exceptions::BaseException const& exception) {
|
|
// STORM_LOG_ERROR("An exception caused StoRM to terminate. The message of the exception is: " << exception.what());
|
|
// } catch (std::exception const& exception) {
|
|
// STORM_LOG_ERROR("An unexpected exception occurred and caused StoRM to terminate. The message of this exception is: " << exception.what());
|
|
// }
|
|
}
|
|
|
|
//#include <memory>
|
|
//#include <stdint.h>
|
|
//
|
|
//#include "stormParametric.h"
|
|
//#include "adapters/ExplicitModelAdapter.h"
|
|
//#include "utility/graph.h"
|
|
//#include "modelchecker/reachability/DirectEncoding.h"
|
|
//#include "storage/BitVector.h"
|
|
//#include "storage/DeterministicTransition.h"
|
|
//
|
|
//using storm::storage::StateId;
|
|
//
|
|
//namespace storm
|
|
//{
|
|
//
|
|
//
|
|
//void ParametricStormEntryPoint::createModel()
|
|
//{
|
|
// mModel = storm::adapters::ExplicitModelAdapter<RationalFunction>::translateProgram(mProgram, mConstants);
|
|
// mModel->printModelInformationToStream(std::cout);
|
|
//}
|
|
//
|
|
//std::string ParametricStormEntryPoint::reachabilityToSmt2(std::string const& label)
|
|
//{
|
|
//
|
|
// storm::storage::BitVector phiStates(mModel->getNumberOfStates(), true);
|
|
// storm::storage::BitVector initStates = mModel->getInitialStates();
|
|
// storm::storage::BitVector targetStates = mModel->getLabeledStates(label);
|
|
//
|
|
// std::shared_ptr<models::Dtmc<RationalFunction>> dtmc = mModel->as<models::Dtmc<RationalFunction>>();
|
|
// // 1. make target states absorbing.
|
|
// dtmc->makeAbsorbing(targetStates);
|
|
// // 2. throw away anything which does not add to the reachability probability.
|
|
// // 2a. remove non productive states
|
|
// storm::storage::BitVector productiveStates = utility::graph::performProbGreater0(*dtmc, dtmc->getBackwardTransitions(), phiStates, targetStates);
|
|
// // 2b. calculate set of states wich
|
|
// storm::storage::BitVector almostSurelyReachingTargetStates = ~utility::graph::performProbGreater0(*dtmc, dtmc->getBackwardTransitions(), phiStates, ~productiveStates);
|
|
// // 2c. Make such states also target states.
|
|
// dtmc->makeAbsorbing(almostSurelyReachingTargetStates);
|
|
// // 2d. throw away non reachable states
|
|
// storm::storage::BitVector reachableStates = utility::graph::performProbGreater0(*dtmc, dtmc->getTransitionMatrix(), phiStates, initStates);
|
|
// storm::storage::BitVector bv = productiveStates & reachableStates;
|
|
// dtmc->getStateLabeling().addAtomicProposition("__targets__", targetStates | almostSurelyReachingTargetStates);
|
|
// models::Dtmc<RationalFunction> subdtmc = dtmc->getSubDtmc(bv);
|
|
//
|
|
// phiStates = storm::storage::BitVector(subdtmc.getNumberOfStates(), true);
|
|
// initStates = subdtmc.getInitialStates();
|
|
// targetStates = subdtmc.getLabeledStates("__targets__");
|
|
// storm::storage::BitVector deadlockStates(phiStates);
|
|
// deadlockStates.set(subdtmc.getNumberOfStates()-1,false);
|
|
//
|
|
// // Search for states with only one non-deadlock successor.
|
|
// std::map<StateId, storage::DeterministicTransition<RationalFunction>> chainedStates;
|
|
// StateId nrStates = subdtmc.getNumberOfStates();
|
|
// StateId deadlockState = nrStates - 1;
|
|
// for(StateId source = 0; source < nrStates - 1; ++source)
|
|
// {
|
|
// if(targetStates[source])
|
|
// {
|
|
// continue;
|
|
// }
|
|
// storage::DeterministicTransition<RationalFunction> productiveTransition(nrStates);
|
|
// for(auto const& transition : subdtmc.getRows(source))
|
|
// {
|
|
// if(productiveTransition.targetState() == nrStates)
|
|
// {
|
|
// // first transition.
|
|
// productiveTransition = transition;
|
|
// }
|
|
// else
|
|
// {
|
|
// // second transition
|
|
// if(transition.first != deadlockState)
|
|
// {
|
|
// productiveTransition.targetState() = nrStates;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// if(productiveTransition.targetState() != nrStates)
|
|
// {
|
|
// chainedStates.emplace(source, productiveTransition);
|
|
// }
|
|
// }
|
|
// storage::BitVector eliminatedStates(nrStates, false);
|
|
// for(auto & chainedState : chainedStates)
|
|
// {
|
|
// assert(chainedState.first != chainedState.second.targetState());
|
|
// auto it = chainedStates.find(chainedState.second.targetState());
|
|
// if(it != chainedStates.end())
|
|
// {
|
|
// //std::cout << "----------------------------" << std::endl;
|
|
// //std::cout << chainedState.first << " -- " << chainedState.second.probability() << " --> " << chainedState.second.targetState() << std::endl;
|
|
// //std::cout << it->first << " -- " << it->second.probability() << " --> " << it->second.targetState() << std::endl;
|
|
// chainedState.second.targetState() = it->second.targetState();
|
|
// chainedState.second.probability() *= it->second.probability();
|
|
// //std::cout << chainedState.first << " -- " << chainedState.second.probability() << " --> " << chainedState.second.targetState() << std::endl;
|
|
// //std::cout << "----------------------------" << std::endl;
|
|
// chainedStates.erase(it);
|
|
// eliminatedStates.set(it->first, true);
|
|
// }
|
|
// }
|
|
//
|
|
//
|
|
// for(auto chainedState : chainedStates)
|
|
// {
|
|
// if(!eliminatedStates[chainedState.first])
|
|
// {
|
|
// std::cout << chainedState.first << " -- " << chainedState.second.probability() << " --> " << chainedState.second.targetState() << std::endl;
|
|
// }
|
|
// }
|
|
//
|
|
// storage::StronglyConnectedComponentDecomposition<RationalFunction> sccs(subdtmc);
|
|
// std::cout << sccs << std::endl;
|
|
//
|
|
// modelchecker::reachability::DirectEncoding dec;
|
|
// std::vector<carl::Variable> parameters;
|
|
|
|
// return dec.encodeAsSmt2(subdtmc, parameters, subdtmc.getLabeledStates("init"), subdtmc.getLabeledStates("__targets__"), mpq_class(1,2));
|
|
//
|
|
//}
|
|
//
|
|
//
|
|
//void storm_parametric(const std::string& constants, const storm::prism::Program& program)
|
|
//{
|
|
// ParametricStormEntryPoint entry(constants, program);
|
|
// entry.createModel();
|
|
// storm::settings::Settings* s = storm::settings::Settings::getInstance();
|
|
// if(s->isSet("reachability"))
|
|
// {
|
|
// std::ofstream fstream("test.smt2");
|
|
// fstream << entry.reachabilityToSmt2(s->getOptionByLongName("reachability").getArgument(0).getValueAsString());
|
|
// fstream.close();
|
|
// }
|
|
//
|
|
//
|
|
//}
|
|
//
|
|
//}
|