public void ExampleTwoStateSplitsProbabilisticThenNondeterministic()
{
NestedMarkovDecisionProcess = Examples.ExampleTwoStateSplitsProbabilisticThenNondeterministic.Create();
var converter = new NmdpToMdp(NestedMarkovDecisionProcess);
MarkovDecisionProcess = converter.MarkovDecisionProcess;
int initialDistributions;
int initialTransitions;
double initialProbabilities;
CalculateMetricsOfInitialState(out initialDistributions, out initialTransitions, out initialProbabilities);
initialDistributions.ShouldBe(1);
initialTransitions.ShouldBe(1);
initialProbabilities.ShouldBe(1.0, 0.0000001);
int state0Distributions;
int state0Transitions;
double state0Probabilities;
CalculateMetricsOfState(0, out state0Distributions, out state0Transitions, out state0Probabilities);
state0Distributions.ShouldBe(2);
state0Transitions.ShouldBe(4);
state0Probabilities.ShouldBe(2.0, 0.0000001);
}
/// <summary>
/// Calculates the probability of formula.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="formula">The state formula to be checked.</param>
/// <param name="terminateEarlyFormula">When terminateEarlyFormula is satisfied stop building the state space.</param>
/// <param name="bound">The maximal number of steps. If stateFormula is satisfied the first time any step later than bound, this probability does not count into the end result.</param>
public static ProbabilityRange CalculateProbabilityRangeOfFormulaBounded(ModelBase model, Formula formula, Formula terminateEarlyFormula, int bound)
{
ProbabilityRange probabilityRangeToReachState;
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var nmdpGenerator = new NmdpFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = TraversalConfiguration
};
nmdpGenerator.AddFormulaToCheck(formula);
var nmdp = nmdpGenerator.GenerateMarkovDecisionProcess(terminateEarlyFormula);
if (_convertNmdpToMdp)
{
var nmdpToMpd = new NmdpToMdp(nmdp);
var mdp = nmdpToMpd.MarkovDecisionProcess;
using (var modelChecker = new BuiltinMdpModelChecker(mdp, System.Console.Out))
{
probabilityRangeToReachState = modelChecker.CalculateProbabilityRange(formula);
}
}
else
{
using (var modelChecker = new BuiltinNmdpModelChecker(nmdp, System.Console.Out))
{
probabilityRangeToReachState = modelChecker.CalculateProbabilityRange(formula);
}
}
return(probabilityRangeToReachState);
}
public void CheckMdp()
{
var m = new Model();
Probability minProbabilityOfFinally2;
Probability maxProbabilityOfFinally2;
var finally2 = new UnaryFormula(new SimpleStateInRangeFormula(2), UnaryOperator.Finally);
var nmdpGenerator = new SimpleNmdpFromExecutableModelGenerator(m);
nmdpGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
nmdpGenerator.AddFormulaToCheck(finally2);
var nmdp = nmdpGenerator.GenerateMarkovDecisionProcess();
nmdp.ExportToGv(Output.TextWriterAdapter());
Output.Log("");
var nmdpToMpd = new NmdpToMdp(nmdp);
var mdp = nmdpToMpd.MarkovDecisionProcess;
mdp.ExportToGv(Output.TextWriterAdapter());
var typeOfModelChecker = typeof(BuiltinMdpModelChecker);
var modelChecker = (MdpModelChecker)Activator.CreateInstance(typeOfModelChecker, mdp, Output.TextWriterAdapter());
using (modelChecker)
{
minProbabilityOfFinally2 = modelChecker.CalculateMinimalProbability(finally2);
maxProbabilityOfFinally2 = modelChecker.CalculateMaximalProbability(finally2);
}
minProbabilityOfFinally2.Between(0.0, 0.0).ShouldBe(true);
maxProbabilityOfFinally2.Between(1.0, 1.0).ShouldBe(true);
}
public void CheckMdp()
{
var m = new Model();
Probability minProbabilityOfFinal1;
Probability minProbabilityOfFinal2;
Probability minProbabilityOfFinal3;
Probability maxProbabilityOfFinal1;
Probability maxProbabilityOfFinal2;
Probability maxProbabilityOfFinal3;
var final1Formula = new UnaryFormula(new SimpleStateInRangeFormula(1), UnaryOperator.Finally);
var final2Formula = new UnaryFormula(new SimpleStateInRangeFormula(2), UnaryOperator.Finally);
var final3Formula = new UnaryFormula(new SimpleStateInRangeFormula(3), UnaryOperator.Finally);
var nmdpGenerator = new SimpleNmdpFromExecutableModelGenerator(m);
nmdpGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
nmdpGenerator.AddFormulaToCheck(final1Formula);
nmdpGenerator.AddFormulaToCheck(final2Formula);
nmdpGenerator.AddFormulaToCheck(final3Formula);
var nmdp = nmdpGenerator.GenerateMarkovDecisionProcess();
var nmdpToMpd = new NmdpToMdp(nmdp);
var mdp = nmdpToMpd.MarkovDecisionProcess;
var typeOfModelChecker = typeof(BuiltinMdpModelChecker);
var modelChecker = (MdpModelChecker)Activator.CreateInstance(typeOfModelChecker, mdp, Output.TextWriterAdapter());
using (modelChecker)
{
minProbabilityOfFinal1 = modelChecker.CalculateMinimalProbability(final1Formula);
minProbabilityOfFinal2 = modelChecker.CalculateMinimalProbability(final2Formula);
minProbabilityOfFinal3 = modelChecker.CalculateMinimalProbability(final3Formula);
maxProbabilityOfFinal1 = modelChecker.CalculateMaximalProbability(final1Formula);
maxProbabilityOfFinal2 = modelChecker.CalculateMaximalProbability(final2Formula);
maxProbabilityOfFinal3 = modelChecker.CalculateMaximalProbability(final3Formula);
}
minProbabilityOfFinal1.Is(0.4, 0.000001).ShouldBe(true);
minProbabilityOfFinal2.Is(0.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal3.Is(0.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal1.Is(0.4, 0.000001).ShouldBe(true);
maxProbabilityOfFinal2.Is(0.6, 0.000001).ShouldBe(true);
maxProbabilityOfFinal3.Is(0.6, 0.000001).ShouldBe(true);
}
/// <summary>
/// Calculates the probability to reach a state where <paramref name="stateFormula" /> holds.
/// </summary>
/// <param name="model">The model that should be checked.</param>
/// <param name="stateFormula">The state formula which _must_ finally be true.</param>
public static ProbabilityRange CalculateProbabilityRangeToReachState(ModelBase model, Formula stateFormula)
{
ProbabilityRange probabilityRangeToReachState;
var probabilityToReachStateFormula = new UnaryFormula(stateFormula, UnaryOperator.Finally);
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var nmdpGenerator = new NmdpFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = TraversalConfiguration
};
nmdpGenerator.AddFormulaToCheck(probabilityToReachStateFormula);
nmdpGenerator.Configuration.SuccessorCapacity *= 8;
var nmdp = nmdpGenerator.GenerateMarkovDecisionProcess(stateFormula);
if (_convertNmdpToMdp)
{
var nmdpToMpd = new NmdpToMdp(nmdp);
var mdp = nmdpToMpd.MarkovDecisionProcess;
using (var modelChecker = new BuiltinMdpModelChecker(mdp, System.Console.Out))
{
probabilityRangeToReachState = modelChecker.CalculateProbabilityRange(probabilityToReachStateFormula);
}
}
else
{
using (var modelChecker = new BuiltinNmdpModelChecker(nmdp, System.Console.Out))
{
probabilityRangeToReachState = modelChecker.CalculateProbabilityRange(probabilityToReachStateFormula);
}
}
return(probabilityRangeToReachState);
}
