private double CalculateFinalProbability(double[] initialStateProbabilities) { var finalProbability = 0.0; var enumerator = MarkovChain.GetEnumerator(); enumerator.SelectInitialDistribution(); while (enumerator.MoveNextTransition()) { var entry = enumerator.CurrentTransition; finalProbability += entry.Value * initialStateProbabilities[entry.Column]; } return(finalProbability); }
private SparseDoubleMatrix CreateDerivedMatrix(Dictionary <long, bool> exactlyOneStates, Dictionary <long, bool> exactlyZeroStates) { //Derived matrix is 0-based. Row i is equivalent to the probability distribution of state i (this is not the case for the Markov Chain). var derivedMatrix = new SparseDoubleMatrix(MarkovChain.States, MarkovChain.Transitions + MarkovChain.States); //Transitions+States is a upper limit var enumerator = MarkovChain.GetEnumerator(); for (var sourceState = 0; sourceState < MarkovChain.States; sourceState++) { enumerator.SelectSourceState(sourceState); derivedMatrix.SetRow(sourceState); if (exactlyOneStates.ContainsKey(sourceState) || exactlyZeroStates.ContainsKey(sourceState)) { // only add a self reference entry derivedMatrix.AddColumnValueToCurrentRow(new SparseDoubleMatrix.ColumnValue(sourceState, 1.0)); } else { // if state is neither exactlyOneStates nor exactlyZeroStates, it is a toCalculateState var selfReferenceAdded = false; while (enumerator.MoveNextTransition()) { var columnValueEntry = enumerator.CurrentTransition; var targetState = columnValueEntry.Column; if (targetState == sourceState) { //this implements the removal of the identity matrix derivedMatrix.AddColumnValueToCurrentRow(new SparseDoubleMatrix.ColumnValue(sourceState, columnValueEntry.Value - 1.0)); selfReferenceAdded = true; } else { derivedMatrix.AddColumnValueToCurrentRow(columnValueEntry); } } if (!selfReferenceAdded) { //this implements the removal of the identity matrix (if not already done) derivedMatrix.AddColumnValueToCurrentRow(new SparseDoubleMatrix.ColumnValue(sourceState, -1.0)); } } derivedMatrix.FinishRow(); } return(derivedMatrix); }
private TemporaryFile WriteFilesAndExecuteMrmc(Formula formulaToCheck, bool outputExactResult) //returns result file { WriteMarkovChainToDisk(); var transformationVisitor = new MrmcTransformer(); transformationVisitor.Visit(formulaToCheck); var formulaToCheckString = transformationVisitor.TransformedFormula; bool useRewards; _initialStates = new Dictionary <int, double>(); var enumerator = MarkovChain.GetEnumerator(); enumerator.SelectInitialDistribution(); while (enumerator.MoveNextTransition()) { //enumerate initial states var entry = enumerator.CurrentTransition; var index = entry.Column + 1; //index in mrmc is 1-based if (_initialStates.ContainsKey(index)) { _initialStates.Add(index, _initialStates[index] + entry.Value); } else { _initialStates.Add(index, entry.Value); } } var fileResults = new TemporaryFile("res"); using (var fileCommandScript = new TemporaryFile("cmd")) using (var fileStateRewards = WriteRewardsToFile(formulaToCheck, out useRewards)) { var script = new StringBuilder(); script.AppendLine("set method_path gauss_jacobi"); //warning: gauss_seidel seems to be buggy in MRMC script.AppendLine("set error_bound 1.0E-6"); script.AppendLine(formulaToCheckString); //write result of every initial state to file if (outputExactResult) { script.Append("write_res_file_result"); } else { script.Append("write_res_file_state"); } foreach (var initialState in _initialStates) { script.Append(" " + (initialState.Key)); } script.AppendLine(); script.AppendLine("quit"); File.WriteAllText(fileCommandScript.FilePath, script.ToString()); var commandLineMode = useRewards ? "dmrm" : "dtmc"; var commandLineArgumentTransitionFile = $" {_fileTransitions.FilePath}"; var commandLineArgumentStateLabelingFile = $" {_fileStateLabelings.FilePath}"; var commandLineArgumentRewardFile = fileStateRewards != null ? $" {fileStateRewards.FilePath}" : ""; var commandLineArgumentCommandScriptFile = $" {fileCommandScript.FilePath}"; var commandLineArgumentResultsFile = $" {fileResults.FilePath}"; var commandLineArguments = commandLineMode + commandLineArgumentTransitionFile + commandLineArgumentStateLabelingFile + commandLineArgumentRewardFile + commandLineArgumentCommandScriptFile + commandLineArgumentResultsFile; var pureModelCheckingTime = ""; var iterations = ""; Action <string> extractInterestingOutput = output => { if (output.StartsWith("The Total Elapsed Model-Checking Time")) { pureModelCheckingTime = output; } else if (output.StartsWith("Gauss Jacobi V_B: The number of Gauss-Jacobi iterations")) { iterations = output; } }; var mrmc = new ExternalProcess("mrmc.exe", commandLineArguments, extractInterestingOutput); var stopwatch = new Stopwatch(); stopwatch.Start(); mrmc.Run(); stopwatch.Stop(); _output?.WriteLine(iterations); _output?.WriteLine(pureModelCheckingTime); _output?.WriteLine($"MRMC total model checking time: {stopwatch.Elapsed}"); } return(fileResults); }
private double CalculateProbabilityToReachStateFormulaInBoundedSteps(Formula psi, Formula phi, int steps) { // Pr[phi U psi] // calculate P [true U<=steps psi] var stopwatch = new Stopwatch(); stopwatch.Start(); var psiEvaluator = MarkovChain.CreateFormulaEvaluator(psi); var stateCount = MarkovChain.States; var directlySatisfiedStates = CalculateSatisfiedStates(psiEvaluator); Dictionary <long, bool> excludedStates; if (phi == null) { excludedStates = new Dictionary <long, bool>(); } else { // excludedStates = Sat(\phi) \Cup Sat(psi) var phiEvaluator = MarkovChain.CreateFormulaEvaluator(phi); var phiOrPsiStates = CalculateSatisfiedStates(phiEvaluator); foreach (var directlySatisfiedState in directlySatisfiedStates) { phiOrPsiStates[directlySatisfiedState.Key] = true; } excludedStates = CreateComplement(phiOrPsiStates); } var enumerator = MarkovChain.GetEnumerator(); var xold = new double[stateCount]; var xnew = CreateDerivedVector(directlySatisfiedStates); var loops = 0; while (loops < steps) { // switch xold and xnew var xtemp = xold; xold = xnew; xnew = xtemp; loops++; for (var i = 0; i < stateCount; i++) { if (directlySatisfiedStates.ContainsKey(i)) { //we could remove this line, because already set by CreateDerivedVector and never changed when we initialize xold with CreateDerivedVector(directlySatisfiedStates) xnew[i] = 1.0; } else if (excludedStates.ContainsKey(i)) { //we could remove this line, because already set by CreateDerivedVector and never changed when we initialize xold with CreateDerivedVector(directlySatisfiedStates) xnew[i] = 0.0; } else { enumerator.SelectSourceState(i); var sum = 0.0; while (enumerator.MoveNextTransition()) { var entry = enumerator.CurrentTransition; sum += entry.Value * xold[entry.Column]; } xnew[i] = sum; } } if (loops % 10 == 0) { stopwatch.Stop(); var currentProbability = CalculateFinalProbability(xnew); _output?.WriteLine($"{loops} Bounded Until iterations in {stopwatch.Elapsed}. Current probability={currentProbability.ToString(CultureInfo.InvariantCulture)}"); stopwatch.Start(); } } var finalProbability = CalculateFinalProbability(xnew); stopwatch.Stop(); return(finalProbability); }
private double CalculateUnboundUntil(Formula psi, Formula phi, int iterationsLeft) { // On algorithmic verification methods for probabilistic systems (1998) by Christel Baier // Theorem 3.1.6 (page 36) // http://wwwneu.inf.tu-dresden.de/content/institutes/thi/algi/publikationen/texte/15_98.pdf // Pr[phi U psi] // calculate P [true U<=steps psi] var stopwatch = new Stopwatch(); stopwatch.Start(); var psiEvaluator = MarkovChain.CreateFormulaEvaluator(psi); var stateCount = MarkovChain.States; var fixPointReached = iterationsLeft <= 0; var directlySatisfiedStates = CalculateSatisfiedStates(psiEvaluator); Dictionary <long, bool> excludedStates; if (phi == null) { excludedStates = new Dictionary <long, bool>(); } else { // excludedStates = Sat(\phi) \Cup Sat(psi) var phiEvaluator = MarkovChain.CreateFormulaEvaluator(phi); var phiOrPsiStates = CalculateSatisfiedStates(phiEvaluator); foreach (var directlySatisfiedState in directlySatisfiedStates) { phiOrPsiStates[directlySatisfiedState.Key] = true; } excludedStates = CreateComplement(phiOrPsiStates); } // calculate probabilityExactlyZero (prob0) var probabilityExactlyZero = ProbabilityExactlyZero(directlySatisfiedStates, excludedStates); // calculate probabilityExactlyOne (prob1) var probabilityExactlyOne = ProbabilityExactlyOne(directlySatisfiedStates, excludedStates, probabilityExactlyZero); var enumerator = MarkovChain.GetEnumerator(); var xold = new double[stateCount]; var xnew = CreateDerivedVector(probabilityExactlyOne); var loops = 0; while (!fixPointReached) { // switch xold and xnew var xtemp = xold; xold = xnew; xnew = xtemp; iterationsLeft--; loops++; for (var i = 0; i < stateCount; i++) { if (probabilityExactlyOne.ContainsKey(i)) { //we could remove this line, because already set by CreateDerivedVector and never changed when we initialize xold with CreateDerivedVector(directlySatisfiedStates) xnew[i] = 1.0; } else if (probabilityExactlyZero.ContainsKey(i)) { //we could remove this line, because already set by CreateDerivedVector and never changed when we initialize xold with CreateDerivedVector(directlySatisfiedStates) xnew[i] = 0.0; } else { enumerator.SelectSourceState(i); var sum = 0.0; while (enumerator.MoveNextTransition()) { var entry = enumerator.CurrentTransition; sum += entry.Value * xold[entry.Column]; } xnew[i] = sum; } } if (loops % 10 == 0) { stopwatch.Stop(); var currentProbability = CalculateFinalProbability(xnew); _output?.WriteLine($"{loops} Fixpoint Until iterations in {stopwatch.Elapsed}. Current probability={currentProbability.ToString(CultureInfo.InvariantCulture)}"); stopwatch.Start(); } if (iterationsLeft <= 0) { fixPointReached = true; } } var finalProbability = CalculateFinalProbability(xnew); stopwatch.Stop(); return(finalProbability); }
private double CalculateProbabilityToReachStateFormulaInBoundedSteps(Formula psi, int steps) { // calculate P [true U<=steps psi] var stopwatch = new Stopwatch(); stopwatch.Start(); var psiEvaluator = MarkovChain.CreateFormulaEvaluator(psi); var stateCount = MarkovChain.States; var precalculatedStates = CreateEmptyPrecalculatedStatesArray(); CalculateSatisfiedStates(precalculatedStates, psiEvaluator); //CalculateExcludedStates(precalculatedStates); // change for \phi Until \psi var enumerator = MarkovChain.GetEnumerator(); var xold = new double[stateCount]; var xnew = CreateDerivedVector(precalculatedStates, PrecalculatedState.Satisfied); var loops = 0; while (loops < steps) { // switch xold and xnew var xtemp = xold; xold = xnew; xnew = xtemp; loops++; for (var i = 0; i < stateCount; i++) { if (precalculatedStates[i].HasFlag(PrecalculatedState.Satisfied)) { //we could remove this line, because already set by CreateDerivedVector and never changed when we initialize xold with CreateDerivedVector(directlySatisfiedStates) xnew[i] = 1.0; } else if (precalculatedStates[i].HasFlag(PrecalculatedState.Excluded)) { //we could remove this line, because already set by CreateDerivedVector and never changed when we initialize xold with CreateDerivedVector(directlySatisfiedStates) xnew[i] = 0.0; } else { enumerator.SelectSourceState(i); var sum = 0.0; while (enumerator.MoveNextTransition()) { var entry = enumerator.CurrentTransition; sum += entry.Value * xold[entry.Column]; } xnew[i] = sum; } } if (loops % 10 == 0) { stopwatch.Stop(); var currentProbability = CalculateFinalProbability(xnew); _output?.WriteLine($"{loops} Bounded Until iterations in {stopwatch.Elapsed}. Current probability={currentProbability.ToString(CultureInfo.InvariantCulture)}"); stopwatch.Start(); } } var finalProbability = CalculateFinalProbability(xnew); stopwatch.Stop(); return(finalProbability); }