/** Model check a P operator. */ private Result checkExpressionProb(ExpressionProb expr) throws PrismException { boolean min; ExpressionTemporal exprTemp; Expression exprTarget; BitSet targetLocs; int timeBound; boolean timeBoundStrict; double prob; // Check whether Pmin=? or Pmax=? (only two cases allowed) if (expr.getProb() != null) { throw new PrismException( "PTA model checking currently only supports Pmin=? and Pmax=? properties (try the digital clocks engine instead)"); } min = expr.getRelOp().equals("min="); // Check this is a F path property (only case allowed at the moment) if (!(expr.getExpression() instanceof ExpressionTemporal)) throw new PrismException( "PTA model checking currently only supports the F path operator (try the digital clocks engine instead)"); exprTemp = (ExpressionTemporal) expr.getExpression(); if (exprTemp.getOperator() != ExpressionTemporal.P_F || !exprTemp.isSimplePathFormula()) throw new PrismException( "PTA model checking currently only supports the F path operator (try the digital clocks engine instead)"); // Determine locations satisfying target exprTarget = exprTemp.getOperand2(); targetLocs = checkLocationExpression(exprTarget); mainLog.println( "Target (" + exprTarget + ") satisfied by " + targetLocs.cardinality() + " locations."); // mainLog.println(targetLocs); // If there is a time bound, add a clock and encode this into target if (exprTemp.hasBounds()) { mainLog.println("Modifying PTA to encode time bound from property..."); // Get time bound info (is always of form <=T or <T) timeBound = exprTemp.getUpperBound().evaluateInt(constantValues); timeBoundStrict = exprTemp.upperBoundIsStrict(); // Modify PTA to include time bound; get new target targetLocs = buildTimeBoundIntoPta(pta, targetLocs, timeBound, timeBoundStrict); mainLog.println("New PTA: " + pta.infoString()); } // Compute probability of reaching the set of target locations prob = computeProbabilisticReachability(targetLocs, min); // Return result return new Result(new Double(prob)); }
private static SamplerBoolean createSamplerForProbPathPropertySimple( Expression expr, ModulesFile mf) throws PrismException { // Negation/parentheses if (expr instanceof ExpressionUnaryOp) { ExpressionUnaryOp exprUnary = (ExpressionUnaryOp) expr; // Parentheses if (exprUnary.getOperator() == ExpressionUnaryOp.PARENTH) { // Recurse return createSamplerForProbPathPropertySimple(exprUnary.getOperand(), mf); } // Negation else if (exprUnary.getOperator() == ExpressionUnaryOp.NOT) { // Recurse, then negate meaning SamplerBoolean sampler = createSamplerForProbPathPropertySimple(exprUnary.getOperand(), mf); sampler.negate(); return sampler; } } // Temporal operators else if (expr instanceof ExpressionTemporal) { ExpressionTemporal exprTemp = (ExpressionTemporal) expr; // Next if (exprTemp.getOperator() == ExpressionTemporal.P_X) { return new SamplerNext(exprTemp); } // Until else if (exprTemp.getOperator() == ExpressionTemporal.P_U) { if (exprTemp.hasBounds()) { if (mf.getModelType().continuousTime()) { // Continuous-time bounded until return new SamplerBoundedUntilCont(exprTemp); } else { // Discrete-time bounded until return new SamplerBoundedUntilDisc(exprTemp); } } else { // Unbounded until return new SamplerUntil(exprTemp); } } // Anything else - convert to until and recurse else { return createSamplerForProbPathPropertySimple(exprTemp.convertToUntilForm(), mf); } } throw new PrismException("Can't create sampler for property \"" + expr + "\""); }
/** Compute probabilities for a simple, non-LTL path operator. */ protected StateValues checkProbPathFormulaSimple( Model model, Expression expr, boolean min1, boolean min2) throws PrismException { StateValues probs = null; // Negation/parentheses if (expr instanceof ExpressionUnaryOp) { ExpressionUnaryOp exprUnary = (ExpressionUnaryOp) expr; // Parentheses if (exprUnary.getOperator() == ExpressionUnaryOp.PARENTH) { // Recurse probs = checkProbPathFormulaSimple(model, exprUnary.getOperand(), min1, min2); } // Negation else if (exprUnary.getOperator() == ExpressionUnaryOp.NOT) { // Compute, then subtract from 1 probs = checkProbPathFormulaSimple(model, exprUnary.getOperand(), !min1, !min2); probs.timesConstant(-1.0); probs.plusConstant(1.0); } } // Temporal operators else if (expr instanceof ExpressionTemporal) { ExpressionTemporal exprTemp = (ExpressionTemporal) expr; // Next if (exprTemp.getOperator() == ExpressionTemporal.P_X) { probs = checkProbNext(model, exprTemp, min1, min2); } // Until else if (exprTemp.getOperator() == ExpressionTemporal.P_U) { if (exprTemp.hasBounds()) { probs = checkProbBoundedUntil(model, exprTemp, min1, min2); } else { probs = checkProbUntil(model, exprTemp, min1, min2); } } // Anything else - convert to until and recurse else { probs = checkProbPathFormulaSimple(model, exprTemp.convertToUntilForm(), min1, min2); } } if (probs == null) throw new PrismException("Unrecognised path operator in P operator"); return probs; }