private void Check(AnalysisConfiguration configuration)
{
var m = new Model();
Probability probabilityOfFinally2;
Probability probabilityOfFinally2b;
var finally2 = new UnaryFormula(new SimpleStateInRangeFormula(2), UnaryOperator.Finally);
var finally2b = new BoundedUnaryFormula(new SimpleStateInRangeFormula(2), UnaryOperator.Finally, 2);
var markovChainGenerator = new SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration = configuration;
markovChainGenerator.AddFormulaToCheck(finally2);
markovChainGenerator.AddFormulaToCheck(finally2b);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinally2 = modelChecker.CalculateProbability(finally2);
probabilityOfFinally2b = modelChecker.CalculateProbability(finally2b);
}
probabilityOfFinally2.Between(0.33, 0.34).ShouldBe(true);
probabilityOfFinally2b.Between(0.33, 0.34).ShouldBe(true);
}
private void Check(AnalysisConfiguration configuration)
{
var m = new Model();
Probability probabilityOfFinal100;
Probability probabilityOfFinal200;
var final100Formula = new UnaryFormula(Model.StateIs100, UnaryOperator.Finally);
var final200Formula = new UnaryFormula(Model.StateIs200, UnaryOperator.Finally);
var markovChainGenerator = new SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration = configuration;
markovChainGenerator.AddFormulaToCheck(final100Formula);
markovChainGenerator.AddFormulaToCheck(final200Formula);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal100 = modelChecker.CalculateProbability(final100Formula);
probabilityOfFinal200 = modelChecker.CalculateProbability(final200Formula);
}
probabilityOfFinal100.Is(0.0, 0.000001).ShouldBe(true);
probabilityOfFinal200.Is(1.0, 0.000001).ShouldBe(true);
}
public void CalculateHazardSingleCoreAllFaultsWithOnce()
{
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <LustreExecutableModel>(_createModel)
{
Configuration = LustreModelChecker.TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.Configuration.EnableStaticPruningOptimization = false;
var onceFormula = new UnaryFormula(_hazard, UnaryOperator.Once);
var onceFault1 = new UnaryFormula(new FaultFormula(_faults[1]), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(onceFault1);
foreach (var fault in _faults.Where(fault => fault != _faults[1]))
{
var faultFormula = new UnaryFormula(new FaultFormula(fault), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
var formulaToCheck = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceFormula), UnaryOperator.Finally, 25);
markovChainGenerator.AddFormulaToCheck(formulaToCheck);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(formulaToCheck);
Console.Write($"Probability of formulaToCheck: {result}");
}
}
protected override void Check()
{
var c = new C();
Probability probabilityOfFinal2;
Probability probabilityOfFinal3;
Formula valueIs2 = c.Value == 2;
Formula valueIs3 = c.Value == 3;
var final2 = new UnaryFormula(valueIs2, UnaryOperator.Finally);
var final3 = new UnaryFormula(valueIs3, UnaryOperator.Finally);
var markovChainGenerator = new SafetySharpMarkovChainFromExecutableModelGenerator(TestModel.InitializeModel(c));
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.Configuration.LtmcModelChecker = (ISSE.SafetyChecking.LtmcModelChecker)Arguments[0];
markovChainGenerator.AddFormulaToCheck(final2);
markovChainGenerator.AddFormulaToCheck(final3);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal2 = modelChecker.CalculateProbability(final2);
probabilityOfFinal3 = modelChecker.CalculateProbability(final3);
}
probabilityOfFinal2.Is(0.3, tolerance: 0.0001).ShouldBe(true);
probabilityOfFinal3.Is(0.6, tolerance: 0.0001).ShouldBe(true);
}
public void CalculateHazardSingleCoreAllFaults()
{
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.EnableStaticPruningOptimization = false;
markovChainGenerator.Configuration.CpuCount = 1;
var formulaToCheck = new BoundedUnaryFormula(model.PossibleCollision, UnaryOperator.Finally, 50);
markovChainGenerator.AddFormulaToCheck(formulaToCheck);
foreach (var fault in model.Faults)
{
var faultFormula = new FaultFormula(fault);
markovChainGenerator.AddFormulaToCheck(faultFormula);
}
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(formulaToCheck);
Console.Write($"Probability of formulaToCheck: {result}");
}
}
private void Check(AnalysisConfiguration configuration)
{
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 SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration = configuration;
markovChainGenerator.AddFormulaToCheck(final1Formula);
markovChainGenerator.AddFormulaToCheck(final2Formula);
markovChainGenerator.AddFormulaToCheck(final3Formula);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal1 = modelChecker.CalculateProbability(final1Formula);
probabilityOfFinal2 = modelChecker.CalculateProbability(final2Formula);
probabilityOfFinal3 = modelChecker.CalculateProbability(final3Formula);
}
probabilityOfFinal1.Is(0.7, 0.000001).ShouldBe(true);
probabilityOfFinal2.Is(0.15, 0.000001).ShouldBe(true);
probabilityOfFinal3.Is(0.15, 0.000001).ShouldBe(true);
}
protected override void Check()
{
var c = new C();
Probability probabilityOfFinal1;
var final1Formula = new UnaryFormula(c.InA(), UnaryOperator.Finally);
var markovChainGenerator = new SafetySharpMarkovChainFromExecutableModelGenerator(TestModel.InitializeModel(c));
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.Configuration.WriteGraphvizModels = true;
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.DefaultTraceOutput = Output.TextWriterAdapter();
markovChainGenerator.Configuration.LtmcModelChecker = (ISSE.SafetyChecking.LtmcModelChecker)Arguments[0];
markovChainGenerator.AddFormulaToCheck(final1Formula);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal1 = modelChecker.CalculateProbability(final1Formula);
}
probabilityOfFinal1.Between(0.3, 0.4).ShouldBe(true);
}
public void CalculateHazardSingleCoreAllFaultsWithOnce()
{
var model = new DegradedModeModel();
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;
var formula = new ExecutableStateFormula(() => model.System.HazardActive);
var onceFormula = new UnaryFormula(formula, UnaryOperator.Once);
var onceFault1 = new UnaryFormula(new FaultFormula(model.System.SignalDetector1.F1), UnaryOperator.Once);
markovChainGenerator.AddFormulaToCheck(onceFault1);
var formulaToCheck = new BoundedUnaryFormula(new BinaryFormula(onceFault1, BinaryOperator.And, onceFormula), UnaryOperator.Finally, 50);
markovChainGenerator.AddFormulaToCheck(formulaToCheck);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
markovChainGenerator.Configuration.EnableEarlyTermination = false;
markovChainGenerator.Configuration.CpuCount = Int32.MaxValue;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(formulaToCheck);
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}");
}
}
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);
}
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 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)
{
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);
}
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);
}
protected override void Check()
{
var c = new C();
Probability probabilityOfFinal1;
var final1Formula = new BoundedBinaryFormula(c.IsPhi(), BinaryOperator.Until, c.IsPsi(), 10);
var markovChainGenerator = new SafetySharpMarkovChainFromExecutableModelGenerator(TestModel.InitializeModel(c));
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.Configuration.LtmcModelChecker = (ISSE.SafetyChecking.LtmcModelChecker)Arguments[0];
markovChainGenerator.AddFormulaToCheck(final1Formula);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfFinal1 = modelChecker.CalculateProbability(final1Formula);
}
probabilityOfFinal1.Is(0.2, 0.000001).ShouldBe(true);
}
private void Check(AnalysisConfiguration configuration)
{
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 SimpleMarkovChainFromExecutableModelGenerator(m);
markovChainGenerator.Configuration = configuration;
markovChainGenerator.AddFormulaToCheck(final0Formula);
markovChainGenerator.AddFormulaToCheck(final0LtFormula);
markovChainGenerator.AddFormulaToCheck(final1Formula);
markovChainGenerator.AddFormulaToCheck(final2Formula);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(configuration, ltmc, 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.00001).ShouldBe(true);
probabilityOfFinal2.Is(0.5, 0.00001).ShouldBe(true);
}
private void Check(AnalysisConfiguration configuration)
{
var m = new Model();
Probability probabilityOfInvariantViolation;
Formula invariantViolated = new SimpleLocalVarIsTrue(0);
var finallyInvariantViolated = new UnaryFormula(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);
}
probabilityOfInvariantViolation.Is(0.01, 0.0001).ShouldBe(true);
}
public void CalculateHazardSingleCore()
{
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 unsuccessful = new BoundedUnaryFormula(model.BloodNotCleanedAndDialyzingFinished, UnaryOperator.Finally, 6);
var contamination = new BoundedUnaryFormula(model.IncomingBloodWasNotOk, UnaryOperator.Finally, 6);
markovChainGenerator.AddFormulaToCheck(unsuccessful);
markovChainGenerator.AddFormulaToCheck(contamination);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(unsuccessful);
Console.Write($"Probability of collision: {result}");
}
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, markovChainGenerator.Configuration.DefaultTraceOutput))
{
var result = modelChecker.CalculateProbability(contamination);
Console.Write($"Probability of collision: {result}");
}
}
protected override void Check()
{
var c = new C();
Probability probabilityOfInvariantViolation;
Formula invariantViolated = c.ViolateInvariant;
var finallyInvariantViolated = new UnaryFormula(invariantViolated, UnaryOperator.Finally);
var markovChainGenerator = new SafetySharpMarkovChainFromExecutableModelGenerator(TestModel.InitializeModel(c));
markovChainGenerator.Configuration.ModelCapacity = ModelCapacityByMemorySize.Small;
markovChainGenerator.Configuration.LtmcModelChecker = (ISSE.SafetyChecking.LtmcModelChecker)Arguments[0];
markovChainGenerator.AddFormulaToCheck(finallyInvariantViolated);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probabilityOfInvariantViolation = modelChecker.CalculateProbability(finallyInvariantViolated);
}
probabilityOfInvariantViolation.Is(0.01, 0.0001).ShouldBe(true);
}
private void CheckOnceWithAtormarOperand(AnalysisConfiguration configuration)
{
var m = new Model();
Probability probability;
//var final9Formula = new UnaryFormula(Model.IsInState9, UnaryOperator.Finally);
var once7Formula = new UnaryFormula(Model.IsInState7, 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 = configuration;
markovChainGenerator.AddFormulaToCheck(final9Once7Formula);
var ltmc = markovChainGenerator.GenerateLabeledMarkovChain();
var modelChecker = new ConfigurationDependentLtmcModelChecker(configuration, ltmc, Output.TextWriterAdapter());
using (modelChecker)
{
probability = modelChecker.CalculateProbability(final9Once7Formula);
}
probability.Is(0.4 * 0.4 + 0.6, 0.00000001).ShouldBe(true);
}
/// <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>
public static Probability CalculateProbabilityOfFormula(ModelBase model, Formula formula)
{
Probability probability;
var createModel = SafetySharpRuntimeModel.CreateExecutedModelFromFormulasCreator(model);
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <SafetySharpRuntimeModel>(createModel)
{
Configuration = TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.AddFormulaToCheck(formula);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, TraversalConfiguration.DefaultTraceOutput))
{
probability = modelChecker.CalculateProbability(formula);
}
System.GC.Collect();
return(probability);
}
/// <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>
public static Probability CalculateProbabilityOfFormula(string ocFileName, string mainNode, IEnumerable <Fault> faults, Formula formula)
{
Probability probability;
var createModel = LustreExecutableModel.CreateExecutedModelFromFormulasCreator(ocFileName, mainNode, faults.ToArray());
var markovChainGenerator = new MarkovChainFromExecutableModelGenerator <LustreExecutableModel>(createModel)
{
Configuration = TraversalConfiguration
};
markovChainGenerator.Configuration.SuccessorCapacity *= 2;
markovChainGenerator.AddFormulaToCheck(formula);
markovChainGenerator.Configuration.UseCompactStateStorage = true;
var markovChain = markovChainGenerator.GenerateLabeledMarkovChain();
using (var modelChecker = new ConfigurationDependentLtmcModelChecker(markovChainGenerator.Configuration, markovChain, TraversalConfiguration.DefaultTraceOutput))
{
probability = modelChecker.CalculateProbability(formula);
}
GC.Collect();
return(probability);
}
