public override AutomataBDD EncodeComposition(BDDEncoder encoder) { AutomataBDD processAutomataBDD = this.Process.Encode(encoder); // return(AutomataBDD.Guard(this.Condition, processAutomataBDD, encoder.model)); }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { AutomataBDD process1BDD = this.FirstProcess.Encode(encoder); AutomataBDD process2BDD = this.SecondProcess.Encode(encoder); return(AutomataBDD.Sequence(process1BDD, process2BDD, encoder.model)); }
private static List <CUDDNode> IsExistPath(Expression goal1, BDDEncoder encoder, List <CUDDNode> path, CUDDNode initDD, AutomataBDD systemBDD, List <string> letters, ref bool reach1) { CUDDNode goal1DD; goal1DD = CUDD.Function.Or(goal1.TranslateBoolExpToBDD(encoder.model).GuardDDs); path = new List <CUDDNode>(); reach1 = encoder.model.PathForward(initDD, goal1DD, new List <List <CUDDNode> >() { systemBDD.transitionBDD }, path, false); logger.Info("Finish run. Result is " + reach1); #if DEBUG StringBuilder builder = new StringBuilder(); PrintResult(builder, path, encoder, letters); logger.Info(builder.ToString()); #endif return(path); }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { AutomataBDD process1BDD = this.FirstProcess.Encode(encoder); Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU)); return(AutomataBDD.EventPrefix(this.ConditionalExpression, eventUpdateExpression, process1BDD, encoder.model)); }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { AutomataBDD processAutomataBDD = this.Process.Encode(encoder); Expression eventUpdateExpression = encoder.GetEventExpression(this.Event); // return(AutomataBDD.EventPrefix(new BoolConstant(true), eventUpdateExpression, processAutomataBDD, encoder.model)); }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { AutomataBDD process1BDD = this.FirstProcess.Encode(encoder); AutomataBDD process2BDD = this.SecondProcess.Encode(encoder); // AutomataBDD ifBDD = AutomataBDD.Guard(this.ConditionalExpression, process1BDD, encoder.model); AutomataBDD elseBDD = AutomataBDD.Guard(Expression.NOT(this.ConditionalExpression), process2BDD, encoder.model); // return AutomataBDD.Choice(new List<AutomataBDD> { ifBDD, elseBDD }, encoder.model); }
/// <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(); }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { this.AddParameterVariable(encoder.model); AutomataBDD result = this.Def.Process.Encode(encoder); for (int i = 0; i < this.Args.Length; i++) { string para = this.Def.Parameters[i]; result.initExpression = Expression.AND(result.initExpression, Expression.EQ(new Variable(para), this.Args[i])); } return(result); }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { AutomataBDD process1BDD = this.FirstProcess.Encode(encoder); AutomataBDD process2BDD = this.SecondProcess.Encode(encoder); Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU)); // AutomataBDD ifBDD = AutomataBDD.EventPrefix(this.ConditionalExpression, eventUpdateExpression, process1BDD, encoder.model); AutomataBDD elseBDD = AutomataBDD.EventPrefix(Expression.NOT(this.ConditionalExpression), eventUpdateExpression, process2BDD, encoder.model); // return(AutomataBDD.Choice(new List <AutomataBDD> { ifBDD, elseBDD }, encoder.model)); }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { AutomataBDD processAutomataBDD = this.Process.Encode(encoder); if (encoder.model.mapChannelToSize.ContainsKey(this.ChannelName)) { int channelEventIndex = encoder.GetChannelIndex(this.ChannelName, BDDEncoder.EventChannelInfo.EventType.ASYNC_CHANNEL_OUTPUT); return(AutomataBDD.ChannelOutputPrefixing(this.ChannelName, channelEventIndex, new List <Expression>(this.ExpressionList), AssignmentExpr, processAutomataBDD, encoder.model)); } else { List <Expression> expressionList = (this.ExpressionList != null) ? new List <Expression>(this.ExpressionList) : new List <Expression>(); int channelEventIndex = encoder.GetEventIndex(this.ChannelName, expressionList.Count); return(AutomataBDD.SyncChannelOutputPrefixing(channelEventIndex, expressionList, processAutomataBDD, encoder.model)); } }
/// <summary> /// Could not support GenerateSymbolicLTS because if tau transition happen, choice is not resolve. Diffcult to track current state /// </summary> /// <param name="encoder"></param> /// <returns></returns> public override AutomataBDD EncodeComposition(BDDEncoder encoder) { List <Process> newnewListProcess = Processes; if (Processes == null) { newnewListProcess = IndexedProcessDefinition.GetIndexedProcesses(new Dictionary <string, Expression>()); } List <AutomataBDD> processAutomataBDDs = new List <AutomataBDD>(); foreach (Process process in newnewListProcess) { processAutomataBDDs.Add(process.Encode(encoder)); } // return(AutomataBDD.ExternalChoice(processAutomataBDDs, encoder.model)); }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { List <Process> newnewListProcess = Processes; if (Processes == null) { newnewListProcess = IndexedProcessDefinition.GetIndexedProcesses(new Dictionary <string, Expression>()); } List <AutomataBDD> processBDDs = new List <AutomataBDD>(); List <CUDDNode> alphabets = new List <CUDDNode>(); foreach (Process process in newnewListProcess) { processBDDs.Add(process.Encode(encoder)); alphabets.Add(encoder.GetAlphabetInBDD(process.GetAlphabets(new Dictionary <string, string>()))); } // return(AutomataBDD.Parallel(processBDDs, alphabets, encoder.model)); }
/// <summary> /// P = [] {[guardi] tau -> Pi} /// </summary> /// <param name="encoder"></param> /// <returns></returns> public override AutomataBDD EncodeComposition(BDDEncoder encoder) { List <AutomataBDD> processAutomataBDDs = new List <AutomataBDD>(); Expression previousguardsOR = null; Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU)); for (int i = 0; i < Processes.Length; i++) { Expression guard = null; if (i == 0) { guard = Conditions[i]; } else //if (previousguardsOR != null) { guard = Expression.AND(guard, Expression.NOT(previousguardsOR)); } AutomataBDD processAutomataBDd = Processes[i].Encode(encoder); AutomataBDD guardProcessAutomataBDD = AutomataBDD.EventPrefix(guard, eventUpdateExpression, processAutomataBDd, encoder.model); processAutomataBDDs.Add(guardProcessAutomataBDD); previousguardsOR = Expression.OR(previousguardsOR, guard); } //if all conditions are not satisfied, it becomes Skip Expression allConditions = new BoolConstant(true); foreach (var condition in Conditions) { allConditions = Expression.OR(allConditions, condition); } processAutomataBDDs.Add(AutomataBDD.EventPrefix(Expression.NOT(allConditions), eventUpdateExpression, new Skip().Encode(encoder), encoder.model)); return(AutomataBDD.Choice(processAutomataBDDs, encoder.model)); }
private static void PrintResult(StringBuilder sb, List <CUDDNode> path, BDDEncoder encoder, List <string> letters) { foreach (var cuddNode in path) { CUDD.Print.PrintMinterm(cuddNode); // CUDD.Print.PrintBDDTree(path); encoder.model.PrintAllVariableValue(cuddNode); letters.ForEach(l => { int valueOfX = encoder.model.GetRowVarValue(cuddNode, l); sb.AppendLine(l + " = " + valueOfX); } ); int v = encoder.model.GetRowVarValue(cuddNode, "#state#0"); sb.AppendLine("#state#0" + " = " + v); int v1 = encoder.model.GetRowVarValue(cuddNode, "#event"); sb.AppendLine("#event" + " = " + v1); } }
/// <summary> /// Encode sync channel out transition as event!a.b.c /// </summary> /// <param name="encoder"></param> /// <param name="processVariableName"></param> /// <param name="localVars">Local of the current SymbolicLTS is unchanged</param> /// <returns></returns> public List <CUDDNode> EncodeSyncChannelOutTransition(BDDEncoder encoder, string processVariableName, List <int> localVars) { Expression guard = Expression.EQ(new Variable(processVariableName), new IntConstant(encoder.stateIndexOfCurrentProcess[this.FromPNPlace.ID])); guard = Expression.CombineGuard(guard, GuardCondition); List <Expression> parameters = encoder.GetParaExpInEvent(this.Event); int channelEventIndex = encoder.GetEventIndex(this.Event.BaseName, parameters.Count); guard = Expression.AND(guard, new Assignment(Model.EVENT_NAME, new IntConstant(channelEventIndex))); for (int i = 0; i < parameters.Count; i++) { //assign event parameter to the values in the event expression guard = Expression.AND(guard, new Assignment(encoder.model.eventParameterVariables[i], parameters[i])); } guard = Expression.AND(guard, new Assignment(processVariableName, new IntConstant(encoder.stateIndexOfCurrentProcess[this.ToPNPlace.ID]))); List <CUDDNode> transitions = guard.TranslateBoolExpToBDD(encoder.model).GuardDDs; return(encoder.model.AddVarUnchangedConstraint(transitions, localVars)); }
/// <summary> /// Encode transition, if it is synchronized, then we don't add constraint of unchanged global variables /// Parallel process only synchorinize event which does not change global variable or each transition changes same to global variables /// 3 kinds of transition: normal event, async channel input and async channel output /// </summary> /// <param name="encoder"></param> /// <param name="processVariableName"></param> /// <param name="localVars">Local of the current SymbolicLTS is unchanged</param> /// <param name="isSynchronized"></param> /// <returns></returns> public List <CUDDNode> Encode(BDDEncoder encoder, string processVariableName, List <int> localVars, bool isSynchronized) { Expression guardExpressions = Expression.EQ(new Variable(processVariableName), new IntConstant(encoder.stateIndexOfCurrentProcess[this.FromPNPlace.ID])); guardExpressions = Expression.CombineGuard(guardExpressions, GuardCondition); Expression eventUpdateExpression; if (this.Event is BDDEncoder.EventChannelInfo) { int channelIndex = encoder.GetChannelIndex(this.Event.BaseName, (this.Event as BDDEncoder.EventChannelInfo).type); eventUpdateExpression = new Assignment(Model.EVENT_NAME, new IntConstant(channelIndex)); } else { eventUpdateExpression = encoder.GetEventExpression(this.Event); } Assignment PNPlaceUpdateExpression = new Assignment(processVariableName, new IntConstant(encoder.stateIndexOfCurrentProcess[this.ToPNPlace.ID])); Sequence updateExpressions = new Sequence(eventUpdateExpression, PNPlaceUpdateExpression); if (this.ProgramBlock != null) { updateExpressions = new Sequence(updateExpressions, this.ProgramBlock); } List <int> unchangedVars = new List <int>(localVars); if (!isSynchronized) { unchangedVars.AddRange(encoder.model.GlobalVarIndex); } return(encoder.model.EncodeTransition(guardExpressions, updateExpressions, unchangedVars)); }
public void Test1Test() { var sb = new StringBuilder(); string varX = "x"; string varY = "y"; //Set number of action names, 2 for a, b Model.NUMBER_OF_EVENT = 3; Model.MAX_NUMBER_EVENT_PARAMETERS = 0; BDDEncoder encoder = new BDDEncoder(); encoder.model.AddGlobalVar(varX, 0, 10); encoder.model.AddGlobalVar(varY, 0, 10); SymbolicLTS lts = new SymbolicLTS(); State state1 = lts.AddState(); State state2 = lts.AddState(); State state3 = lts.AddState(); State state4 = lts.AddState(); lts.InitialState = state1; var primitiveApplication1 = new Assignment(varX, new PrimitiveApplication(PrimitiveApplication.PLUS, new Variable(varX), new IntConstant(1))); var primitiveApplication2 = new Assignment(varY, new PrimitiveApplication(PrimitiveApplication.PLUS, new Variable(varY), new IntConstant(4))); /* * * for (int i = 0; i < exps.Count; i++) * { * //Update eventParameterVariables[i] = exps[i] * //Don't need to update exps because later after synchronization, not updated variable keeps the same value * update = new Sequence(update, new Assignment(model.eventParameterVariables[i], exps[i])); * } */ var primitiveApplication = new Sequence(primitiveApplication1, primitiveApplication2); /*PrimitiveApplication.CombineProgramBlock( * primitiveApplication1, * primitiveApplication2);*/ logger.Info(primitiveApplication); Transition trans1 = new Transition(new Event("a"), null, primitiveApplication, state1, state2); Expression assignment = new Assignment(varX, new PrimitiveApplication(PrimitiveApplication.PLUS, new Variable(varX), new IntConstant(2))); logger.Info("Assignments: " + assignment); var secAssignment = new Assignment(varY, new PrimitiveApplication(PrimitiveApplication.PLUS, new Variable(varY), new WildConstant())); Transition trans2 = new Transition(new Event("b"), null, primitiveApplication, state2, state3); Transition trans3 = new Transition(new Event("c"), null, primitiveApplication, state3, state4); lts.AddTransition(trans1); lts.AddTransition(trans2); lts.AddTransition(trans3); AutomataBDD systemBDD = lts.Encode(encoder); //Variable x is initialised to 1 systemBDD.initExpression = new PrimitiveApplication(PrimitiveApplication.AND, systemBDD.initExpression, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(varX), new IntConstant(1))); systemBDD.initExpression = new PrimitiveApplication(PrimitiveApplication.AND, systemBDD.initExpression, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(varY), new IntConstant(1))); CUDDNode initDD = CUDD.Function.Or(systemBDD.initExpression.TranslateBoolExpToBDD(encoder.model).GuardDDs); logger.Info("init: " + systemBDD.initExpression); var u = 1; for (; u < 2; u++) { logger.Info($"U is {u}"); //Define 2 goals Expression goal1 = new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(varX), new IntConstant(3)); goal1 = new PrimitiveApplication(PrimitiveApplication.AND, goal1, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(varY), new IntConstant(9))); //Encode 2 goals to BDD CUDDNode goal1DD = CUDD.Function.Or(goal1.TranslateBoolExpToBDD(encoder.model).GuardDDs); logger.Info("Goal: " + goal1); List <CUDDNode> path = new List <CUDDNode>(); bool reach1 = encoder.model.PathForward(initDD, goal1DD, new List <List <CUDDNode> >() { systemBDD.transitionBDD }, path, true); if (reach1) { sb.AppendLine("goal1 is reachable"); foreach (var cuddNode in path) { encoder.model.PrintAllVariableValue(cuddNode); logger.Info("after"); CUDD.Print.PrintMinterm(cuddNode); // CUDD.Print.PrintBDDTree(path); int valueOfX = encoder.model.GetRowVarValue(cuddNode, varX); sb.AppendLine(varX + " = " + valueOfX); int valueOfY = encoder.model.GetRowVarValue(cuddNode, varY); sb.AppendLine(varY + " = " + valueOfY); } } else { sb.AppendLine("goal1 is unreachable"); } path.Clear(); } /* * bool reach2 = encoder.model.PathForward(initDD, goal2DD, new List<List<CUDDNode>>() { systemBDD.transitionBDD }, path, true); * if (reach2) * { * sb.AppendLine("goal2 is reachable"); * foreach (var cuddNode in path) * { * int valueOfX = encoder.model.GetRowVarValue(cuddNode, varX); * sb.AppendLine(varX + " = " + valueOfX); * } * } * else * { * sb.AppendLine("goal2 is unreachable"); * } */ logger.Info(sb); encoder.model.Close(); }
public bool IsValidPath(GeneNode automata, List <GeneLink> booleanNetwok, Dictionary <string, List <int> > availableFunctions = null) { lock (locker) { var tempAutomata = automata; // new GeneNode() //{ // NodeName = "Start", // CurrentCondition = new Condition(), // Transitions = new List<GeneTransition>() // { // new GeneTransition() // { // Node = automata // } // } //}; var letters = new List <string>(); int z = 0; var depth = tempAutomata.NodeLength; tempAutomata.GetAllConditionLetters(letters); letters = letters.SelectMany(l => Enumerable.Range(0, depth).ToList().Select(n => Formater.FormatParameter(l, n))).ToList(); logger.Info(tempAutomata.NodeLength + 1); Model.NUMBER_OF_EVENT = tempAutomata.NodeLength + 2; Model.MAX_NUMBER_EVENT_PARAMETERS = 0; BDDEncoder encoder = new BDDEncoder(); letters.Distinct().ToList().ForEach(l => encoder.model.AddLocalVar(l, 0, 1)); logger.Info(string.Join(",", letters)); SymbolicLTS lts = new SymbolicLTS(); List <State> states = new List <State>(); var state0 = lts.AddState(); states.Add(state0); lts.InitialState = states[0]; var state1 = lts.AddState(); states.Add(state1); //var goal2 = CreateExpressionBasedOnAutomata(tempAutomata); var dictValues = BDDLogicHelper.CreateDictBasedOnAutomata(tempAutomata); Expression seq = null; /*CreateExpressionsFromBooleanNetwork(booleanNetwok, * availableFunctions, depth, Mode.Assignment, dictValues);*/ if (dictValues.Any()) { dictValues.ToList().ForEach(f => { Expression curr = new Assignment(f.Key, new BoolConstant(f.Value)); seq = seq == null ? curr : new Sequence(seq, curr); }); } //seq = new Sequence(seq, goal2); // // logger.Info("Assignments: " + seq); var trans1 = new Transition(new Event("a0"), null, seq, states[0], states[1]); lts.Transitions.Add(trans1); logger.Info(lts); AutomataBDD systemBDD = lts.Encode(encoder); systemBDD.PrintTransition(); CUDDNode initDD = CUDD.Function.Or( systemBDD.initExpression.TranslateBoolExpToBDD(encoder.model).GuardDDs); bool reach1 = true; var path = new List <CUDDNode>(); var geneTransition = tempAutomata; InitInitialState(geneTransition, systemBDD, letters); var goal = SetGoalsBasedOnAutomata(geneTransition); var goal3 = CreateExpressionsFromBooleanNetwork(booleanNetwok, availableFunctions, depth, Mode.Equal); goal = new PrimitiveApplication(PrimitiveApplication.AND, goal, goal3); logger.Info("Goal: " + goal); path = IsExistPath(goal, encoder, path, initDD, systemBDD, letters, ref reach1); path.Clear(); encoder.model.Close(); return(reach1); } }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { return(AutomataBDD.Stop()); }
public override AutomataBDD EncodeComposition(BDDEncoder encoder) { return(AutomataBDD.Skip(encoder.model)); }