public override ExpressionBDDEncoding TranslateBoolExpToBDD(Model model) { ExpressionBDDEncoding result = new ExpressionBDDEncoding(); result.GuardDDs.Add(CUDD.Constant(1)); result = TranslateStatementToBDD(result, model); return(result); }
/// <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 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)); }
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); }
/// <summary> /// Close the model, dereference variables /// </summary> public void Close() { this.AllRowVarsExceptSingleCopy.Deref(); this.AllColVars.Deref(); CUDD.Deref(this.varIdentities); CUDD.Deref(this.variableEncoding); CUDD.Deref(this.variableRanges); CUDD.CloseDownCUDD(); }
/// <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> /// [ REFS: 'none', DEREFS: 'dd if failed to add' ] /// </summary> public void AddNodeToGuard(CUDDNode dd) { if (!dd.Equals(CUDD.ZERO)) { this.GuardDDs.Add(dd); } else { CUDD.Deref(dd); } }
/// <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); }
public void Deref() { CUDD.Deref(ind.guards, ind.trans); CUDD.Deref(ind.rewards); foreach (var componentDDse in synchs) { CUDD.Deref(componentDDse.guards, componentDDse.trans); CUDD.Deref(componentDDse.rewards); } CUDD.Deref(id); }
/// <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); }
private void HandlePredicateDefine(PlanningParser.PredicateDefineContext context) { _exclusiveAxiom = CUDD.Constant(1); _predicateDict = new Dictionary <string, Predicate>(); foreach (var atomFormSkeleton in context.atomFormSkeleton()) { PredicateEnumerator enumerator = new PredicateEnumerator(atomFormSkeleton, _predicateDict, _currentCuddIndex); Algorithms.IterativeScanMixedRadix(enumerator); _currentCuddIndex = enumerator.CurrentCuddIndex; if (atomFormSkeleton.oneofDefine() != null) { Console.WriteLine("Predicate {0} have oneOf", atomFormSkeleton.predicate().GetText()); //Console.WriteLine("Hello!"); //Console.ReadLine(); string predicateName = atomFormSkeleton.predicate().GetText(); int oneOfVarsCount = atomFormSkeleton.oneofDefine().VAR().Count; string[] oneOfVarNameArray = new string[oneOfVarsCount]; var varNameList = atomFormSkeleton.listVariable().GetVariableNameList(); var collection = atomFormSkeleton.listVariable().GetCollection(); IList <string>[] notOneOfVarCollection = new IList <string> [varNameList.Count - oneOfVarsCount]; Parallel.For(0, oneOfVarsCount, i => oneOfVarNameArray[i] = atomFormSkeleton.oneofDefine().VAR(i).GetText()); for (int i = 0, k = 0; i < varNameList.Count; i++) { bool exists = oneOfVarNameArray.Any(s => s == varNameList[i]); if (!exists) { notOneOfVarCollection[k] = collection[i]; k++; if (k == notOneOfVarCollection.Length) { break; } } } ExclusiveAxiomEnumerator exclusiveAxiomEnumerator = new ExclusiveAxiomEnumerator(predicateName, _predicateDict, notOneOfVarCollection); Algorithms.IterativeScanMixedRadix(exclusiveAxiomEnumerator); _exclusiveAxiom = CUDD.Function.And(_exclusiveAxiom, exclusiveAxiomEnumerator.ExclusiveAxiom); } } //foreach (var predicate in _predicateDict.Values) //{ // Console.WriteLine("name: {0}, Previous index: {1}, successive index: {2}", predicate.FullName, predicate.PreviousCuddIndex, predicate.SuccessiveCuddIndex); //} }
/// <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); } }
static void Test1(string domainFileName, string problemFileName) { CUDD.InitialiseCUDD(256, 256, 262144, 0.1); // Create a TextReader that reads from a file TextReader tr = new StreamReader(domainFileName); // create a CharStream that reads from standard input AntlrInputStream input = new AntlrInputStream(tr); // create a lexer that feeds off of input CharStream PlanningLexer lexer = new PlanningLexer(input); // create a buffer of tokens pulled from the lexer CommonTokenStream tokens = new CommonTokenStream(lexer); // create a parser that feeds off the tokens buffer PlanningParser parser = new PlanningParser(tokens); var domainContext = parser.domain();// begin parsing at init rule //Console.WriteLine(domainContext.ToStringTree(parser)); tr.Close(); //var domain = Domain.CreateInstance(domainContext); //ShowDomainInfo(domain); // Create a TextReader that reads from a file tr = new StreamReader(problemFileName); // create a CharStream that reads from standard input input = new AntlrInputStream(tr); // create a lexer that feeds off of input CharStream lexer = new PlanningLexer(input); // create a buffer of tokens pulled from the lexer tokens = new CommonTokenStream(lexer); // create a parser that feeds off the tokens buffer parser = new PlanningParser(tokens); var serverProblemContext = parser.serverProblem();// begin parsing at init rule //Console.WriteLine(serverProblemContext.ToStringTree(parser)); tr.Close(); //Console.ReadLine(); ServerProblem problem = ServerProblem.CreateInstance(domainContext, serverProblemContext); problem.ShowInfo(); Server server = new Server(port, listenBacklog, problem); server.Run(); Console.ReadLine(); }
/// <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> /// 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)); }
/// <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> /// [ 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)); }
/// <summary> /// [ REFS: 'result', DEREFS: none ] /// </summary> /// <returns></returns> private CUDDNode GetKbNode() { //OK CUDDNode result = CUDD.Constant(1); foreach (var pair in _predBooleanMap) { string name = pair.Key; int index = _predicateDict[name].PreviousCuddIndex; CUDDNode literal = pair.Value ? CUDD.Var(index) : CUDD.Function.Not(CUDD.Var(index)); result = CUDD.Function.And(result, literal); } 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); }
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); }
public void Update(Event e) { var literalList = GenerateLiteralList(CurrentCuddNode, e); UpdateByLiteralList(literalList); CUDD.Deref(CurrentCuddNode); CurrentCuddNode = GetKbNode(); if (Changed != null) { var tuple = new Tuple <IReadOnlyDictionary <string, bool>, Event>(_predBooleanMap, e); Changed(this, tuple); } }
/// <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); }
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 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> /// Use when the boolen constant is used as expression: a = true /// </summary> /// <param name="model"></param> /// <returns></returns> public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model) { string channelName = Arguments[0].ToString(); string countChannelVariable = Model.GetCountVarChannel(channelName); string topChannelVariable = Model.GetTopVarChannel(channelName); switch (MethodName) { case Constants.cfull: Expression isFull = Expression.EQ(new Variable(countChannelVariable), new IntConstant(model.mapChannelToSize[channelName])); ExpressionBDDEncoding isFullTemp = isFull.TranslateBoolExpToBDD(model); isFullTemp.ExpressionDDs = new List <CUDDNode>(isFullTemp.GuardDDs); isFullTemp.GuardDDs = new List <CUDDNode>() { CUDD.Constant(1) }; return(isFullTemp); case Constants.cempty: Expression isEmpty = Expression.EQ(new Variable(countChannelVariable), new IntConstant(0)); ExpressionBDDEncoding isEmptyTemp = isEmpty.TranslateBoolExpToBDD(model); isEmptyTemp.ExpressionDDs = new List <CUDDNode>(isEmptyTemp.GuardDDs); isEmptyTemp.GuardDDs = new List <CUDDNode>() { CUDD.Constant(1) }; return(isEmptyTemp); case Constants.ccount: return(new Variable(countChannelVariable).TranslateIntExpToBDD(model)); case Constants.csize: return(new IntConstant(model.mapChannelToSize[channelName]).TranslateIntExpToBDD(model)); case Constants.cpeek: //(top_a - count_a) % L Expression popedElementPosition = new PrimitiveApplication(PrimitiveApplication.MOD, Expression.MINUS(new Variable(topChannelVariable), new Variable(countChannelVariable)), new IntConstant(model.mapChannelToSize[channelName])); //a[top_a - count_a % L][i] return(new PrimitiveApplication(PrimitiveApplication.ARRAY, new Variable(channelName), Expression.TIMES( popedElementPosition, new IntConstant(Model.MAX_MESSAGE_LENGTH)) ).TranslateIntExpToBDD(model)); } throw new Exception("Static call can not be encoded in BDD"); }
/// <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); }
/// /// <summary> /// Use when the boolen constant is used as expression: a = true /// </summary> /// <param name="model"></param> /// <returns></returns> public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model) { ExpressionBDDEncoding result = new ExpressionBDDEncoding(); result.GuardDDs.Add(CUDD.Constant(1)); if (Value) { result.ExpressionDDs.Add(CUDD.Constant(1)); } else { result.ExpressionDDs.Add(CUDD.Constant(0)); } return(result); }