private static void ExportDistribution(LabeledTransitionMarkovChain markovChain, TextWriter sb, string sourceStateName, LabeledTransitionMarkovChain.LabeledTransitionEnumerator distribution)
{
while (distribution.MoveNext())
{
sb.Write($"{sourceStateName} -> {distribution.CurrentTargetState} [label=\"{Probability.PrettyPrint(distribution.CurrentProbability)}");
for (int i = 0; i < markovChain.StateFormulaLabels.Length; i++)
{
if (i == 0)
{
sb.Write("\\n");
}
else
{
sb.Write(",");
}
if (distribution.CurrentFormulas[i])
{
sb.Write("t");
}
else
{
sb.Write("f");
}
}
sb.WriteLine("\"];");
}
}
// Note: Should be used with using(var modelchecker = new ...)
public BuiltinLtmcModelChecker(LabeledTransitionMarkovChain markovChain, TextWriter output = null)
: base(markovChain, output)
{
Requires.That(true, "Need CompactStateStorage to use this model checker");
LabeledMarkovChain.AssertIsDense();
output.WriteLine("Initializing Built-in Ltmc Model checker");
}
/// <summary>
/// Generates a <see cref="LabeledTransitionMarkovChain" /> for the model created by <paramref name="createModel" />.
/// </summary>
internal LabeledTransitionMarkovChain GenerateLtmc(AnalysisModelCreator createModel)
{
using (var modelTraverser = new ModelTraverser(createModel, Configuration, LabeledTransitionMarkovChain.TransitionSize, FormulaManager.NeedsStutteringState))
{
_markovChain = new LabeledTransitionMarkovChain(modelTraverser.Context.ModelCapacity.NumberOfStates, modelTraverser.Context.ModelCapacity.NumberOfTransitions);
_markovChain.StateFormulaLabels = FormulaManager.FinalStateFormulaLabels.ToArray();
if (FormulaManager.NeedsStutteringState)
{
_markovChain.CreateStutteringState(modelTraverser.Context.StutteringStateIndex);
}
modelTraverser.Context.TraversalParameters.TransitionModifiers.AddRange(FormulaManager.TransitionModifierGenerators);
modelTraverser.Context.TraversalParameters.TransitionModifiers.Add(() => new ConsolidateTransitionsModifier());
modelTraverser.Context.TraversalParameters.BatchedTransitionActions.Add(() => new LabeledTransitionMarkovChain.LtmcBuilder(_markovChain));
modelTraverser.Context.Output.WriteLine($"Generating labeled transition markov chain.");
modelTraverser.TraverseModelAndReport();
// StateStorage must be freed manually. Reason is that invariant checker does not free up the
// space, because it might be necessary for other usages of the ModelTraversers (e.g. StateGraphGenerator
// which keeps the States for the StateGraph)
modelTraverser.Context.States.SafeDispose();
}
if (Configuration.WriteGraphvizModels)
{
FormulaManager.PrintStateFormulas(FormulaManager.FinalStateFormulas, Configuration.DefaultTraceOutput);
Configuration.DefaultTraceOutput.WriteLine("Ltmc Model");
_markovChain.ExportToGv(Configuration.DefaultTraceOutput);
}
return(_markovChain);
}
public LtmcRetraverseModel(LabeledTransitionMarkovChain ltmc, Formula[] stateFormulasToCheck, AnalysisConfiguration configuration)
{
Assert.That(stateFormulasToCheck.Length <= 32, "Too many Formulas");
LabeledTransitionMarkovChain = ltmc;
TemporaryStateStorage = new TemporaryStateStorage(ModelStateVectorSize, configuration.SuccessorCapacity);
_transitions = new LtmcRetraverseTransitionSetBuilder(TemporaryStateStorage, configuration.SuccessorCapacity);
_formulas = stateFormulasToCheck;
_formulaInStateTransitionEvaluators = stateFormulasToCheck.Select(CreateFormulaEvaluator).ToArray();
}
internal DiscreteTimeMarkovChain ConvertToMarkovChain(LabeledTransitionMarkovChain labeledTransitionMarkovChain)
{
var ltmcToMc = new LtmcToDtmc(labeledTransitionMarkovChain);
var markovChain = ltmcToMc.MarkovChain;
if (Configuration.WriteGraphvizModels)
{
Configuration.DefaultTraceOutput.WriteLine("Dtmc Model");
markovChain.ExportToGv(Configuration.DefaultTraceOutput);
}
return(markovChain);
}
public void ConvertInitialStates(LabeledTransitionMarkovChain ltmc)
{
MarkovChain.StartWithInitialDistribution();
var enumerator = ltmc.GetInitialDistributionEnumerator();
while (enumerator.MoveNext())
{
var targetEntry = new StateStorageEntry(enumerator.CurrentFormulas, enumerator.CurrentTargetState);
var targetState = _mapper[targetEntry];
MarkovChain.AddInitialTransition(targetState, enumerator.CurrentProbability);
}
MarkovChain.FinishInitialDistribution();
}
private void CreateStates(LabeledTransitionMarkovChain ltmc)
{
var enumerator = ltmc.GetTransitionChainEnumerator();
while (enumerator.MoveNext())
{
var entry = new StateStorageEntry(enumerator.CurrentFormulas, enumerator.CurrentTargetState);
if (!_mapper.ContainsKey(entry))
{
_mapper.Add(entry, States);
_backMapper[States] = entry;
States++;
}
}
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="executableStateFormulas">The state formulas that can be evaluated over the generated state graph.</param>
/// <param name="output">The callback that should be used to output messages.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
internal LtmcGenerator(AnalysisModelCreator <TExecutableModel> createModel, Formula terminateEarlyCondition, Formula[] executableStateFormulas,
Action <string> output, AnalysisConfiguration configuration)
: base(createModel, output, configuration, LabeledTransitionMarkovChain.TransitionSize)
{
_markovChain = new LabeledTransitionMarkovChain(Context.ModelCapacity.NumberOfStates, Context.ModelCapacity.NumberOfTransitions);
_markovChain.StateFormulaLabels = executableStateFormulas.Select(stateFormula => stateFormula.Label).ToArray();
Context.TraversalParameters.BatchedTransitionActions.Add(() => new LabeledTransitionMarkovChain.LtmcBuilder <TExecutableModel>(_markovChain));
if (terminateEarlyCondition != null)
{
_markovChain.CreateStutteringState(Context.StutteringStateIndex);
var terminalteEarlyFunc = StateFormulaSetEvaluatorCompilationVisitor.Compile(_markovChain.StateFormulaLabels, terminateEarlyCondition);
Context.TraversalParameters.TransitionModifiers.Add(() => new EarlyTerminationModifier <TExecutableModel>(terminalteEarlyFunc));
}
}
public void ConvertTransitions(LabeledTransitionMarkovChain ltmc)
{
for (var i = 0; i < States; i++)
{
var sourceEntry = _backMapper[i];
MarkovChain.StartWithNewDistribution(i);
var enumerator = ltmc.GetTransitionEnumerator(sourceEntry.StateStorageState);
while (enumerator.MoveNext())
{
var targetEntry = new StateStorageEntry(enumerator.CurrentFormulas, enumerator.CurrentTargetState);
var targetState = _mapper[targetEntry];
MarkovChain.AddTransition(targetState, enumerator.CurrentProbability);
}
MarkovChain.FinishDistribution();
}
}
public UnderlyingDigraph(LabeledTransitionMarkovChain markovChain)
{
// Assumption "every node is reachable" is fulfilled due to the construction
// Except maybe the stuttering state
_transitionTargetNo = markovChain.Transitions;
_stateNo = markovChain.SourceStates.Count;
_baseGraph = new BidirectionalGraph();
var enumerator = markovChain.GetInitialDistributionEnumerator();
AddStatesFromEnumerator(null, enumerator);
foreach (var sourceState in markovChain.SourceStates)
{
enumerator = markovChain.GetTransitionEnumerator(sourceState);
markovChain.GetTransitionEnumerator(sourceState);
AddStatesFromEnumerator(sourceState, enumerator);
}
}
public LtmcToDtmc(LabeledTransitionMarkovChain ltmc)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
Console.Out.WriteLine("Starting to convert labeled transition Markov chain to Markov chain");
Console.Out.WriteLine($"Ltmc: States {ltmc.SourceStates.Count}, Transitions {ltmc.Transitions}");
CreateStates(ltmc);
var modelCapacity = new ModelCapacityByModelSize(States, ltmc.Transitions * 8L);
MarkovChain = new DiscreteTimeMarkovChain(modelCapacity);
MarkovChain.StateFormulaLabels = ltmc.StateFormulaLabels;
SetStateLabeling();
ConvertInitialStates(ltmc);
ConvertTransitions(ltmc);
stopwatch.Stop();
Console.Out.WriteLine($"Completed transformation in {stopwatch.Elapsed}");
Console.Out.WriteLine($"Mc: States {MarkovChain.States}, Transitions {MarkovChain.Transitions}");
}
public static void ExportToGv(this LabeledTransitionMarkovChain markovChain, TextWriter sb)
{
sb.WriteLine("digraph S {");
//sb.WriteLine("size = \"8,5\"");
sb.WriteLine("node [shape=box];");
var initialStateName = "initialState";
sb.WriteLine($" {initialStateName} [shape=point,width=0.0,height=0.0,label=\"\"];");
var initialDistribution = markovChain.GetInitialDistributionEnumerator();
ExportDistribution(markovChain, sb, initialStateName, initialDistribution);
foreach (var state in markovChain.SourceStates)
{
sb.Write($" {state} [label=\"{state}");
sb.WriteLine("\"];");
var distribution = markovChain.GetTransitionEnumerator(state);
ExportDistribution(markovChain, sb, state.ToString(), distribution);
}
sb.WriteLine("}");
}
public MarkovChainFromMarkovChainGenerator(LabeledTransitionMarkovChain ltmc)
{
Requires.NotNull(ltmc, nameof(ltmc));
_sourceLtmc = ltmc;
}
// Note: Should be used with using(var modelchecker = new ...)
public ConfigurationDependentLtmcModelChecker(AnalysisConfiguration configuration, LabeledTransitionMarkovChain markovChain, TextWriter output = null)
: base(markovChain, output)
{
switch (configuration.LtmcModelChecker)
{
case SafetyChecking.LtmcModelChecker.BuiltInLtmc:
Requires.That(configuration.UseCompactStateStorage, "Need CompactStateStorage to use this algorithm");
_ltmcModelChecker = new BuiltinLtmcModelChecker(markovChain, output);
break;
case SafetyChecking.LtmcModelChecker.BuiltInDtmc:
var dtmc = ConvertToMarkovChain(configuration, markovChain);
_dtmcModelChecker = new BuiltinDtmcModelChecker(dtmc, output);
break;
case SafetyChecking.LtmcModelChecker.ExternalMrmc:
dtmc = ConvertToMarkovChain(configuration, markovChain);
_dtmcModelChecker = new ExternalDtmcModelCheckerMrmc(dtmc, output);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public TransitionChainEnumerator(LabeledTransitionMarkovChain ltmc)
{
_ltmc = ltmc;
CurrentIndex = -1;
}
public LabeledTransitionEnumerator(LabeledTransitionMarkovChain ltmc, long firstElement, long elements)
{
_ltmc = ltmc;
CurrentIndex = firstElement - 1;
_lastElementIndex = firstElement + elements - 1;
}
// Note: Should be used with using(var modelchecker = new ...)
internal LtmcModelChecker(LabeledTransitionMarkovChain markovChain, TextWriter output = null)
{
LabeledMarkovChain = markovChain;
_output = output;
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="markovChain">The Markov chain that should be built up.</param>
public LtmcBuilder(LabeledTransitionMarkovChain markovChain)
{
Requires.NotNull(markovChain, nameof(markovChain));
_markovChain = markovChain;
}
public LabeledTransitionEnumerator(LabeledTransitionMarkovChain ltmc, int firstElement)
{
_ltmc = ltmc;
CurrentIndex = -1;
_nextElementIndex = firstElement;
}
