public void SumOfAllDistributionsOk(MarkovDecisionProcessExample example)
{
var mdp = example.Mdp;
mdp.RowsWithDistributions.PrintMatrix(Output.Log);
mdp.ValidateStates();
mdp.PrintPathWithStepwiseHighestProbability(10);
var enumerator = mdp.GetEnumerator();
var counter = 0.0;
while (enumerator.MoveNextState())
{
while (enumerator.MoveNextDistribution())
{
var counterOfTransition = 0.0;
while (enumerator.MoveNextTransition())
{
counterOfTransition += enumerator.CurrentTransition.Value;
}
Assert.Equal(1.0, counterOfTransition);
counter += counterOfTransition;
}
}
Assert.Equal(example.StateDistributions * 1.0, counter);
}
public void CalculateAncestorsTest(MarkovDecisionProcessExample example)
{
var mdp = example.Mdp;
var underlyingDigraph = mdp.CreateUnderlyingDigraph();
var nodesToIgnore = new Dictionary <int, bool>();
var result1 = underlyingDigraph.BaseGraph.GetAncestors(example.StatesSatisfyDirectlyLabel1Formula, nodesToIgnore.ContainsKey);
foreach (var result in result1.Keys)
{
Assert.True(example.AncestorsOfStatesWithLabel1.ContainsKey(result), $"state {result} not found in expected results (label1)");
}
foreach (var result in example.AncestorsOfStatesWithLabel1.Keys)
{
Assert.True(result1.ContainsKey(result), $"state {result} not found in calculated results (label1)");
}
var result2 = underlyingDigraph.BaseGraph.GetAncestors(example.StatesSatisfyDirectlyLabel2Formula, nodesToIgnore.ContainsKey);
foreach (var result in result2.Keys)
{
Assert.True(example.AncestorsOfStatesWithLabel2.ContainsKey(result), $"state {result} not found in expected results (label2)");
}
foreach (var result in example.AncestorsOfStatesWithLabel2.Keys)
{
Assert.True(result2.ContainsKey(result), $"state {result} not found in calculated results (label2)");
}
}
public void MinimalProbabilityToReach_Label1(MarkovDecisionProcessExample example)
{
var mdp = example.Mdp;
var finallyLabel1 = new UnaryFormula(MarkovDecisionProcessExample.Label1Formula, UnaryOperator.Finally);
using (var prismChecker = new ExternalMdpModelCheckerPrism(mdp, Output.TextWriterAdapter()))
{
var result = prismChecker.CalculateMinimalProbability(finallyLabel1);
result.Is(example.MinimalProbabilityFinallyLabel1, 0.0001).ShouldBe(true);
}
}
public void MaximalProbabilityToReachIn50Steps_Label1(MarkovDecisionProcessExample example)
{
var mdp = example.Mdp;
var steps = 50;
var finallyLabel1 = new BoundedUnaryFormula(MarkovDecisionProcessExample.Label1Formula, UnaryOperator.Finally, steps);
using (var checker = new BuiltinMdpModelChecker(mdp, Output.TextWriterAdapter()))
{
var result = checker.CalculateMaximalProbability(finallyLabel1);
result.Is(example.MaximalProbabilityFinallyLabel1, 0.0001).ShouldBe(true);
}
}
public void FormulaEvaluatorTest(MarkovDecisionProcessExample example)
{
var mdp = example.Mdp;
var evaluateStateFormulaLabel1 = mdp.CreateFormulaEvaluator(MarkovDecisionProcessExample.Label1Formula);
var evaluateStateFormulaLabel2 = mdp.CreateFormulaEvaluator(MarkovDecisionProcessExample.Label2Formula);
var evaluateStateFormulaExample1 = mdp.CreateFormulaEvaluator(example.ExampleFormula1);
var evaluateStateFormulaExample2 = mdp.CreateFormulaEvaluator(example.ExampleFormula2);
var satisfyStateFormulaLabel1 = 0;
var satisfyStateFormulaLabel2 = 0;
var satisfyStateFormulaExample1 = 0;
var satisfyStateFormulaExample2 = 0;
for (var i = 0; i < mdp.States; i++)
{
if (evaluateStateFormulaLabel1(i))
{
Assert.True(example.StatesSatisfyDirectlyLabel1Formula.ContainsKey(i), $"Formula is satisfied in state {i}, which is not expected (label1)");
satisfyStateFormulaLabel1++;
}
if (evaluateStateFormulaLabel2(i))
{
Assert.True(example.StatesSatisfyDirectlyLabel2Formula.ContainsKey(i), $"Formula is satisfied in state {i}, which is not expected (label2)");
satisfyStateFormulaLabel2++;
}
if (evaluateStateFormulaExample1(i))
{
Assert.True(example.StatesSatisfyDirectlyExampleFormula1.ContainsKey(i), $"Formula is satisfied in state {i}, which is not expected (exampleformula1)");
satisfyStateFormulaExample1++;
}
if (evaluateStateFormulaExample2(i))
{
Assert.True(example.StatesSatisfyDirectlyExampleFormula2.ContainsKey(i), $"Formula is satisfied in state {i}, which is not expected (exampleformula2)");
satisfyStateFormulaExample2++;
}
}
Assert.Equal(example.StatesSatisfyDirectlyLabel1Formula.Count, satisfyStateFormulaLabel1);
Assert.Equal(example.StatesSatisfyDirectlyLabel2Formula.Count, satisfyStateFormulaLabel2);
Assert.Equal(example.StatesSatisfyDirectlyExampleFormula1.Count, satisfyStateFormulaExample1);
Assert.Equal(example.StatesSatisfyDirectlyExampleFormula2.Count, satisfyStateFormulaExample2);
}
public void Prob0ATest_Label1(MarkovDecisionProcessExample example)
{
var mdp = example.Mdp;
var excludedStates = new Dictionary <long, bool>()
{
};
var directlySatisfiedStates = example.StatesSatisfyDirectlyLabel1Formula;
using (var checker = new BuiltinMdpModelChecker(mdp, Output.TextWriterAdapter()))
{
var results = checker.StatesReachableWithProbabilityExactlyZeroWithAllSchedulers(directlySatisfiedStates, excludedStates);
foreach (var result in results.Keys)
{
Assert.True(example.StatesProb0ALabel1.ContainsKey(result), $"state {result} not found in expected results");
}
foreach (var result in example.StatesProb0ALabel1.Keys)
{
Assert.True(results.ContainsKey(result), $"state {result} not found in calculated results");
}
}
}
