1#include "storm-config.h"
34enum class DtmcEngine { PrismSparse, JaniSparse,
Hybrid, PrismDd, JaniDd };
36class SparseGmmxxGmresIluEnvironment {
39 static const DtmcEngine engine = DtmcEngine::PrismSparse;
40 static const bool isExact =
false;
53class JaniSparseGmmxxGmresIluEnvironment {
56 static const DtmcEngine engine = DtmcEngine::JaniSparse;
57 static const bool isExact =
false;
70class SparseGmmxxGmresDiagEnvironment {
73 static const DtmcEngine engine = DtmcEngine::PrismSparse;
74 static const bool isExact =
false;
87class SparseGmmxxBicgstabIluEnvironment {
90 static const DtmcEngine engine = DtmcEngine::PrismSparse;
91 static const bool isExact =
false;
104class SparseEigenDGmresEnvironment {
107 static const DtmcEngine engine = DtmcEngine::PrismSparse;
108 static const bool isExact =
false;
121class SparseEigenDoubleLUEnvironment {
124 static const DtmcEngine engine = DtmcEngine::PrismSparse;
125 static const bool isExact =
false;
136class SparseEigenRationalLUEnvironment {
139 static const DtmcEngine engine = DtmcEngine::PrismSparse;
140 static const bool isExact =
true;
151class SparseRationalEliminationEnvironment {
154 static const DtmcEngine engine = DtmcEngine::PrismSparse;
155 static const bool isExact =
true;
165class SparseNativeJacobiEnvironment {
168 static const DtmcEngine engine = DtmcEngine::PrismSparse;
169 static const bool isExact =
false;
181class SparseNativeWalkerChaeEnvironment {
184 static const DtmcEngine engine = DtmcEngine::PrismSparse;
185 static const bool isExact =
false;
198class SparseNativeSorEnvironment {
201 static const DtmcEngine engine = DtmcEngine::PrismSparse;
202 static const bool isExact =
false;
214class SparseNativePowerEnvironment {
217 static const DtmcEngine engine = DtmcEngine::PrismSparse;
218 static const bool isExact =
false;
230class SparseNativeSoundValueIterationEnvironment {
233 static const DtmcEngine engine = DtmcEngine::PrismSparse;
234 static const bool isExact =
false;
241 env.
solver().
native().
setMethod(storm::solver::NativeLinearEquationSolverMethod::SoundValueIteration);
247class SparseNativeOptimisticValueIterationEnvironment {
250 static const DtmcEngine engine = DtmcEngine::PrismSparse;
251 static const bool isExact =
false;
258 env.
solver().
native().
setMethod(storm::solver::NativeLinearEquationSolverMethod::OptimisticValueIteration);
264class SparseNativeGuessingValueIterationEnvironment {
267 static const DtmcEngine engine = DtmcEngine::PrismSparse;
268 static const bool isExact =
false;
275 env.
solver().
native().
setMethod(storm::solver::NativeLinearEquationSolverMethod::GuessingValueIteration);
281class SparseNativeIntervalIterationEnvironment {
284 static const DtmcEngine engine = DtmcEngine::PrismSparse;
285 static const bool isExact =
false;
299class SparseNativeRationalSearchEnvironment {
302 static const DtmcEngine engine = DtmcEngine::PrismSparse;
303 static const bool isExact =
true;
314class SparseTopologicalEigenLUEnvironment {
317 static const DtmcEngine engine = DtmcEngine::PrismSparse;
318 static const bool isExact =
true;
330class HybridSylvanGmmxxGmresEnvironment {
333 static const DtmcEngine engine = DtmcEngine::Hybrid;
334 static const bool isExact =
false;
346class HybridCuddNativeJacobiEnvironment {
349 static const DtmcEngine engine = DtmcEngine::Hybrid;
350 static const bool isExact =
false;
362class HybridCuddNativeSoundValueIterationEnvironment {
365 static const DtmcEngine engine = DtmcEngine::Hybrid;
366 static const bool isExact =
false;
379class HybridSylvanNativeRationalSearchEnvironment {
382 static const DtmcEngine engine = DtmcEngine::Hybrid;
383 static const bool isExact =
true;
394class DdSylvanNativePowerEnvironment {
397 static const DtmcEngine engine = DtmcEngine::PrismDd;
398 static const bool isExact =
false;
410class JaniDdSylvanNativePowerEnvironment {
413 static const DtmcEngine engine = DtmcEngine::JaniDd;
414 static const bool isExact =
false;
426class DdCuddNativeJacobiEnvironment {
429 static const DtmcEngine engine = DtmcEngine::PrismDd;
430 static const bool isExact =
false;
442class DdSylvanRationalSearchEnvironment {
445 static const DtmcEngine engine = DtmcEngine::PrismDd;
446 static const bool isExact =
true;
457template<
typename TestType>
458class DtmcPrctlModelCheckerTest :
public ::testing::Test {
460 typedef typename TestType::ValueType
ValueType;
464 DtmcPrctlModelCheckerTest() : _environment(TestType::createEnvironment()) {}
466 void SetUp()
override {
468 GTEST_SKIP() <<
"Z3 not available.";
476 return storm::utility::convertNumber<ValueType>(input);
481 bool isSparseModel()
const {
482 return std::is_same<typename TestType::ModelType, SparseModelType>::value;
484 bool isSymbolicModel()
const {
485 return std::is_same<typename TestType::ModelType, SymbolicModelType>::value;
488 template<
typename MT =
typename TestType::ModelType>
489 typename std::enable_if<std::is_same<MT, SparseModelType>::value,
490 std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>>>::type
491 buildModelFormulas(std::string
const& pathToPrismFile, std::string
const& formulasAsString, std::string
const& constantDefinitionString =
"")
const {
492 std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>> result;
495 if (TestType::engine == DtmcEngine::PrismSparse) {
497 result.first = storm::api::buildSparseModel<ValueType>(program, result.second)->template as<MT>();
498 }
else if (TestType::engine == DtmcEngine::JaniSparse) {
501 result.first = storm::api::buildSparseModel<ValueType>(janiData.first, result.second)->template as<MT>();
507 template<
typename MT =
typename TestType::ModelType>
508 typename std::enable_if<std::is_same<MT, SymbolicModelType>::value,
509 std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>>>::type
510 buildModelFormulas(std::string
const& pathToPrismFile, std::string
const& formulasAsString, std::string
const& constantDefinitionString =
"")
const {
511 std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>> result;
514 if (TestType::engine == DtmcEngine::Hybrid || TestType::engine == DtmcEngine::PrismDd) {
516 result.first = storm::api::buildSymbolicModel<TestType::ddType, ValueType>(program, result.second)->template as<MT>();
517 }
else if (TestType::engine == DtmcEngine::JaniDd) {
519 janiData.first.substituteFunctions();
521 result.first = storm::api::buildSymbolicModel<TestType::ddType, ValueType>(janiData.first, result.second)->template as<MT>();
526 std::vector<storm::modelchecker::CheckTask<storm::logic::Formula, ValueType>> getTasks(
527 std::vector<std::shared_ptr<storm::logic::Formula const>>
const& formulas)
const {
528 std::vector<storm::modelchecker::CheckTask<storm::logic::Formula, ValueType>> result;
529 for (
auto const& f : formulas) {
530 result.emplace_back(*f);
535 template<
typename MT =
typename TestType::ModelType>
536 typename std::enable_if<std::is_same<MT, SparseModelType>::value, std::shared_ptr<storm::modelchecker::AbstractModelChecker<MT>>>::type createModelChecker(
537 std::shared_ptr<MT>
const& model)
const {
538 if (TestType::engine == DtmcEngine::PrismSparse || TestType::engine == DtmcEngine::JaniSparse) {
539 return std::make_shared<storm::modelchecker::SparseDtmcPrctlModelChecker<SparseModelType>>(*model);
543 template<
typename MT =
typename TestType::ModelType>
544 typename std::enable_if<std::is_same<MT, SymbolicModelType>::value, std::shared_ptr<storm::modelchecker::AbstractModelChecker<MT>>>::type
545 createModelChecker(std::shared_ptr<MT>
const& model)
const {
546 if (TestType::engine == DtmcEngine::Hybrid) {
547 return std::make_shared<storm::modelchecker::HybridDtmcPrctlModelChecker<SymbolicModelType>>(*model);
548 }
else if (TestType::engine == DtmcEngine::PrismDd || TestType::engine == DtmcEngine::JaniDd) {
549 return std::make_shared<storm::modelchecker::SymbolicDtmcPrctlModelChecker<SymbolicModelType>>(*model);
553 template<
typename MT =
typename TestType::ModelType>
554 typename std::enable_if<std::is_same<MT, SparseModelType>::value,
void>::type execute(std::shared_ptr<MT>
const& model,
555 std::function<
void()>
const& f)
const {
559 template<
typename MT =
typename TestType::ModelType>
560 typename std::enable_if<std::is_same<MT, SymbolicModelType>::value,
void>::type execute(std::shared_ptr<MT>
const& model,
561 std::function<
void()>
const& f)
const {
562 model->getManager().execute(f);
566 std::unique_ptr<storm::modelchecker::CheckResult>& result) {
568 result->filter(*filter);
569 return result->asQualitativeCheckResult().forallTrue();
573 std::unique_ptr<storm::modelchecker::CheckResult>& result) {
575 result->filter(*filter);
576 return result->asQuantitativeCheckResult<
ValueType>().getMin();
583 if (isSparseModel()) {
584 return std::make_unique<storm::modelchecker::ExplicitQualitativeCheckResult>(model->template as<SparseModelType>()->getInitialStates());
586 return std::make_unique<storm::modelchecker::SymbolicQualitativeCheckResult<TestType::ddType>>(
587 model->template as<SymbolicModelType>()->getReachableStates(), model->template as<SymbolicModelType>()->getInitialStates());
592typedef ::testing::Types<
594 SparseGmmxxGmresIluEnvironment, JaniSparseGmmxxGmresIluEnvironment, SparseGmmxxGmresDiagEnvironment, SparseGmmxxBicgstabIluEnvironment,
595 HybridSylvanGmmxxGmresEnvironment,
597 SparseEigenDGmresEnvironment, SparseEigenDoubleLUEnvironment, SparseEigenRationalLUEnvironment, SparseRationalEliminationEnvironment,
598 SparseNativeJacobiEnvironment, SparseNativeWalkerChaeEnvironment, SparseNativeSorEnvironment, SparseNativePowerEnvironment,
599 SparseNativeSoundValueIterationEnvironment, SparseNativeOptimisticValueIterationEnvironment, SparseNativeGuessingValueIterationEnvironment,
600 SparseNativeIntervalIterationEnvironment, SparseNativeRationalSearchEnvironment, SparseTopologicalEigenLUEnvironment, HybridCuddNativeJacobiEnvironment,
601 HybridCuddNativeSoundValueIterationEnvironment, HybridSylvanNativeRationalSearchEnvironment, DdSylvanNativePowerEnvironment,
602 JaniDdSylvanNativePowerEnvironment, DdCuddNativeJacobiEnvironment, DdSylvanRationalSearchEnvironment>
608 std::string formulasString =
"P=? [F \"one\"]";
609 formulasString +=
"; P=? [F \"two\"]";
610 formulasString +=
"; P=? [F \"three\"]";
611 formulasString +=
"; R=? [F \"done\"]";
613 auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR
"/dtmc/die.pm", formulasString);
614 auto model = std::move(modelFormulas.first);
615 auto tasks = this->getTasks(modelFormulas.second);
616 this->execute(model, [&]() {
617 EXPECT_EQ(13ul, model->getNumberOfStates());
618 EXPECT_EQ(20ul, model->getNumberOfTransitions());
620 auto checker = this->createModelChecker(model);
621 std::unique_ptr<storm::modelchecker::CheckResult> result;
623 result = checker->check(this->env(), tasks[0]);
626 result = checker->check(this->env(), tasks[1]);
629 result = checker->check(this->env(), tasks[2]);
632 result = checker->check(this->env(), tasks[3]);
637TYPED_TEST(DtmcPrctlModelCheckerTest, Crowds) {
638 std::string formulasString =
"P=? [F observe0>1]";
639 formulasString +=
"; P=? [F \"observeIGreater1\"]";
640 formulasString +=
"; P=? [F observe1>1]";
642 auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR
"/dtmc/crowds-4-3.pm", formulasString);
643 auto model = std::move(modelFormulas.first);
644 auto tasks = this->getTasks(modelFormulas.second);
645 this->execute(model, [&]() {
646 EXPECT_EQ(726ul, model->getNumberOfStates());
647 EXPECT_EQ(1146ul, model->getNumberOfTransitions());
649 auto checker = this->createModelChecker(model);
650 std::unique_ptr<storm::modelchecker::CheckResult> result;
652 result = checker->check(this->env(), tasks[0]);
655 result = checker->check(this->env(), tasks[1]);
658 result = checker->check(this->env(), tasks[2]);
663TYPED_TEST(DtmcPrctlModelCheckerTest, SynchronousLeader) {
664 std::string formulasString =
"P=? [F \"elected\"]";
665 formulasString +=
"; P=? [F<=5 \"elected\"]";
666 formulasString +=
"; R=? [F \"elected\"]";
668 auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR
"/dtmc/leader-3-5.pm", formulasString);
669 auto model = std::move(modelFormulas.first);
670 auto tasks = this->getTasks(modelFormulas.second);
671 this->execute(model, [&]() {
672 EXPECT_EQ(273ul, model->getNumberOfStates());
673 EXPECT_EQ(397ul, model->getNumberOfTransitions());
675 auto checker = this->createModelChecker(model);
676 std::unique_ptr<storm::modelchecker::CheckResult> result;
678 result = checker->check(this->env(), tasks[0]);
681 result = checker->check(this->env(), tasks[1]);
684 result = checker->check(this->env(), tasks[2]);
689TEST(DtmcPrctlModelCheckerTest, AllUntilProbabilities) {
691 GTEST_SKIP() <<
"Z3 not available.";
693 std::string formulasString =
"P=? [F \"one\"]";
694 formulasString +=
"; P=? [F \"two\"]";
695 formulasString +=
"; P=? [F \"three\"]";
699 std::vector<storm::modelchecker::CheckTask<storm::logic::Formula, double>> tasks;
700 for (
auto const& f : formulas) {
701 tasks.emplace_back(*f);
703 auto model = storm::api::buildSparseModel<double>(program, formulas)->template as<storm::models::sparse::Dtmc<double>>();
704 EXPECT_EQ(13ul, model->getNumberOfStates());
705 EXPECT_EQ(20ul, model->getNumberOfTransitions());
709 initialStates.set(0);
721 initialStates, phiStates, psiStates);
723 EXPECT_NEAR(1.0 / 6, result[7], 1e-6);
724 EXPECT_NEAR(1.0 / 6, result[8], 1e-6);
725 EXPECT_NEAR(1.0 / 6, result[9], 1e-6);
726 EXPECT_NEAR(1.0 / 6, result[10], 1e-6);
727 EXPECT_NEAR(1.0 / 6, result[11], 1e-6);
728 EXPECT_NEAR(1.0 / 6, result[12], 1e-6);
735 EXPECT_NEAR(1, result[0], 1e-6);
736 EXPECT_NEAR(0.5, result[1], 1e-6);
737 EXPECT_NEAR(0.5, result[2], 1e-6);
738 EXPECT_NEAR(0.25, result[5], 1e-6);
739 EXPECT_NEAR(0, result[7], 1e-6);
740 EXPECT_NEAR(0, result[8], 1e-6);
741 EXPECT_NEAR(0, result[9], 1e-6);
742 EXPECT_NEAR(0.125, result[10], 1e-6);
743 EXPECT_NEAR(0.125, result[11], 1e-6);
744 EXPECT_NEAR(0, result[12], 1e-6);
747TYPED_TEST(DtmcPrctlModelCheckerTest, LtlProbabilitiesDie) {
748#ifdef STORM_HAVE_LTL_MODELCHECKING_SUPPORT
749 std::string formulasString =
"P=? [(X s>0) U (s=7 & d=2)]";
750 formulasString +=
"; P=? [ X (((s=1) U (s=3)) U (s=7))]";
751 formulasString +=
"; P=? [ (F (X (s=6 & (XX s=5)))) & (F G (d!=5))]";
752 formulasString +=
"; P=? [ F (s=3 U (\"three\"))]";
753 formulasString +=
"; P=? [ F s=3 U (\"three\")]";
754 formulasString +=
"; P=? [ F (s=6) & X \"done\"]";
755 formulasString +=
"; P=? [ (F s=6) & (X \"done\")]";
757 auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR
"/dtmc/die.pm", formulasString);
758 auto model = std::move(modelFormulas.first);
759 auto tasks = this->getTasks(modelFormulas.second);
760 this->execute(model, [&]() {
761 EXPECT_EQ(13ul, model->getNumberOfStates());
762 EXPECT_EQ(20ul, model->getNumberOfTransitions());
764 auto checker = this->createModelChecker(model);
765 std::unique_ptr<storm::modelchecker::CheckResult> result;
768 if (TypeParam::engine == DtmcEngine::PrismSparse || TypeParam::engine == DtmcEngine::JaniSparse) {
769 result = checker->check(tasks[0]);
772 result = checker->check(tasks[1]);
775 result = checker->check(tasks[2]);
778 result = checker->check(tasks[3]);
781 result = checker->check(tasks[4]);
784 result = checker->check(tasks[5]);
787 result = checker->check(tasks[6]);
790 EXPECT_FALSE(checker->canHandle(tasks[0]));
798TYPED_TEST(DtmcPrctlModelCheckerTest, LtlProbabilitiesSynchronousLeader) {
799#ifdef STORM_HAVE_LTL_MODELCHECKING_SUPPORT
800 std::string formulasString =
"P=? [X (u1=true U \"elected\")]";
801 formulasString +=
"; P=? [X !(u1=true U \"elected\")]";
802 formulasString +=
"; P=? [X v1=2 & X v1=1]";
803 formulasString +=
"; P=? [(X v1=2) & (X v1=1)]";
804 formulasString +=
"; P=? [(!X v1=2) & (X v1=1)]";
806 auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR
"/dtmc/leader-3-5.pm", formulasString);
807 auto model = std::move(modelFormulas.first);
808 auto tasks = this->getTasks(modelFormulas.second);
809 this->execute(model, [&]() {
810 EXPECT_EQ(273ul, model->getNumberOfStates());
811 EXPECT_EQ(397ul, model->getNumberOfTransitions());
813 auto checker = this->createModelChecker(model);
814 std::unique_ptr<storm::modelchecker::CheckResult> result;
817 if (TypeParam::engine == DtmcEngine::PrismSparse || TypeParam::engine == DtmcEngine::JaniSparse) {
818 result = checker->check(tasks[0]);
821 result = checker->check(tasks[1]);
824 result = checker->check(tasks[2]);
827 result = checker->check(tasks[3]);
830 result = checker->check(tasks[4]);
834 EXPECT_FALSE(checker->canHandle(tasks[0]));
842TYPED_TEST(DtmcPrctlModelCheckerTest, HOAProbabilitiesDie) {
844 std::string formulasString =
"P=?[HOA: {\"" STORM_TEST_RESOURCES_DIR
"/hoa/automaton_UXp0p1.hoa\", \"p0\" -> (s>0), \"p1\" -> (s=7 & d=2) }]";
846 formulasString +=
"; P=?[HOA: {\"" STORM_TEST_RESOURCES_DIR
"/hoa/automaton_UXp0p1.hoa\", \"p0\" -> (s>0), \"p1\" -> (d=4 | d=2) }]";
848 formulasString +=
"; P=?[HOA: {\"" STORM_TEST_RESOURCES_DIR
"/hoa/automaton_Fandp0Xp1.hoa\", \"p0\" -> (s=4), \"p1\" -> \"three\" }]";
850 formulasString +=
"; P=?[HOA: {\"" STORM_TEST_RESOURCES_DIR
"/hoa/automaton_Fandp0Xp1.hoa\", \"p0\" -> (s=6), \"p1\" -> \"done\" }]";
852 formulasString +=
"; P=?[HOA: {\"" STORM_TEST_RESOURCES_DIR
"/hoa/automaton_Fandp0Xp1.hoa\", \"p0\" -> (s=6), \"p1\" -> !\"done\" }]";
854 formulasString +=
"; P=?[HOA: {\"" STORM_TEST_RESOURCES_DIR
"/hoa/automaton_Fandp0Xp1.hoa\", \"p0\" -> (s=4 | s=5), \"p1\" -> s=7 & (d=3 | d=5) }]";
856 formulasString +=
"; P>0.3[HOA: {\"" STORM_TEST_RESOURCES_DIR
"/hoa/automaton_Fandp0Xp1.hoa\", \"p0\" -> (s=4 | s=5), \"p1\" -> s=7 & (d=3 | d=5) }]";
858 auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR
"/dtmc/die.pm", formulasString);
859 auto model = std::move(modelFormulas.first);
860 auto tasks = this->getTasks(modelFormulas.second);
861 this->execute(model, [&]() {
862 EXPECT_EQ(13ul, model->getNumberOfStates());
863 EXPECT_EQ(20ul, model->getNumberOfTransitions());
865 auto checker = this->createModelChecker(model);
866 std::unique_ptr<storm::modelchecker::CheckResult> result;
869 if (TypeParam::engine == DtmcEngine::PrismSparse || TypeParam::engine == DtmcEngine::JaniSparse) {
870 result = checker->check(tasks[0]);
873 result = checker->check(tasks[1]);
876 result = checker->check(tasks[2]);
879 result = checker->check(tasks[3]);
882 result = checker->check(tasks[4]);
885 result = checker->check(tasks[5]);
888 result = checker->check(tasks[6]);
889 EXPECT_TRUE(this->getQualitativeResultAtInitialState(model, result));
891 EXPECT_FALSE(checker->canHandle(tasks[0]));
std::unique_ptr< storm::modelchecker::QualitativeCheckResult > getInitialStateFilter(std::shared_ptr< storm::models::sparse::Model< storm::Interval > > const &model)
double getQuantitativeResultAtInitialState(std::shared_ptr< storm::models::sparse::Model< storm::Interval > > const &model, std::unique_ptr< storm::modelchecker::CheckResult > &result)
void setPrecision(storm::RationalNumber value)
void setPreconditioner(storm::solver::EigenLinearEquationSolverPreconditioner value)
void setMethod(storm::solver::EigenLinearEquationSolverMethod value)
SolverEnvironment & solver()
void setMethod(storm::solver::GmmxxLinearEquationSolverMethod value)
void setPrecision(storm::RationalNumber value)
void setPreconditioner(storm::solver::GmmxxLinearEquationSolverPreconditioner value)
void setMaximalNumberOfIterations(uint64_t value)
void setMethod(storm::solver::NativeLinearEquationSolverMethod value)
void setRelativeTerminationCriterion(bool value)
void setPrecision(storm::RationalNumber value)
TopologicalSolverEnvironment & topological()
void setLinearEquationSolverType(storm::solver::EquationSolverType const &value, bool isSetFromDefault=false)
EigenSolverEnvironment & eigen()
void setForceSoundness(bool value)
NativeSolverEnvironment & native()
GmmxxSolverEnvironment & gmmxx()
void setUnderlyingEquationSolverType(storm::solver::EquationSolverType value)
static std::vector< ValueType > computeAllUntilProbabilities(Environment const &env, storm::solver::SolveGoal< ValueType > &&goal, storm::storage::SparseMatrix< ValueType > const &transitionMatrix, storm::storage::BitVector const &initialStates, storm::storage::BitVector const &phiStates, storm::storage::BitVector const &psiStates)
This class represents a discrete-time Markov chain.
This class represents a discrete-time Markov chain.
A bit vector that is internally represented as a vector of 64-bit values.
A class that holds a possibly non-square matrix in the compressed row storage format.
std::vector< storm::jani::Property > parsePropertiesForPrismProgram(std::string const &inputString, storm::prism::Program const &program, boost::optional< std::set< std::string > > const &propertyFilter)
storm::prism::Program parseProgram(std::string const &filename, bool prismCompatibility, bool simplify)
std::vector< std::shared_ptr< storm::logic::Formula const > > extractFormulasFromProperties(std::vector< storm::jani::Property > const &properties)
std::pair< storm::jani::Model, std::vector< storm::jani::Property > > convertPrismToJani(storm::prism::Program const &program, storm::converter::PrismToJaniConverterOptions options)
SFTBDDChecker::ValueType ValueType
NumberType parseNumber(std::string const &value)
Parse number from string.
storm::prism::Program preprocess(storm::prism::Program const &program, std::map< storm::expressions::Variable, storm::expressions::Expression > const &constantDefinitions)
storm::storage::BitVector filter(std::vector< T > const &values, std::function< bool(T const &value)> const &function)
Retrieves a bit vector containing all the indices for which the value at this position makes the give...
TYPED_TEST(GraphTestAR, SymbolicProb01StochasticGameDieSmall)
TYPED_TEST_SUITE(GraphTestAR, TestingTypes,)
::testing::Types< Cudd, Sylvan > TestingTypes