public void Check()
{
var m = new Model();
Probability probabilityOfFinal1;
Probability probabilityOfFinal2;
Probability probabilityOfFinal3;
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 markovChainGenerator = new SimpleDtmcFromExecutableModelGenerator(m);
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.AddFormulaToCheck(final1Formula);
markovChainGenerator.AddFormulaToCheck(final2Formula);
markovChainGenerator.AddFormulaToCheck(final3Formula);
var dtmc = markovChainGenerator.GenerateMarkovChain();
var typeOfModelChecker = typeof(BuiltinDtmcModelChecker);
var modelChecker = (DtmcModelChecker)Activator.CreateInstance(typeOfModelChecker, dtmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal1 = modelChecker.CalculateProbability(final1Formula);
probabilityOfFinal2 = modelChecker.CalculateProbability(final2Formula);
probabilityOfFinal3 = modelChecker.CalculateProbability(final3Formula);
}
probabilityOfFinal1.Is(1.0, 0.000001).ShouldBe(true);
probabilityOfFinal2.Is(1.0, 0.000001).ShouldBe(true);
probabilityOfFinal3.Is(1.0, 0.000001).ShouldBe(true);
}
/// <summary>
/// Visits the <paramref name="formula" />.
/// </summary>
public override void VisitUnaryFormula(UnaryFormula formula)
{
switch (formula.Operator)
{
case UnaryOperator.Next:
case UnaryOperator.Finally:
case UnaryOperator.Globally:
throw new InvalidOperationException($"Path Operator only allowed in Path Formulas.");
break;
case UnaryOperator.Not:
_builder.Append("(");
_builder.Append(" ! ");
Visit(formula.Operand);
_builder.Append(")");
break;
case UnaryOperator.All:
VisitForAllPathFormula(formula.Operand);
break;
case UnaryOperator.Exists:
VisitExistsPathFormula(formula.Operand);
break;
default:
Assert.NotReached($"Unknown or unsupported unary operator '{formula.Operator}'.");
break;
}
}
public void StepwiseProbablityOfLabel2ForExample4()
{
var example = new Example4();
var dtmc = example.MarkovChain;
var results = new List <Probability>();
using (var prismChecker = new BuiltinDtmcModelChecker(dtmc, Output.TextWriterAdapter()))
{
for (var i = 0; i <= 10; i++)
{
var boundedStepi = new BoundedUnaryFormula(MarkovChainExample.Label2Formula, UnaryOperator.Finally, i);
var resultBoundedStepi = prismChecker.CalculateProbability(boundedStepi);
Output.Log($"Result {i}:\t{resultBoundedStepi}");
results.Add(resultBoundedStepi);
}
var boundedStep200 = new BoundedUnaryFormula(MarkovChainExample.Label2Formula, UnaryOperator.Finally, 200);
var resultBoundedStep200 = prismChecker.CalculateProbability(boundedStep200);
Output.Log($"Result {200}:\t{resultBoundedStep200}");
var inf = new UnaryFormula(MarkovChainExample.Label2Formula, UnaryOperator.Finally);
var resultInf = prismChecker.CalculateProbability(inf);
Output.Log($"Result inf:\t{resultInf}");
}
}
public void CheckWithEarlyTermination()
{
var m = new Model();
Probability probabilityOfFinally3;
var stateIs3 = new SimpleStateInRangeFormula(3);
var finally3 = new UnaryFormula(stateIs3, UnaryOperator.Finally);
var markovChainGenerator = new SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.Configuration.EnableEarlyTermination = true;
markovChainGenerator.AddFormulaToCheck(finally3);
var dtmc = markovChainGenerator.GenerateMarkovChain();
dtmc.ExportToGv(Output.TextWriterAdapter());
var typeOfModelChecker = typeof(BuiltinDtmcModelChecker);
var modelChecker = (DtmcModelChecker)Activator.CreateInstance(typeOfModelChecker, dtmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinally3 = modelChecker.CalculateProbability(finally3);
}
Assert.Equal(5, dtmc.States);
Assert.Equal(5, dtmc.Transitions);
probabilityOfFinally3.Between(0.66, 0.67).ShouldBe(true);
}
protected void CheckNmdp()
{
var m = new Model();
Probability minProbabilityOfFinal1;
Probability maxProbabilityOfFinal1;
var finally1 = new UnaryFormula(Model.StateIs1, UnaryOperator.Finally);
var nmdpGenerator = new SimpleNmdpFromExecutableModelGenerator(m);
nmdpGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
nmdpGenerator.AddFormulaToCheck(finally1);
var nmdp = nmdpGenerator.GenerateMarkovDecisionProcess();
var typeOfModelChecker = typeof(BuiltinNmdpModelChecker);
var modelChecker = (NmdpModelChecker)Activator.CreateInstance(typeOfModelChecker, nmdp, Output.TextWriterAdapter());
using (modelChecker)
{
minProbabilityOfFinal1 = modelChecker.CalculateMinimalProbability(finally1);
maxProbabilityOfFinal1 = modelChecker.CalculateMaximalProbability(finally1);
}
minProbabilityOfFinal1.Is(0.65, 0.000001).ShouldBe(true);
maxProbabilityOfFinal1.Is(0.65, 0.000001).ShouldBe(true);
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitUnaryFormula(UnaryFormula formula)
{
if (formula.Operator == UnaryOperator.Not)
Visit(formula.Operand);
else
_containsInvalidOperators = true;
}
public void CheckOnceWithNonAtomarOperand()
{
var m = new Model();
Probability probability;
var once7MoreComplex = new BinaryFormula(Model.IsInState7, BinaryOperator.And, Model.IsInState7);
var once7Formula = new UnaryFormula(once7MoreComplex, UnaryOperator.Once);
var is9Once7Formula = new BinaryFormula(Model.IsInState9, BinaryOperator.And, once7Formula);
var final9Once7Formula = new UnaryFormula(is9Once7Formula, UnaryOperator.Finally);
var markovChainGenerator = new SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = true;
markovChainGenerator.Configuration.DefaultTraceOutput = Output.TextWriterAdapter();
markovChainGenerator.Configuration.WriteGraphvizModels = true;
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = true;
markovChainGenerator.AddFormulaToCheck(final9Once7Formula);
var dtmc = markovChainGenerator.GenerateMarkovChain();
var typeOfModelChecker = typeof(BuiltinDtmcModelChecker);
var modelChecker = (DtmcModelChecker)Activator.CreateInstance(typeOfModelChecker, dtmc, Output.TextWriterAdapter());
using (modelChecker)
{
probability = modelChecker.CalculateProbability(final9Once7Formula);
}
probability.Is(0.4 * 0.4 + 0.6, 0.00000001).ShouldBe(true);
}
public void CheckNmdp()
{
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());
var typeOfModelChecker = typeof(BuiltinNmdpModelChecker);
var modelChecker = (NmdpModelChecker)Activator.CreateInstance(typeOfModelChecker, nmdp, 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);
}
/// <summary>
/// Visits the <paramref name="formula" />.
/// </summary>
public override void VisitUnaryFormula(UnaryFormula formula)
{
_builder.Append("(");
switch (formula.Operator)
{
case UnaryOperator.Next:
_builder.Append(" X ");
break;
case UnaryOperator.Finally:
_builder.Append(" <> ");
break;
case UnaryOperator.Globally:
_builder.Append(" [] ");
break;
case UnaryOperator.Not:
_builder.Append(" ! ");
break;
default:
Assert.NotReached($"Unknown or unsupported unary operator '{formula.Operator}'.");
break;
}
Visit(formula.Operand);
_builder.Append(")");
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitUnaryFormula(UnaryFormula formula)
{
if (formula.Operator == UnaryOperator.All || formula.Operator == UnaryOperator.Exists)
_containsInvalidOperators = true;
else
Visit(formula.Operand);
}
/// <summary>
/// Initizializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
Func <AnalysisModel> createAnalysisModelFunc = () =>
new ActivationMinimalExecutedModel <TExecutableModel>(RuntimeModelCreator, 0, configuration);
var createAnalysisModel = new AnalysisModelCreator(createAnalysisModelFunc);
var invariant = new UnaryFormula(hazard, UnaryOperator.Not);
_invariantChecker = new InvariantChecker(createAnalysisModel, configuration, invariant);
}
/// <summary>
/// Initizializes the model that should be analyzed.
/// </summary>
/// <param name="configuration">The configuration that should be used for the analyses.</param>
/// <param name="hazard">The hazard that should be analyzed.</param>
protected override void InitializeModel(AnalysisConfiguration configuration, Formula hazard)
{
Func <AnalysisModel <TExecutableModel> > createAnalysisModelFunc = () =>
new ActivationMinimalExecutedModel <TExecutableModel>(RuntimeModelCreator, _stateHeaderBytes, configuration.SuccessorCapacity);
var createAnalysisModel = new AnalysisModelCreator <TExecutableModel>(createAnalysisModelFunc);
var invariant = new UnaryFormula(hazard, UnaryOperator.Not);
_invariantChecker = new InvariantChecker <TExecutableModel>(createAnalysisModel, OnOutputWritten, configuration, invariant);
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitUnaryFormula(UnaryFormula formula)
{
if (formula.Operator == UnaryOperator.All || formula.Operator == UnaryOperator.Exists)
{
_containsInvalidOperators = true;
}
else
{
Visit(formula.Operand);
}
}
public void ProbabilityToReach_Label1(MarkovChainExample example)
{
var dtmc = example.MarkovChain;
var finallyLabel1 = new UnaryFormula(MarkovChainExample.Label1Formula, UnaryOperator.Finally);
using (var checker = new ExternalDtmcModelCheckerMrmc(dtmc, Output.TextWriterAdapter()))
{
var result = checker.CalculateProbability(finallyLabel1);
result.Is(example.ProbabilityFinallyLabel1, 0.0001).ShouldBe(true);
}
}
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);
}
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitUnaryFormula(UnaryFormula formula)
{
switch (formula.Operator)
{
case UnaryOperator.Not:
Visit(formula.Operand);
_expression = Expression.Not(_expression);
break;
default:
throw new InvalidOperationException("Only state formulas can be evaluated.");
}
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitUnaryFormula(UnaryFormula formula)
{
switch (formula.Operator)
{
case UnaryOperator.Not:
Visit(formula.Operand);
_expression = Expression.Not(_expression);
break;
default:
throw new InvalidOperationException("Only state formulas can be evaluated.");
}
}
private void CheckUnbounded(AnalysisConfiguration configuration)
{
var m = new SharedModels.SimpleExample2a();
Probability minProbabilityOfFinal0;
Probability minProbabilityOfFinal0Lt;
Probability minProbabilityOfFinal1;
Probability minProbabilityOfFinal2;
Probability maxProbabilityOfFinal0;
Probability maxProbabilityOfFinal0Lt;
Probability maxProbabilityOfFinal1;
Probability maxProbabilityOfFinal2;
var final0Formula = new UnaryFormula(SharedModels.SimpleExample2a.StateIs0, UnaryOperator.Finally);
var final0LtFormula =
new BoundedUnaryFormula(
new BinaryFormula(SharedModels.SimpleExample2a.StateIs0, BinaryOperator.And, SharedModels.SimpleExample2a.LocalVarIsTrue),
UnaryOperator.Finally, 4);
var final1Formula = new UnaryFormula(SharedModels.SimpleExample2a.StateIs1, UnaryOperator.Finally);
var final2Formula = new UnaryFormula(SharedModels.SimpleExample2a.StateIs2, UnaryOperator.Finally);
var mdpGenerator = new SimpleMarkovDecisionProcessFromExecutableModelGenerator(m);
mdpGenerator.Configuration = configuration;
mdpGenerator.AddFormulaToCheck(final0Formula);
mdpGenerator.AddFormulaToCheck(final0LtFormula);
mdpGenerator.AddFormulaToCheck(final1Formula);
mdpGenerator.AddFormulaToCheck(final2Formula);
var mdp = mdpGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
var modelChecker = new ConfigurationDependentLtmdpModelChecker(configuration, mdp, Output.TextWriterAdapter());
using (modelChecker)
{
minProbabilityOfFinal0 = modelChecker.CalculateMinimalProbability(final0Formula);
minProbabilityOfFinal0Lt = modelChecker.CalculateMinimalProbability(final0LtFormula);
minProbabilityOfFinal1 = modelChecker.CalculateMinimalProbability(final1Formula);
minProbabilityOfFinal2 = modelChecker.CalculateMinimalProbability(final2Formula);
maxProbabilityOfFinal0 = modelChecker.CalculateMaximalProbability(final0Formula);
maxProbabilityOfFinal0Lt = modelChecker.CalculateMaximalProbability(final0LtFormula);
maxProbabilityOfFinal1 = modelChecker.CalculateMaximalProbability(final1Formula);
maxProbabilityOfFinal2 = modelChecker.CalculateMaximalProbability(final2Formula);
}
minProbabilityOfFinal0.Is(1.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal0Lt.Is(0.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal1.Is(0.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal2.Is(0.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal0.Is(1.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal0Lt.Is(1.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal1.Is(1.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal2.Is(1.0, 0.000001).ShouldBe(true);
}
public void Parametric()
{
Formula invariant = new LustrePressureBelowThreshold();
Formula hazard = new UnaryFormula(invariant, UnaryOperator.Not);
LustrePressureBelowThreshold.threshold = 60;
var faultK1 = new PermanentFault()
{
Name = "fault_k1", Identifier = 1, ProbabilityOfOccurrence = new Probability(3.0E-6)
};
var faultK2 = new PermanentFault()
{
Name = "fault_k2", Identifier = 2, ProbabilityOfOccurrence = new Probability(3.0E-6)
};
var faultSensor = new PermanentFault()
{
Name = "fault_sensor", Identifier = 4, ProbabilityOfOccurrence = new Probability(1.0E-5)
};
var faults = new[] { faultK1, faultK2, faultSensor };
var parameter = new QuantitativeParametricAnalysisParameter
{
StateFormula = hazard,
Bound = null,
From = 3.0E-7,
To = 3.0E-5,
Steps = 25,
};
using (var fileWriter = new StreamWriter(Path.Combine(AssemblyDirectory, "pressureTank_varyK1.csv"), append: false))
{
parameter.UpdateParameterInModel = value => { faultK1.ProbabilityOfOccurrence = new Probability(value); };
var result = LustreModelChecker.ConductQuantitativeParametricAnalysis(Path.Combine(AssemblyDirectory, "pressureTank.lus"), "TANK", faults, parameter);
result.ToCsv(fileWriter);
}
using (var fileWriter = new StreamWriter(Path.Combine(AssemblyDirectory, "pressureTank_varyK2.csv"), append: false))
{
parameter.UpdateParameterInModel = value => { faultK2.ProbabilityOfOccurrence = new Probability(value); };
var result = LustreModelChecker.ConductQuantitativeParametricAnalysis(Path.Combine(AssemblyDirectory, "pressureTank.lus"), "TANK", faults, parameter);
result.ToCsv(fileWriter);
}
using (var fileWriter = new StreamWriter(Path.Combine(AssemblyDirectory, "pressureTank_varySensor.csv"), append: false))
{
parameter.UpdateParameterInModel = value => { faultSensor.ProbabilityOfOccurrence = new Probability(value); };
var result = LustreModelChecker.ConductQuantitativeParametricAnalysis(Path.Combine(AssemblyDirectory, "pressureTank.lus"), "TANK", faults, parameter);
result.ToCsv(fileWriter);
}
}
public void TankRupture()
{
Formula invariant = new LustrePressureBelowThreshold();
Formula hazard = new UnaryFormula(invariant, UnaryOperator.Not);
LustrePressureBelowThreshold.threshold = 60;
var faults = new List <Fault>
{
new TransientFault()
{
Name = "fault_switch", Identifier = 0, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_k1", Identifier = 1, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_k2", Identifier = 2, ProbabilityOfOccurrence = null
},
new PermanentFault()
{
Name = "fault_timer", Identifier = 3, ProbabilityOfOccurrence = new Probability(1.0E-5)
},
new PermanentFault()
{
Name = "fault_sensor", Identifier = 4, ProbabilityOfOccurrence = new Probability(1.0E-5)
}
};
var createModel = LustreExecutableModel.CreateExecutedModelFromFormulasCreator(Path.Combine(AssemblyDirectory, "pressureTank.lus"), "TANK", faults.ToArray());
var markovChainGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <LustreExecutableModel>(createModel);
markovChainGenerator.Configuration.ModelCapacity = new ModelCapacityByModelSize(10000, 1000000);
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = true;
markovChainGenerator.Configuration.LtmdpModelChecker = LtmdpModelChecker.BuiltInLtmdp;
markovChainGenerator.AddFormulaToCheck(hazard);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
var ltmcModelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, Console.Out);
var finallyHazard = new BoundedUnaryFormula(hazard, UnaryOperator.Finally, 200);
var result = ltmcModelChecker.CalculateProbabilityRange(finallyHazard);
Console.Write($"Probability of hazard: {result}");
}
public void CalculateHazardSingleCoreAllFaultsWithOnce()
{
var model = new Model();
SetProbabilities(model);
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.CpuCount = 1;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var onceUnsuccessful = new UnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Once);
var onceContamination = new UnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Once);
var onceFault1 = new UnaryFormula(new FaultFormula(model.HdMachine.Dialyzer.DialyzerMembraneRupturesFault), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(onceFault1);
foreach (var fault in model.Faults.Where(fault => fault != model.HdMachine.Dialyzer.DialyzerMembraneRupturesFault))
{
var faultFormula = new UnaryFormula(new FaultFormula(fault), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
var finallyUnsuccessful = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceUnsuccessful), UnaryOperator.Finally, 6);
var finallyContamination = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceContamination), UnaryOperator.Finally, 6);
markovChainGenerator.AddFormulaToCheck(finallyUnsuccessful);
markovChainGenerator.AddFormulaToCheck(finallyContamination);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(finallyUnsuccessful);
Console.Write($"Probability of unsuccessful: {result}");
}
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(finallyContamination);
Console.Write($"Probability of contamination: {result}");
}
}
public void Check()
{
var m = new Model();
var formulaNotTwo = new UnaryFormula(Model.StateIsTwo, UnaryOperator.Not);
var checker = new SimpleQualitativeChecker(m, formulaNotTwo)
{
Configuration = AnalysisConfiguration.Default
};
checker.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
checker.Configuration.DefaultTraceOutput = Output.TextWriterAdapter();
var result = checker.CheckInvariant(formulaNotTwo);
result.FormulaHolds.ShouldBe(true);
}
public void Check()
{
var m = new Model();
Probability probabilityOfStep11FrozenValue0AndInvariantViolated;
Probability probabilityOfStep11FrozenValue1AndInvariantViolated;
Probability probabilityOfStep11FrozenValue0AndInvariantNotViolated;
Probability probabilityOfStep11FrozenValue1AndInvariantNotViolated;
Formula formulaProbabilityOfStep11FrozenValue0AndInvariantViolated = new BinaryFormula(new SimpleStateInRangeFormula(10), BinaryOperator.And, new SimpleLocalVarIsTrue(0));
Formula formulaProbabilityOfStep11FrozenValue1AndInvariantViolated = new BinaryFormula(new SimpleStateInRangeFormula(10 + 128), BinaryOperator.And, new SimpleLocalVarIsTrue(0));
Formula formulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated = new BinaryFormula(new SimpleStateInRangeFormula(10), BinaryOperator.And, new UnaryFormula(new SimpleLocalVarIsTrue(0), UnaryOperator.Not));
Formula formulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated = new BinaryFormula(new SimpleStateInRangeFormula(10 + 128), BinaryOperator.And, new UnaryFormula(new SimpleLocalVarIsTrue(0), UnaryOperator.Not));
var finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue0AndInvariantViolated, UnaryOperator.Finally);
var finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue1AndInvariantViolated, UnaryOperator.Finally);
var finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated, UnaryOperator.Finally);
var finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated, UnaryOperator.Finally);
var markovChainGenerator = new SimpleDtmcFromExecutableModelGenerator(m);
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantViolated);
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantViolated);
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated);
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated);
var dtmc = markovChainGenerator.GenerateMarkovChain();
dtmc.ExportToGv(Output.TextWriterAdapter());
var typeOfModelChecker = typeof(BuiltinDtmcModelChecker);
var modelChecker = (DtmcModelChecker)Activator.CreateInstance(typeOfModelChecker, dtmc, Output.TextWriterAdapter()); using (modelChecker)
{
probabilityOfStep11FrozenValue0AndInvariantViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantViolated);
probabilityOfStep11FrozenValue1AndInvariantViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantViolated);
probabilityOfStep11FrozenValue0AndInvariantNotViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated);
probabilityOfStep11FrozenValue1AndInvariantNotViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated);
}
var probabilitiesSummedUp =
probabilityOfStep11FrozenValue0AndInvariantViolated +
probabilityOfStep11FrozenValue1AndInvariantViolated +
probabilityOfStep11FrozenValue0AndInvariantNotViolated +
probabilityOfStep11FrozenValue1AndInvariantNotViolated;
probabilitiesSummedUp.Is(1.0, 0.000001).ShouldBe(true);
}
protected override void Check()
{
var c = new C();
Probability probabilityOfStep11FrozenValue2AndInvariantViolated;
Probability probabilityOfStep11FrozenValue3AndInvariantViolated;
Probability probabilityOfStep11FrozenValue2AndInvariantNotViolated;
Probability probabilityOfStep11FrozenValue3AndInvariantNotViolated;
Formula formulaProbabilityOfStep11FrozenValue2AndInvariantViolated = c._timestep == 11 && c._frozenValue == 2 && c.ViolateInvariant;
Formula formulaProbabilityOfStep11FrozenValue3AndInvariantViolated = c._timestep == 11 && c._frozenValue == 3 && c.ViolateInvariant;
Formula formulaProbabilityOfStep11FrozenValue2AndInvariantNotViolated = c._timestep == 11 && c._frozenValue == 2 && !c.ViolateInvariant;
Formula formulaProbabilityOfStep11FrozenValue3AndInvariantNotViolated = c._timestep == 11 && c._frozenValue == 3 && !c.ViolateInvariant;
var finallyFormulaProbabilityOfStep11FrozenValue2AndInvariantViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue2AndInvariantViolated, UnaryOperator.Finally);
var finallyFormulaProbabilityOfStep11FrozenValue3AndInvariantViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue3AndInvariantViolated, UnaryOperator.Finally);
var finallyFormulaProbabilityOfStep11FrozenValue2AndInvariantNotViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue2AndInvariantNotViolated, UnaryOperator.Finally);
var finallyFormulaProbabilityOfStep11FrozenValue3AndInvariantNotViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue3AndInvariantNotViolated, UnaryOperator.Finally);
var markovChainGenerator = new SafetySharpMarkovChainFromExecutableModelGenerator(TestModel.InitializeModel(c));
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.Configuration.LtmcModelChecker = (ISSE.SafetyChecking.LtmcModelChecker)Arguments[0];
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue2AndInvariantViolated);
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue3AndInvariantViolated);
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue2AndInvariantNotViolated);
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue3AndInvariantNotViolated);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfStep11FrozenValue2AndInvariantViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue2AndInvariantViolated);
probabilityOfStep11FrozenValue3AndInvariantViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue3AndInvariantViolated);
probabilityOfStep11FrozenValue2AndInvariantNotViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue2AndInvariantNotViolated);
probabilityOfStep11FrozenValue3AndInvariantNotViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue3AndInvariantNotViolated);
}
var probabilitiesSummedUp =
probabilityOfStep11FrozenValue2AndInvariantViolated +
probabilityOfStep11FrozenValue3AndInvariantViolated +
probabilityOfStep11FrozenValue2AndInvariantNotViolated +
probabilityOfStep11FrozenValue3AndInvariantNotViolated;
probabilitiesSummedUp.Is(1.0, 0.000001).ShouldBe(true);
}
public void CalculateLtmdpWithoutStaticPruningSingleCore()
{
var model = new Model();
SetProbabilities(model);
model.HdMachine.Dialyzer.DialyzerMembraneRupturesFault.ProbabilityOfOccurrence = null;
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovDecisionProcessFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.LtmdpModelChecker = LtmdpModelChecker.BuiltInLtmdp;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var unsuccessful = new UnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Finally);
var contamination = new UnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Finally);
markovChainGenerator.AddFormulaToCheck(unsuccessful);
markovChainGenerator.AddFormulaToCheck(contamination);
foreach (var fault in model.Faults)
{
var faultFormula = new FaultFormula(fault);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.CpuCount = 1;
var markovChain = markovChainGenerator.GenerateLabeledTransitionMarkovDecisionProcess();
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbabilityRange(unsuccessful);
Console.Write($"Probability of unsuccessful: {result}");
}
using (var modelChecker = new ConfigurationDependentLtmdpModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbabilityRange(contamination);
Console.Write($"Probability of contamination: {result}");
}
}
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();
nmdp.ExportToGv(Output.TextWriterAdapter());
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(1.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal2.Is(0.0, 0.000001).ShouldBe(true);
minProbabilityOfFinal3.Is(0.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal1.Is(1.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal2.Is(1.0, 0.000001).ShouldBe(true);
maxProbabilityOfFinal3.Is(1.0, 0.000001).ShouldBe(true);
}
public void CalculateHazardSingleCoreWithOncePositionDetectorMis()
{
var model = Model.CreateOriginal();
SetProbabilities(model);
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = SafetySharpModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.CpuCount = 1;
markovChainGenerator.Configuration.ModelCapacity = new ModelCapacityByModelSize(3300000L, 1000000000L);
var onceFault1 = new UnaryFormula(new FaultFormula(model.HeightControl.PreControl.PositionDetector.Misdetection), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(onceFault1);
var onceCollision = new UnaryFormula(model.Collision, UnaryOperator.Once);
var onceFalseAlarm = new UnaryFormula(model.FalseAlarm, UnaryOperator.Once);
var finallyCollision = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceCollision), UnaryOperator.Finally, 50);
var finallyFalseAlarm = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceFalseAlarm), UnaryOperator.Finally, 50);
markovChainGenerator.AddFormulaToCheck(finallyCollision);
markovChainGenerator.AddFormulaToCheck(finallyFalseAlarm);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var markovChain = markovChainGenerator.GenerateMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, ltmc, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(finallyCollision);
Console.Write($"Probability of collision: {result}");
}
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, ltmc, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(finallyFalseAlarm);
Console.Write($"Probability of falseAlarm: {result}");
}
}
private void Check(AnalysisConfiguration configuration)
{
var m = new Model();
Probability probabilityOfStep11FrozenValue0AndInvariantViolated;
Probability probabilityOfStep11FrozenValue1AndInvariantViolated;
Probability probabilityOfStep11FrozenValue0AndInvariantNotViolated;
Probability probabilityOfStep11FrozenValue1AndInvariantNotViolated;
Formula formulaProbabilityOfStep11FrozenValue0AndInvariantViolated = new BinaryFormula(new SimpleStateInRangeFormula(10), BinaryOperator.And, new SimpleLocalVarIsTrue(0));
Formula formulaProbabilityOfStep11FrozenValue1AndInvariantViolated = new BinaryFormula(new SimpleStateInRangeFormula(10 + 128), BinaryOperator.And, new SimpleLocalVarIsTrue(0));
Formula formulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated = new BinaryFormula(new SimpleStateInRangeFormula(10), BinaryOperator.And, new UnaryFormula(new SimpleLocalVarIsTrue(0), UnaryOperator.Not));
Formula formulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated = new BinaryFormula(new SimpleStateInRangeFormula(10 + 128), BinaryOperator.And, new UnaryFormula(new SimpleLocalVarIsTrue(0), UnaryOperator.Not));
var finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue0AndInvariantViolated, UnaryOperator.Finally);
var finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue1AndInvariantViolated, UnaryOperator.Finally);
var finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated, UnaryOperator.Finally);
var finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated = new UnaryFormula(formulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated, UnaryOperator.Finally);
var markovChainGenerator = new SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration = configuration;
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantViolated);
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantViolated);
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated);
markovChainGenerator.AddFormulaToCheck(finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(configuration, ltmc, Output.TextWriterAdapter());
{
probabilityOfStep11FrozenValue0AndInvariantViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantViolated);
probabilityOfStep11FrozenValue1AndInvariantViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantViolated);
probabilityOfStep11FrozenValue0AndInvariantNotViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue0AndInvariantNotViolated);
probabilityOfStep11FrozenValue1AndInvariantNotViolated = modelChecker.CalculateProbability(finallyFormulaProbabilityOfStep11FrozenValue1AndInvariantNotViolated);
}
var probabilitiesSummedUp =
probabilityOfStep11FrozenValue0AndInvariantViolated +
probabilityOfStep11FrozenValue1AndInvariantViolated +
probabilityOfStep11FrozenValue0AndInvariantNotViolated +
probabilityOfStep11FrozenValue1AndInvariantNotViolated;
probabilitiesSummedUp.Is(1.0, 0.000001).ShouldBe(true);
}
public void Check()
{
var m = new SharedModels.SimpleExample2a();
Probability probabilityOfFinal0;
Probability probabilityOfFinal0Lt;
Probability probabilityOfFinal1;
Probability probabilityOfFinal2;
var final0Formula = new UnaryFormula(SharedModels.SimpleExample2a.StateIs0, UnaryOperator.Finally);
var final0LtFormula =
new UnaryFormula(
new BinaryFormula(SharedModels.SimpleExample2a.StateIs0, BinaryOperator.And, SharedModels.SimpleExample2a.LocalVarIsTrue),
UnaryOperator.Finally);
var final1Formula = new UnaryFormula(SharedModels.SimpleExample2a.StateIs1, UnaryOperator.Finally);
var final2Formula = new UnaryFormula(SharedModels.SimpleExample2a.StateIs2, UnaryOperator.Finally);
var markovChainGenerator = new SimpleDtmcFromExecutableModelGenerator(m);
markovChainGenerator.Configuration.WriteGraphvizModels = true;
markovChainGenerator.Configuration.DefaultTraceOutput = Output.TextWriterAdapter();
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.Configuration.UseAtomarPropositionsAsStateLabels = false;
markovChainGenerator.AddFormulaToCheck(final0Formula);
markovChainGenerator.AddFormulaToCheck(final0LtFormula);
markovChainGenerator.AddFormulaToCheck(final1Formula);
markovChainGenerator.AddFormulaToCheck(final2Formula);
var dtmc = markovChainGenerator.GenerateMarkovChain();
var typeOfModelChecker = typeof(BuiltinDtmcModelChecker);
var modelChecker = (DtmcModelChecker)Activator.CreateInstance(typeOfModelChecker, dtmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal0 = modelChecker.CalculateProbability(final0Formula);
probabilityOfFinal0Lt = modelChecker.CalculateProbability(final0LtFormula);
probabilityOfFinal1 = modelChecker.CalculateProbability(final1Formula);
probabilityOfFinal2 = modelChecker.CalculateProbability(final2Formula);
}
probabilityOfFinal0.Is(1.0, 0.000001).ShouldBe(true);
probabilityOfFinal0Lt.Is(0.55 / 3.0 * 4.0, 0.000001).ShouldBe(true);
probabilityOfFinal1.Is(0.5, 0.000001).ShouldBe(true);
probabilityOfFinal2.Is(0.5, 0.000001).ShouldBe(true);
}
public void Check()
{
Probability probabilityOfFinal1;
Probability probabilityOfFinal2;
Probability probabilityOfFinal3;
Probability probabilityOfFinal4;
var m = new Model();
var formula1 = new BinaryFormula(Model.FIs2, BinaryOperator.Or, Model.FIs3);
var formula2 = Model.FIs1;
var formula3 = new BinaryFormula(new BinaryFormula(Model.GIs0, BinaryOperator.Or, Model.GIs7), BinaryOperator.Or, Model.GIs8);
var formula4 = Model.GIs7;
var final1 = new UnaryFormula(formula1, UnaryOperator.Finally);
var final2 = new UnaryFormula(formula2, UnaryOperator.Finally);
var final3 = new UnaryFormula(formula3, UnaryOperator.Finally);
var final4 = new UnaryFormula(formula4, UnaryOperator.Finally);
var markovChainGenerator = new SimpleDtmcFromExecutableModelGenerator(m);
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.AddFormulaToCheck(final1);
markovChainGenerator.AddFormulaToCheck(final2);
markovChainGenerator.AddFormulaToCheck(final3);
markovChainGenerator.AddFormulaToCheck(final4);
var dtmc = markovChainGenerator.GenerateMarkovChain();
var typeOfModelChecker = typeof(BuiltinDtmcModelChecker);
var modelChecker = (DtmcModelChecker)Activator.CreateInstance(typeOfModelChecker, dtmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal1 = modelChecker.CalculateProbability(final1);
probabilityOfFinal2 = modelChecker.CalculateProbability(final2);
probabilityOfFinal3 = modelChecker.CalculateProbability(final3);
probabilityOfFinal4 = modelChecker.CalculateProbability(final4);
}
probabilityOfFinal1.Is(0.0, tolerance: 0.0001).ShouldBe(true);
probabilityOfFinal2.Is(1.0, tolerance: 0.0001).ShouldBe(true);
probabilityOfFinal3.Is(1.0, tolerance: 0.0001).ShouldBe(true);
probabilityOfFinal4.Is(0.8333333333, tolerance: 0.0001).ShouldBe(true);
}
private void Check(AnalysisConfiguration configuration)
{
Probability probabilityOfFinal1;
Probability probabilityOfFinal2;
Probability probabilityOfFinal3;
Probability probabilityOfFinal4;
var m = new Model();
var formula1 = new BinaryFormula(Model.FIs2, BinaryOperator.Or, Model.FIs3);
var formula2 = Model.FIs1;
var formula3 = new BinaryFormula(new BinaryFormula(Model.GIs0, BinaryOperator.Or, Model.GIs7), BinaryOperator.Or, Model.GIs8);
var formula4 = Model.GIs7;
var final1 = new UnaryFormula(formula1, UnaryOperator.Finally);
var final2 = new UnaryFormula(formula2, UnaryOperator.Finally);
var final3 = new UnaryFormula(formula3, UnaryOperator.Finally);
var final4 = new UnaryFormula(formula4, UnaryOperator.Finally);
var markovChainGenerator = new SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration = configuration;
markovChainGenerator.AddFormulaToCheck(final1);
markovChainGenerator.AddFormulaToCheck(final2);
markovChainGenerator.AddFormulaToCheck(final3);
markovChainGenerator.AddFormulaToCheck(final4);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal1 = modelChecker.CalculateProbability(final1);
probabilityOfFinal2 = modelChecker.CalculateProbability(final2);
probabilityOfFinal3 = modelChecker.CalculateProbability(final3);
probabilityOfFinal4 = modelChecker.CalculateProbability(final4);
}
probabilityOfFinal1.Is(0.0, tolerance: 0.0001).ShouldBe(true);
probabilityOfFinal2.Is(1.0, tolerance: 0.0001).ShouldBe(true);
probabilityOfFinal3.Is(1.0, tolerance: 0.0001).ShouldBe(true);
probabilityOfFinal4.Is(0.8333333333, tolerance: 0.0001).ShouldBe(true);
}
protected override void Check()
{
{
var actual = !(X(true));
var expected = new UnaryFormula(
new UnaryFormula(new ExecutableStateFormula(() => true), UnaryOperator.Next),
UnaryOperator.Not);
Check(actual, expected);
}
{
var actual = !X(true);
var expected = new UnaryFormula(
new UnaryFormula(new ExecutableStateFormula(() => true), UnaryOperator.Next),
UnaryOperator.Not);
Check(actual, expected);
}
}
public Sequent Apply(Sequent sequent)
{
UnaryFormula implicationFormula = (UnaryFormula)sequent.LeftHandSide.Formulas.Where(
x => x is UnaryFormula formula && formula.Connective == UnaryConnective.Negation
).FirstOrDefault();
if (implicationFormula == null)
{
return(null);
}
sequent.LeftHandSide.Formulas.Remove(implicationFormula);
var formula = implicationFormula.Formula.Clone();
sequent.RightHandSide.Formulas.Add(formula);
sequent.Justification = "R5 (" + sequent.Name + ")";
return(sequent);
}
public void TankRupture()
{
Formula invariant = new LustrePressureBelowThreshold();
Formula hazard = new UnaryFormula(invariant, UnaryOperator.Not);
LustrePressureBelowThreshold.threshold = 60;
var faults = new List <Fault>
{
new TransientFault()
{
Name = "fault_switch", Identifier = 0, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_k1", Identifier = 1, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_k2", Identifier = 2, ProbabilityOfOccurrence = new Probability(3.0E-6)
},
new PermanentFault()
{
Name = "fault_timer", Identifier = 3, ProbabilityOfOccurrence = new Probability(1.0E-5)
},
new PermanentFault()
{
Name = "fault_sensor", Identifier = 4, ProbabilityOfOccurrence = new Probability(1.0E-5)
}
};
var modelChecker = new LustreMarkovChainFromExecutableModelGenerator(Path.Combine(AssemblyDirectory, "pressureTank.lus"), "TANK", faults);
modelChecker.AddFormulaToCheck(hazard);
modelChecker.Configuration.UseCompactStateStorage = true;
var lmc = modelChecker.GenerateLabeledMarkovChain();
var ltmcModelChecker = new BuiltinLtmcModelChecker(lmc, Console.Out);
var finallyHazard = new BoundedUnaryFormula(hazard, UnaryOperator.Finally, 200);
var result = ltmcModelChecker.CalculateProbability(finallyHazard);
Console.Write($"Probability of hazard: {result}");
}
private Probability Check(AnalysisConfiguration configuration)
{
var m = new Model();
Probability probabilityOfInvariantViolation;
var finallyInvariantViolated = new UnaryFormula(Model.InvariantViolated, UnaryOperator.Finally);
var markovChainGenerator = new SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration = configuration;
markovChainGenerator.AddFormulaToCheck(finallyInvariantViolated);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfInvariantViolation = modelChecker.CalculateProbability(finallyInvariantViolated);
}
return(probabilityOfInvariantViolation);
}
/// <summary>
/// Visits an element of type <see cref="UnaryFormula" />.
/// </summary>
/// <param name="formula">The <see cref="UnaryFormula" /> instance that should be visited.</param>
protected internal virtual void VisitUnaryFormula(UnaryFormula formula)
{
DefaultVisit(formula);
}
/// <summary>
/// Visits an element of type <see cref="UnaryFormula" />.
/// </summary>
/// <param name="formula">The <see cref="UnaryFormula" /> instance that should be visited.</param>
protected internal override void VisitUnaryFormula(UnaryFormula formula)
{
Visit(formula.Operand);
}
/// <summary> /// Visits the <paramref name="formula." /> /// </summary> public abstract void VisitUnaryFormula(UnaryFormula formula);