/// <summary> /// [ REFS: '', DEREFS: 'P1, P2'] /// </summary> /// <param name="isP1Terminate"></param> /// <param name="P1"></param> /// <param name="P2"></param> /// <param name="model"></param> /// <param name="result"></param> public static void SequenceEncodeTransition(string isP1Terminate, AutomataBDD P1, AutomataBDD P2, Model model, AutomataBDD result) { CUDDNode tauEvent = GetTauTransEncoding(model); CUDDNode terminateEvent = GetTerminationTransEncoding(model); CUDD.Ref(terminateEvent); CUDD.Ref(P1.transitionBDD); List <CUDDNode> notTerminateTransition = CUDD.Function.And(P1.transitionBDD, CUDD.Function.Not(terminateEvent)); //CUDD.Ref(terminateEvent); //CUDD.Ref(P1.transitionBDD); List <CUDDNode> terminateTransition = CUDD.Function.And(P1.transitionBDD, terminateEvent); //Convert terminate transition to tau transition terminateTransition = CUDD.Abstract.ThereExists(terminateTransition, model.GetAllEventVars()); terminateTransition = CUDD.Function.And(terminateTransition, tauEvent); //1. !isP1Terminate and not terminate transition, channel and !isP1Terminate Expression guard = Expression.AND(Expression.EQ(new Variable(isP1Terminate), new IntConstant(0)), new Assignment(isP1Terminate, new IntConstant(0))); List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; // CUDD.Ref(guardDD); result.transitionBDD.AddRange(CUDD.Function.And(guardDD, notTerminateTransition)); CUDD.Ref(guardDD); result.channelInTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelInTransitionBDD)); // CUDD.Ref(guardDD); result.channelOutTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelOutTransitionBDD)); //2. (!isP1Terminate ∧ terminate P1.transition ∧ isP1Terminate' and P2.Init') guard = Expression.AND(Expression.EQ(new Variable(isP1Terminate), new IntConstant(0)), new Assignment(isP1Terminate, new IntConstant(1))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; guardDD = CUDD.Function.And(guardDD, P2.GetInitInColumn(model)); result.transitionBDD.AddRange(CUDD.Function.And(guardDD, terminateTransition)); //3. (isP1Terminate ∧ P2.Trans/In/Out ∧ isP1Terminate') guard = Expression.AND(Expression.EQ(new Variable(isP1Terminate), new IntConstant(1)), new Assignment(isP1Terminate, new IntConstant(1))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; // CUDD.Ref(guardDD); result.transitionBDD.AddRange(CUDD.Function.And(guardDD, P2.transitionBDD)); CUDD.Ref(guardDD); result.channelInTransitionBDD.AddRange(CUDD.Function.And(guardDD, P2.channelInTransitionBDD)); //CUDD.Ref(guardDD); result.channelOutTransitionBDD.AddRange(CUDD.Function.And(guardDD, P2.channelOutTransitionBDD)); }
public static CUDDNode NondetUntil(CUDDNode trans, CUDDNode nondetMask, CUDDVars allRowVars, CUDDVars allColVars, CUDDVars nondetVars, CUDDNode yes, CUDDNode maybe, bool min) { DateTime startTime = DateTime.Now; int numberOfIterations = 0; CUDDNode a, sol, tmp; CUDD.Ref(trans, maybe); a = CUDD.Function.Times(trans, maybe); CUDD.Ref(yes); sol = yes; while (true) { numberOfIterations++; tmp = CUDD.Matrix.MatrixMultiplyVector(a, sol, allRowVars, allColVars); if (min) { CUDD.Ref(nondetMask); tmp = CUDD.Function.Maximum(tmp, nondetMask); tmp = CUDD.Abstract.MinAbstract(tmp, nondetVars); } else { tmp = CUDD.Abstract.MaxAbstract(tmp, nondetVars); } CUDD.Ref(yes); tmp = CUDD.Function.Maximum(tmp, yes); //check convergence if (CUDD.IsEqual(tmp, sol)) { CUDD.Deref(tmp); break; } CUDD.Deref(sol); sol = tmp; } DateTime endTime = DateTime.Now; double runningTime = (endTime - startTime).TotalSeconds; Debug.WriteLine("NondetUntil: " + numberOfIterations + " iterations in " + runningTime + " seconds"); // CUDD.Deref(a); return(sol); }
public CUDDNode ComputeReachReward(CUDDNode b, int rewardStructIndex) { //Reference to b in the calling place and create a new copy CUDD.Ref(b, reach); b = CUDD.Function.And(b, reach); // CUDDNode inf, maybe, reward; if (b.Equals(CUDD.ZERO)) { CUDD.Ref(reach); inf = reach; maybe = CUDD.Constant(0); } else if (b.Equals(reach)) { inf = CUDD.Constant(0); maybe = CUDD.Constant(0); } else { CUDDNode no = ProbAlgo.Prob0(trans01, reach, allRowVars, allColVars, reach, b); CUDDNode prob1 = ProbAlgo.Prob1(trans01, reach, allRowVars, allColVars, reach, b, no); CUDD.Deref(no); CUDD.Ref(reach); inf = CUDD.Function.And(reach, CUDD.Function.Not(prob1)); CUDD.Ref(reach, inf, b); maybe = CUDD.Function.And(reach, CUDD.Function.Not(CUDD.Function.Or(inf, b))); } // print out yes/no/maybe Debug.WriteLine("goal = " + CUDD.GetNumMinterms(b, allRowVars.GetNumVars())); Debug.WriteLine("inf = " + CUDD.GetNumMinterms(inf, allRowVars.GetNumVars())); Debug.WriteLine("maybe = " + CUDD.GetNumMinterms(maybe, allRowVars.GetNumVars())); if (maybe.Equals(CUDD.ZERO)) { CUDD.Ref(inf); reward = CUDD.Function.ITE(inf, CUDD.PlusInfinity(), CUDD.Constant(0)); } else { reward = ProbAlgo.ProbReachReward(trans, stateRewards[rewardStructIndex], transRewards[rewardStructIndex], reach, allRowVars, allColVars, maybe, inf); } CUDD.Deref(inf, maybe, b); CUDD.Ref(start); return(CUDD.Function.Times(reward, start)); }
/// <summary> /// P ◦ R is the set of all successors of states in the set P /// [ REFS: 'result', DEREFS:states] /// </summary> /// <param name="states"></param> /// <param name="transitions"></param> /// <returns></returns> public CUDDNode Successors(CUDDNode states, List <CUDDNode> transitions) { CUDD.Ref(transitions); CUDDNode temp = CUDD.Function.And(states, transitions); CUDDNode successors = SwapRowColVars(temp); successors = CUDD.Abstract.ThereExists(successors, AllColVars); return(successors); }
/// <summary> /// R ? P is the set of all predecessors of states in the set P /// [ REFS: 'result', DEREFS:states] /// </summary> /// <param name="states"></param> /// <param name="transitions"></param> /// <returns></returns> public CUDDNode Predecessors(CUDDNode states, List <CUDDNode> transitions) { CUDDNode temp = this.SwapRowColVars(states); CUDD.Ref(transitions); CUDDNode predecessors = CUDD.Function.And(temp, transitions); predecessors = CUDD.Abstract.ThereExists(predecessors, AllColVars); return(predecessors); }
/// <summary> /// Return the rol-vars vector of the product of matrix and vector /// [ REFS: 'result', DEREFS: '' ] /// </summary> /// <param name="matrix">Matrix of rol * col vars</param> /// <param name="vector">Vector of rol vars</param> /// <returns></returns> public static CUDDNode MatrixMultiplyVector(CUDDNode matrix, CUDDNode vector, CUDDVars allRowVars, CUDDVars allColVars) { //Return matrix * vector CUDD.Ref(vector); CUDDNode temp = Variable.SwapVariables(vector, allRowVars, allColVars); CUDD.Ref(matrix); CUDDNode result = MatrixMultiply(matrix, temp, allColVars, BOULDER); return(result); }
/// <summary> /// Forward search, check destination is reachable from source /// Store all reachable states and check fix point /// At step t, find all reachable states after t time units /// Fix point: rechable(0, t) == rechable(0, t + 1) /// [ REFS: '', DEREFS:] /// </summary> /// <param name="source"></param> /// <param name="destination"></param> /// <param name="discreteTransitions"></param> /// <returns></returns> public bool PathForward1(CUDDNode source, CUDDNode destination, List <CUDDNode> discreteTransitions, List <CUDDNode> tickTransitions) { // bool reachable = false; CUDD.Ref(source); CUDDNode allReachableFromInit = SuccessorsStart(source, discreteTransitions); CUDD.Ref(allReachableFromInit); CUDDNode currentReachableFromInit = allReachableFromInit; CUDDNode commonNode = CUDD.Constant(0); do { Debug.WriteLine("Successors: " + numberOfBDDOperation++); currentReachableFromInit = Successors(currentReachableFromInit, tickTransitions); currentReachableFromInit = SuccessorsStart(currentReachableFromInit, discreteTransitions); //Check 2 directions have intersection CUDD.Ref(destination, currentReachableFromInit); CUDD.Deref(commonNode); commonNode = CUDD.Function.And(destination, currentReachableFromInit); if (!commonNode.Equals(CUDD.ZERO)) { reachable = true; break; } //find fixpoint CUDD.Ref(currentReachableFromInit, allReachableFromInit); CUDDNode allReachabeFromInitTemp = CUDD.Function.Or(currentReachableFromInit, allReachableFromInit); if (allReachabeFromInitTemp.Equals(allReachableFromInit)) { //reachable = false; CUDD.Deref(allReachabeFromInitTemp); break; } else { currentReachableFromInit = CUDD.Function.Different(currentReachableFromInit, allReachableFromInit); allReachableFromInit = allReachabeFromInitTemp; } } while (true); CUDD.Deref(allReachableFromInit, currentReachableFromInit, commonNode); // return(reachable); }
/// <summary> /// Encode all commands whose labels are the same as labelToBeEncoded /// </summary> /// <param name="moduleIndex"></param> /// <param name="module"></param> /// <param name="labelToBeEncoded"></param> private ComponentDDs EncodeModule(int moduleIndex, Module module, string labelToBeEncoded, int currentAvailStartBit) { //Store guard, and the final encoding of each command List <CUDDNode> guardDDs = new List <CUDDNode>(); List <CUDDNode> commandDDs = new List <CUDDNode>(); for (int i = 0; i < module.Commands.Count; i++) { Command command = module.Commands[i]; if (command.Synch == labelToBeEncoded) { CUDDNode guardDD = EncodeExpression(command.Guard); CUDD.Ref(allRowVarRanges); guardDD = CUDD.Function.And(guardDD, allRowVarRanges); if (guardDD.Equals(CUDD.ZERO)) { Debug.WriteLine("Warning: Guard " + command.Guard + " for command " + (i + 1) + " of module \"" + module.Name + "\" is never satisfied.\n"); guardDDs.Add(guardDD); commandDDs.Add(CUDD.Constant(0)); } else { CUDDNode updateDD = EncodeCommand(moduleIndex, command.Updates, guardDD); guardDDs.Add(guardDD); commandDDs.Add(updateDD); } } else { guardDDs.Add(CUDD.Constant(0)); commandDDs.Add(CUDD.Constant(0)); } } ComponentDDs result; if (modules.modelType == ModelType.DTMC) { result = CombineProbCommands(moduleIndex, guardDDs, commandDDs); } else if (modules.modelType == ModelType.MDP) { result = CombineNondetCommands(guardDDs, commandDDs, currentAvailStartBit); } else { throw new Exception("Unknown model type"); } return(result); }
/// <summary> /// Forward search, check destination is reachable from source /// NOT store all reachable states, use some special condition to terminate /// At step t, find all reachable states after t time units /// Fix point when rechable(t1 + a, t1 + a) is a subset of rechable(t1, t1) /// Rabbit algorithm (S x Tick x Trans*)* /// [ REFS: '', DEREFS:] /// </summary> /// <param name="source"></param> /// <param name="destination"></param> /// <param name="discreteTransitions"></param> /// <returns></returns> public bool PathForward2(CUDDNode source, CUDDNode destination, List <CUDDNode> discreteTransitions, List <CUDDNode> tickTransitions) { // bool reachable = false; CUDD.Ref(source); CUDDNode currentReachableFromInit = SuccessorsStart(source, discreteTransitions); CUDDNode previousReachableFromInit = CUDD.Constant(0); int s, p; s = p = 0; CUDDNode commonNode = CUDD.Constant(0); int numberOfLoop = 0; while (!CUDD.IsSubSet(previousReachableFromInit, currentReachableFromInit)) { numberOfLoop++; Debug.Write(numberOfLoop + " "); if (p <= s / 2) { p = s; CUDD.Deref(previousReachableFromInit); CUDD.Ref(currentReachableFromInit); previousReachableFromInit = currentReachableFromInit; } currentReachableFromInit = Successors(currentReachableFromInit, tickTransitions); currentReachableFromInit = SuccessorsStart(currentReachableFromInit, discreteTransitions); s++; //Check 2 directions have intersection CUDD.Ref(destination, currentReachableFromInit); CUDD.Deref(commonNode); commonNode = CUDD.Function.And(destination, currentReachableFromInit); if (!commonNode.Equals(CUDD.ZERO)) { reachable = true; break; } } Debug.WriteLine("\nTA Path Forward 2: " + numberOfLoop + " loops."); CUDD.Deref(currentReachableFromInit, previousReachableFromInit, commonNode); // return(reachable); }
private void GenerateBelievePrecondition() { //OK BelievePrecondition = _believeEventArray[0].Precondition; CUDD.Ref(BelievePrecondition); for (int i = 1; i < _believeEventArray.Length; i++) { CUDDNode eventPreNode = _believeEventArray[i].Precondition; CUDD.Ref(eventPreNode); BelievePrecondition = CUDD.Function.Or(BelievePrecondition, eventPreNode); } }
/// <summary> /// Generate the counter example for LTL model checking, including 2 parts: prefix, and period. /// [ REFS: '', DEREFS: automataBDD.transitionBDD, this.prefix, this.period ] /// </summary> /// <param name="automataBDD"></param> /// <param name="encoder"></param> /// <returns></returns> public void GetMCResult(AutomataBDD automataBDD, BDDEncoder encoder) { VerificationOutput.CounterExampleTrace.Add(InitialStep); if (VerificationOutput.VerificationResult == VerificationResultType.INVALID && VerificationOutput.GenerateCounterExample) { VerificationOutput.LoopIndex = this.prefix.Count + 1; List <CUDDNode> traces = new List <CUDDNode>(); ExpressionBDDEncoding initEncoding = automataBDD.initExpression.TranslateBoolExpToBDD(encoder.model); traces.Add(CUDD.Function.Or(initEncoding.GuardDDs)); traces.AddRange(this.prefix); traces.AddRange(this.period); Valuation currentValuation = this.InitialStep.GlobalEnv; Valuation lastValuation; for (int i = 1; i < traces.Count; i++) { //Get event information CUDD.Ref(traces[i], traces[i - 1]); CUDDNode transitionTemp = CUDD.Function.And(traces[i - 1], encoder.model.SwapRowColVars(traces[i])); CUDD.Ref(automataBDD.transitionBDD); CUDDNode transWithEventInfo = CUDD.Function.And(transitionTemp, automataBDD.transitionBDD); transWithEventInfo = CUDD.Abstract.ThereExists(transWithEventInfo, encoder.model.AllRowVarsExceptSingleCopy); transWithEventInfo = CUDD.RestrictToFirst(transWithEventInfo, encoder.model.AllColVars); lastValuation = currentValuation; currentValuation = encoder.GetValuationFromBDD(transWithEventInfo, this.InitialStep.GlobalEnv); string eventName = encoder.GetEventChannelName(lastValuation, currentValuation, transWithEventInfo); VerificationOutput.CounterExampleTrace.Add(new ConfigurationBDD(eventName, currentValuation)); // CUDD.Deref(transWithEventInfo); } // CUDD.Deref(traces); } CUDD.Deref(automataBDD.transitionBDD); VerificationOutput.ActualMemoryUsage = CUDD.ReadMemoryInUse(); VerificationOutput.numberOfBoolVars = encoder.model.NumberOfBoolVars; encoder.model.Close(); }
/// <summary> /// Return AutomataBDD of Sequence process /// </summary> /// <param name="P1">AutomataBDD of the first process</param> /// <param name="P2">AutomataBDD of the second process</param> /// <param name="model"></param> /// <returns></returns> public static AutomataBDD Sequence(AutomataBDD P1, AutomataBDD P2, Model model) { AutomataBDD result = new AutomataBDD(); List <string> varNames = AutomataBDD.SequenceSetVariable(P1, P2, model, result); AutomataBDD.SequenceSetInit(varNames[0], P1, P2, result); CUDD.Ref(P1.transitionBDD); AutomataBDD.SequenceEncodeTransition(varNames[0], P1, P2, model, result); SequenceEncodeTick(varNames[0], P1, P2, model, result); // return(result); }
/// <summary> /// The result already contains the guard of this command. In other words, this is the encoding of the whole command, not just only update part. /// [ REFS: 'result', DEREFS: '' ] /// </summary> /// <param name="moduleIndex"></param> /// <param name="updates"></param> /// <param name="guardDD"></param> /// <returns></returns> private CUDDNode EncodeCommand(int moduleIndex, List <Update> updates, CUDDNode guardDD) { CUDDNode result = CUDD.Constant(0); foreach (var update in updates) { CUDD.Ref(guardDD); CUDDNode updateDD = EncodeUpdate(moduleIndex, update, guardDD); result = CUDD.Function.Plus(result, updateDD); } return(result); }
/// <summary> /// Return state having probability 1 of b1 U b2 /// [ REFS: 'result', DEREFS: ] /// </summary> /// <param name="trans01"></param> /// <param name="reach"></param> /// <param name="allRowVars"></param> /// <param name="allColVars"></param> /// <param name="b1"></param> /// <param name="b2"></param> /// <param name="no"></param> /// <returns></returns> public static CUDDNode Prob1(CUDDNode trans01, CUDDNode reach, CUDDVars allRowVars, CUDDVars allColVars, CUDDNode b1, CUDDNode b2, CUDDNode no) { DateTime startTime = DateTime.Now; int numberOfIterations = 0; CUDD.Ref(no); CUDDNode sol = no; while (true) { numberOfIterations++; CUDD.Ref(sol); CUDDNode tmp = CUDD.Variable.SwapVariables(sol, allRowVars, allColVars); CUDD.Ref(trans01); tmp = CUDD.Function.And(tmp, trans01); tmp = CUDD.Abstract.ThereExists(tmp, allColVars); CUDD.Ref(b1); tmp = CUDD.Function.And(b1, tmp); CUDD.Ref(b2); tmp = CUDD.Function.And(CUDD.Function.Not(b2), tmp); CUDD.Ref(no); tmp = CUDD.Function.Or(no, tmp); if (tmp.Equals(sol)) { CUDD.Deref(tmp); break; } CUDD.Deref(sol); sol = tmp; } CUDD.Ref(reach); sol = CUDD.Function.And(reach, CUDD.Function.Not(sol)); DateTime endTime = DateTime.Now; double runningTime = (endTime - startTime).TotalSeconds; Debug.WriteLine("Prob1: " + numberOfIterations + " iterations in " + runningTime + " seconds"); return(sol); }
/// <summary> /// tau transition in process 2 does not resolve /// [ REFS: '', DEREFS: 'P1, P2'] /// </summary> /// <param name="P1"></param> /// <param name="P2"></param> /// <param name="model"></param> /// <param name="result"></param> private static void InterruptEncodeTransition(AutomataBDD P1, AutomataBDD P2, Model model, AutomataBDD result) { //1. (isInterrupted < 2 ∧ P1.Trans/In/Out ∧ [(event' = termination and isInterrupted' = 1) or (event' != termination and isInterrupted' = isInterrupted)] P2.var = P2.var') Expression guard = Expression.AND( Expression.LT(new Variable(result.newLocalVarName), new IntConstant(2)), Expression.OR( Expression.AND( GetTerminateTransExpression(), new Assignment(result.newLocalVarName, new IntConstant(1))), Expression.AND( GetNotTerminateTransExpression(), new Assignment(result.newLocalVarName, new Variable(result.newLocalVarName)))) ); List <CUDDNode> transition = guard.TranslateBoolExpToBDD(model).GuardDDs; transition = model.AddVarUnchangedConstraint(transition, P2.variableIndex); // CUDD.Ref(transition); result.transitionBDD.AddRange(CUDD.Function.And(transition, P1.transitionBDD)); CUDD.Ref(transition); result.channelInTransitionBDD.AddRange(CUDD.Function.And(transition, P1.channelInTransitionBDD)); result.channelOutTransitionBDD.AddRange(CUDD.Function.And(transition, P1.channelOutTransitionBDD)); //2. (isInterrupted != 1 ∧ P2.Trans/In/Out ∧ [(event' = tau and isInterrupted' = isInterrupted) or (event' != tau and isInterrupted' = 2)]) guard = Expression.AND( Expression.NE(new Variable(result.newLocalVarName), new IntConstant(1)), Expression.OR( Expression.AND( GetTauTransExpression(), new Assignment(result.newLocalVarName, new Variable(result.newLocalVarName))), Expression.AND( GetNotTauTransExpression(), new Assignment(result.newLocalVarName, new IntConstant(2)))) ); transition = guard.TranslateBoolExpToBDD(model).GuardDDs; // CUDD.Ref(transition); result.transitionBDD.AddRange(CUDD.Function.And(transition, P2.transitionBDD)); CUDD.Ref(transition); result.channelInTransitionBDD.AddRange(CUDD.Function.And(transition, P2.channelInTransitionBDD)); //CUDD.Ref(transition); result.channelOutTransitionBDD.AddRange(CUDD.Function.And(transition, P2.channelOutTransitionBDD)); }
private static CUDDNode GetCuddNode(this PlanningParser.TermAtomFormContext context, IReadOnlyDictionary <string, Predicate> predicateDict, StringDictionary assignment) { CUDDNode result; if (context.predicate() != null) { string predicateFullName = ConstContainer.GetFullName(context, assignment); Predicate predicate = predicateDict[predicateFullName]; int cuddIndex = predicate.PreviousCuddIndex; result = CUDD.Var(cuddIndex); } else { string firstTermString = Globals.TermInterpreter.GetString(context.term(0), assignment); string secondTermString = Globals.TermInterpreter.GetString(context.term(1), assignment); if (context.EQ() != null) { result = firstTermString == secondTermString ? CUDD.ONE : CUDD.ZERO; } else if (context.NEQ() != null) { result = firstTermString != secondTermString ? CUDD.ONE : CUDD.ZERO; } else { int firstValue = int.Parse(firstTermString); int secondValue = int.Parse(secondTermString); if (context.LT() != null) { result = firstValue < secondValue ? CUDD.ONE : CUDD.ZERO; } else if (context.LEQ() != null) { result = firstValue <= secondValue ? CUDD.ONE : CUDD.ZERO; } else if (context.GT() != null) { result = firstValue > secondValue ? CUDD.ONE : CUDD.ZERO; } else { result = firstValue >= secondValue ? CUDD.ONE : CUDD.ZERO; } } CUDD.Ref(result); } return(result); }
private static CUDDNode RecursiveScanMixedRaio(PlanningParser.GdContext context, IReadOnlyDictionary <string, Predicate> predicateDict, IReadOnlyList <string> variableNameList, IReadOnlyList <IList <string> > collection, StringDictionary assignment, int currentLevel = 0, bool isForall = true) { CUDDNode result; if (currentLevel != variableNameList.Count) { string variableName = variableNameList[currentLevel]; result = isForall ? CUDD.ONE : CUDD.ZERO; CUDD.Ref(result); CUDDNode equalNode = isForall ? CUDD.ZERO : CUDD.ONE; Func <CUDDNode, CUDDNode, CUDDNode> boolFunc; if (isForall) { boolFunc = CUDD.Function.And; } else { boolFunc = CUDD.Function.Or; } foreach (string value in collection[currentLevel]) { assignment[variableName] = value; CUDDNode gdNode = RecursiveScanMixedRaio(context, predicateDict, variableNameList, collection, assignment, currentLevel + 1, isForall); if (gdNode.Equals(equalNode)) { CUDD.Deref(result); result = equalNode; CUDD.Ref(result); break; } result = boolFunc(result, gdNode); } } else { result = GetCuddNode(context, predicateDict, assignment); } return(result); }
/// <summary> /// [ REFS: 'result', DEREFS: '' ] /// </summary> /// <param name="b"></param> /// <returns></returns> public CUDDNode ComputeNextProb(CUDDNode b) { //Reference to b in the calling place and create a new copy CUDD.Ref(b, reach); b = CUDD.Function.And(b, reach); CUDDNode allProbs = CUDD.Matrix.MatrixMultiplyVector(trans, b, allRowVars, allColVars); // CUDD.Deref(b); CUDD.Ref(start); return(CUDD.Function.Times(allProbs, start)); }
private static void WaitUntilEncodeTransitionChannel(string state, string isTerminate, AutomataBDD m0, int t, Model model, AutomataBDD result) { Expression guard; List <CUDDNode> guardDD, transTemp; //1. m0.Trans/In/Out and state' = state and [(event' = terminate and isTerminate') or (event' != terminate and isTerminate' = isTerminate)] guard = new PrimitiveApplication(PrimitiveApplication.AND, new Assignment(state, new Variable(state)), new PrimitiveApplication(PrimitiveApplication.OR, new PrimitiveApplication(PrimitiveApplication.AND, new Assignment(Model.EVENT_NAME, new IntConstant(Model.TERMINATE_EVENT_INDEX)), new Assignment(isTerminate, new IntConstant(1))), new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.NOT, new Assignment(Model.EVENT_NAME, new IntConstant(Model.TERMINATE_EVENT_INDEX))), new Assignment(isTerminate, new Variable(isTerminate))))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; CUDD.Ref(guardDD); transTemp = CUDD.Function.And(m0.transitionBDD, guardDD); result.transitionBDD.AddRange(transTemp); // CUDD.Ref(guardDD); transTemp = CUDD.Function.And(m0.channelInTransitionBDD, guardDD); result.channelInTransitionBDD.AddRange(transTemp); // //CUDD.Ref(guardDD); transTemp = CUDD.Function.And(m0.channelOutTransitionBDD, guardDD); result.channelOutTransitionBDD.AddRange(transTemp); //2. isTerminate and state = t and event' = terminate and isTermniate' & state = t + 1 guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(isTerminate), new IntConstant(1)), new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(state), new IntConstant(t)), new PrimitiveApplication(PrimitiveApplication.AND, new Assignment(Model.EVENT_NAME, new IntConstant(Model.TERMINATE_EVENT_INDEX)), new PrimitiveApplication(PrimitiveApplication.AND, new Assignment(isTerminate, new IntConstant(1)), new Assignment(state, new IntConstant(t + 1)))))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; CUDD.Ref(guardDD); transTemp = CUDD.Function.And(m0.transitionBDD, guardDD); result.transitionBDD.AddRange(transTemp); // CUDD.Ref(guardDD); transTemp = CUDD.Function.And(m0.channelInTransitionBDD, guardDD); result.channelInTransitionBDD.AddRange(transTemp); // //CUDD.Ref(guardDD); transTemp = CUDD.Function.And(m0.channelOutTransitionBDD, guardDD); result.channelOutTransitionBDD.AddRange(transTemp); }
/// <summary> /// Return Pmin(phi1 U phi2) = 1 /// </summary> /// <param name="trans01"></param> /// <param name="reach"></param> /// <param name="nondetMask"></param> /// <param name="allRowVars"></param> /// <param name="allColVars"></param> /// <param name="nondetVar"></param> /// <param name="no"></param> /// <param name="b2"></param> /// <returns></returns> public static CUDDNode Prob1A(CUDDNode trans01, CUDDNode reach, CUDDNode nondetMask, CUDDVars allRowVars, CUDDVars allColVars, CUDDVars nondetVar, CUDDNode no, CUDDNode b2) { DateTime startTime = DateTime.Now; int numberOfIterations = 0; CUDD.Ref(reach, no); CUDDNode notNo = CUDD.Function.And(reach, CUDD.Function.Not(no)); CUDD.Ref(b2, notNo); CUDDNode sol = CUDD.Function.Or(b2, notNo); while (true) { numberOfIterations++; CUDD.Ref(sol); CUDDNode tmp = CUDD.Variable.SwapVariables(sol, allRowVars, allColVars); CUDD.Ref(trans01); tmp = CUDD.Abstract.ForAll(CUDD.Function.Implies(trans01, tmp), allColVars); CUDD.Ref(nondetMask); tmp = CUDD.Function.Or(tmp, nondetMask); tmp = CUDD.Abstract.ForAll(tmp, nondetVar); CUDD.Ref(notNo); tmp = CUDD.Function.And(notNo, tmp); CUDD.Ref(b2); tmp = CUDD.Function.Or(b2, tmp); if (tmp.Equals(sol)) { CUDD.Deref(tmp); break; } CUDD.Deref(sol); sol = tmp; } DateTime endTime = DateTime.Now; double runningTime = (endTime - startTime).TotalSeconds; Debug.WriteLine("Prob1A: " + numberOfIterations + " iterations in " + runningTime + " seconds"); // CUDD.Deref(notNo); return(sol); }
public NondetModelChecker(NonDetModel model) : base(model) { allNondetVars = model.allNondetVars; FilterStates(); CUDD.Ref(trans01, reach); nondetMask = CUDD.Function.And(CUDD.Function.Not(CUDD.Abstract.ThereExists(trans01, allColVars)), reach); Debug.WriteLine("States: " + CUDD.GetNumMinterms(reach, allRowVars.GetNumVars()) + " (" + CUDD.GetNumMinterms(start, allRowVars.GetNumVars()) + " initial)"); Debug.WriteLine("Transitions: " + CUDD.GetNumMinterms(trans01, allRowVars.GetNumVars() * 2 + allNondetVars.GetNumVars())); Debug.WriteLine("Transition matrix: " + CUDD.Print.GetInfoString(trans, allRowVars.GetNumVars() * 2 + allNondetVars.GetNumVars()) + ", vars: " + allRowVars.GetNumVars() + "r/" + allColVars.GetNumVars() + "c/" + allNondetVars.GetNumVars() + "nd"); }
private void HandleInitBelief(PlanningParser.InitBeliefContext context) { if (context != null) { StringDictionary assignment = new StringDictionary(); InitBelief = context.gd().GetCuddNode(_predicateDict, assignment); InitBelief = CUDD.Function.And(InitBelief, _exclusiveAxiom); } else { InitBelief = InitKnowledge; CUDD.Ref(InitBelief); CUDD.Deref(_exclusiveAxiom); } }
/// <summary> /// Return variable expression /// </summary> public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model) { ExpressionBDDEncoding result = new ExpressionBDDEncoding(); result.GuardDDs.Add(CUDD.Constant(1)); int variableIndex = model.GetVarIndex(this.expressionID); CUDDNode varDD = model.variableEncoding[variableIndex]; CUDD.Ref(varDD); result.ExpressionDDs.Add(varDD); return(result); }
/// <summary> /// Add new local variable /// </summary> /// <param name="name"></param> /// <param name="lower"></param> /// <param name="upper"></param> public void AddLocalVar(string name, int lower, int upper) { varList.AddNewVariable(name, lower, upper); int numBits = varList.GetNumberOfBits(name); CUDDNode vr, vc; CUDDVars rowVar = new CUDDVars(); CUDDVars colVar = new CUDDVars(); for (int j = 0; j < numBits; j++) { vr = CUDD.Var(numverOfBoolVars++); vc = CUDD.Var(numverOfBoolVars++); rowVar.AddVar(vr); colVar.AddVar(vc); } this.rowVars.Add(rowVar); this.colVars.Add(colVar); this.AllRowVars.AddVars(rowVar); this.AllRowVarsExceptSingleCopy.AddVars(rowVar); this.AllColVars.AddVars(colVar); // used for unchanged variable in transition. CUDDNode identity = CUDD.Constant(0); for (int i = lower; i <= upper; i++) { identity = CUDD.Matrix.SetMatrixElement(identity, rowVar, colVar, i - lower, i - lower, 1); } this.varIdentities.Add(identity); // CUDDNode expressionDD = CUDD.MINUS_INFINITY; CUDD.Ref(expressionDD); for (int i = lower; i <= upper; i++) { expressionDD = CUDD.Matrix.SetVectorElement(expressionDD, rowVar, i - lower, i); } this.variableEncoding.Add(expressionDD); // CUDD.Ref(identity); allRowVarRanges = CUDD.Function.And(allRowVarRanges, CUDD.Abstract.ThereExists(identity, colVar)); CUDD.Ref(identity); colVarRanges.Add(CUDD.Abstract.ThereExists(identity, rowVar)); }
/// <summary> /// Return strongly connected components /// Does not include Event variable /// this.transitionsNoEvents is the transtion from reachble states /// From Feasible algorithm in the article "LTL Symbolic MC" /// [ REFS: 'result', DEREFS:] /// </summary> /// <param name="model"></param> /// <param name="initState"></param> /// <param name="cycleMustPass">The cycle must pass all states in the cycleMustPass</param> /// <returns></returns> private CUDDNode SCCHull(Model model, CUDDNode initState, List <CUDDNode> cycleMustPass) { CUDDNode old = CUDD.Constant(0); CUDD.Ref(initState); CUDDNode New = model.SuccessorsStart(initState, this.transitionsNoEvents); //Limit transition to transition of reachable states CUDD.Ref(New, New); transitionsNoEvents[0] = CUDD.Function.And(transitionsNoEvents[0], New); transitionsNoEvents[1] = CUDD.Function.And(transitionsNoEvents[1], New); //Pruning step: remove states whose succeessors are not belong to that set while (!New.Equals(old)) { CUDD.Deref(old); CUDD.Ref(New); old = New; foreach (var justice in cycleMustPass) { //final state as justice requirement //new = (new and J) x R* CUDD.Ref(justice); New = model.SuccessorsStart(CUDD.Function.And(New, justice), this.transitionsNoEvents); } //while new is not comprised of the set of all successors of new states while (true) { CUDD.Ref(New, New); CUDDNode temp = CUDD.Function.And(New, model.Successors(New, this.transitionsNoEvents)); if (temp.Equals(New)) { CUDD.Deref(temp); break; } else { CUDD.Deref(New); New = temp; } } } return(New); }
/// <summary> /// [ REFS: 'result', DEREFS: 'guard' ] /// </summary> /// <param name="moduleIndex"></param> /// <param name="update"></param> /// <param name="synch"></param> /// <param name="guard"></param> /// <returns></returns> public CUDDNode EncodeUpdate(int moduleIndex, Update update, CUDDNode guard) { List <int> updatedVarIndexes = new List <int>(); CUDDNode result = CUDD.Constant(1); foreach (var assignment in update.Assignments) { int varIndex = varList.GetVarIndex(assignment.LeftHandSide); updatedVarIndexes.Add(varIndex); int low = varList.GetVarLow(varIndex); int high = varList.GetVarHigh(varIndex); CUDDNode leftDD = CUDD.Constant(0); for (int i = low; i <= high; i++) { leftDD = CUDD.Matrix.SetVectorElement(leftDD, colVars[varIndex], i - low, i); } CUDDNode rightDD = EncodeExpression(assignment.RightHandSide); CUDDNode commandDD = CUDD.Function.Equal(leftDD, rightDD); CUDD.Ref(guard); commandDD = CUDD.Function.And(commandDD, guard); //filter out of range configuration CUDD.Ref(colVarRanges[varIndex]); commandDD = CUDD.Function.And(commandDD, colVarRanges[varIndex]); CUDD.Ref(allRowVarRanges); commandDD = CUDD.Function.And(commandDD, allRowVarRanges); result = CUDD.Function.And(result, commandDD); } //Global variables and other local variables in the current module if not updated must be the same for (int i = 0; i < varList.GetNumberOfVar(); i++) { if ((varList.GetModuleIndex(i) == moduleIndex || varList.GetModuleIndex(i) == Modules.DefaultMainModuleIndex) && !updatedVarIndexes.Contains(i)) { CUDD.Ref(varIdentities[i]); result = CUDD.Function.And(result, varIdentities[i]); } } return(CUDD.Function.Times(result, CUDD.Constant((update.Probability as DoubleConstant).Value))); }
private void GenerateKnowPrecondition() { KnowPrecondition = BelievePrecondition; if (MaxPlausibilityDegree == 1) { CUDD.Ref(KnowPrecondition); for (int i = _believeEventArray.Length; i < _knowEventArray.Length; i++) { CUDDNode eventPreNode = _knowEventArray[i].Precondition; CUDD.Ref(eventPreNode); KnowPrecondition = CUDD.Function.Or(KnowPrecondition, eventPreNode); } } }
/// <summary> /// (temp ∧ P1.Trans/In/Out ∧ temp') /// [ REFS: '', DEREFS: 'P1'] /// </summary> private static void CopyTransitionAfterEventChannel(AutomataBDD P1, Model model, AutomataBDD result) { Expression guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(1)), new Assignment(result.newLocalVarName, new IntConstant(1))); List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; // CUDD.Ref(guardDD); result.transitionBDD.AddRange(CUDD.Function.And(guardDD, P1.transitionBDD)); CUDD.Ref(guardDD); result.channelInTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelInTransitionBDD)); //CUDD.Ref(guardDD); result.channelOutTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelOutTransitionBDD)); }
private void HandleInitKnowledge(PlanningParser.InitKnowledgeContext context) { CUDD.Ref(_exclusiveAxiom); //Console.WriteLine("Exclusive axiom:"); //CUDD.Print.PrintMinterm(_exclusiveAxiom); if (context != null) { StringDictionary assignment = new StringDictionary(); InitKnowledge = context.gd().GetCuddNode(_predicateDict, assignment); InitKnowledge = CUDD.Function.And(_exclusiveAxiom, InitKnowledge); } else { InitKnowledge = _exclusiveAxiom; } }
public CUDDNode ComputeCumulReward(int rewardStructIndex, int bound) { CUDDNode result = CUDD.Constant(0); if (bound > 0) { CUDDNode allRewards = ProbAlgo.ProbCumulReward(trans, stateRewards[rewardStructIndex], transRewards[rewardStructIndex], allRowVars, allColVars, bound); CUDD.Deref(result); CUDD.Ref(start); result = CUDD.Function.Times(allRewards, start); } // return(result); }