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; }