/// <summary> /// Return the intersection of model and negation of LTL /// Note that all of the state of model are the accepting state /// [ REFS: 'result', DEREFS:'automata1, automata2' ] /// </summary> /// <param name="system"></param> /// <param name="negationLTL"></param> /// <param name="model"></param> /// <returns></returns> public static AutomataBDD Intersection(AutomataBDD system, AutomataBDD negationLTL, Model model) { //AddIdleTransAtDeadlockStates(system, model); AutomataBDD result = new AutomataBDD(); //Set var result.variableIndex.AddRange(system.variableIndex); result.variableIndex.AddRange(negationLTL.variableIndex); //Set Init result.initExpression = Expression.AND(system.initExpression, negationLTL.initExpression); //Set Acceptance State result.acceptanceExpression = negationLTL.acceptanceExpression; //Set Transition //transition must happen at both automata1 + negation LTL result.transitionBDD = CUDD.Function.And(system.transitionBDD, negationLTL.transitionBDD); // CUDD.Deref(system.channelInTransitionBDD, system.channelOutTransitionBDD, negationLTL.channelInTransitionBDD, negationLTL.channelOutTransitionBDD); return(result); }
/// <summary> /// P.init: m0.init ^ clk = 0 /// </summary> private static void DeadlineSetInit(string clk, AutomataBDD m0, AutomataBDD result) { result.initExpression = Expression.AND(m0.initExpression, Expression.EQ( new Variable(clk), new IntConstant(0))); }
/// <summary> /// Create a new variable which know whether event is tick or not /// Later all event information is removed from the transition /// Return the justice based on that new varaible /// justice: event = tick, event != tick /// </summary> /// <param name="modelBDD"></param> /// <param name="model"></param> /// <returns></returns> public List <CUDDNode> GetJustices(AutomataBDD modelBDD, Model model) { model.AddLocalVar(EVENT_DUMMY, 0, 1); //Because later event variables are removed, add new variable to check whether it is tick or not Expression guard = Expression.OR( Expression.AND( TimeBehaviors.GetTickTransExpression(), new Assignment(EVENT_DUMMY, new IntConstant(1))), Expression.AND( TimeBehaviors.GetNotTickTransExpression(), new Assignment(EVENT_DUMMY, new IntConstant(0)))); modelBDD.transitionBDD = CUDD.Function.And(modelBDD.transitionBDD, guard.TranslateBoolExpToBDD(model).GuardDDs); //the cycle must contain tick transition (zeno) and other transitions (progress) List <CUDDNode> justices = new List <CUDDNode>(); guard = Expression.EQ(new Variable(EVENT_DUMMY), new IntConstant(0)); justices.Add(CUDD.Function.Or(guard.TranslateBoolExpToBDD(model).GuardDDs)); guard = Expression.EQ(new Variable(EVENT_DUMMY), new IntConstant(1)); justices.Add(CUDD.Function.Or(guard.TranslateBoolExpToBDD(model).GuardDDs)); return(justices); }
/// <summary> /// Tick transition if done is false, don't need to add unchanged condition of other local variables. /// They will be updated after the event becomes true /// use the tick transition of P1 if done is true /// </summary> /// <param name="P1"></param> /// <param name="model"></param> /// <param name="result"></param> private static void EventPrefixEncodeTick(Expression guardOfTick, AutomataBDD P1, Model model, AutomataBDD result) { Expression guard; List <CUDDNode> guardDD; //1. !done and guardOfTick and event = tick and !done' if (!(guardOfTick is BoolConstant && !(guardOfTick as BoolConstant).Value)) { guard = Expression.AND( Expression.EQ( new Variable(result.newLocalVarName), new IntConstant(0)), Expression.AND( guardOfTick, new PrimitiveApplication( PrimitiveApplication.AND, AutomataBDD. GetTerminateTransExpression (), new Assignment( result.newLocalVarName, new IntConstant(0))))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex); result.Ticks.AddRange(guardDD); } //2. done and p1.Tick and done' guard = Expression.AND(Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(1)), new Assignment(result.newLocalVarName, new IntConstant(0))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; guardDD = CUDD.Function.And(guardDD, P1.Ticks); result.Ticks.AddRange(guardDD); }
private static void WithinEncodeTransitionChannel(string clk, AutomataBDD m0, int t, Model model, AutomataBDD result) { Expression guard; List <CUDDNode> guardDD, transTemp; //1. (clk <= t) and m0.Trans/In/Out and [(event' = tau and clk' = clk) or (event' != tau and clk' = -1)] guard = Expression.AND(Expression.LE(new Variable(clk), new IntConstant(t)), Expression.OR(Expression.AND( AutomataBDD.GetTauTransExpression(), new Assignment(clk, new Variable(clk))), Expression.AND( AutomataBDD.GetNotTauTransExpression(), new Assignment(clk, new IntConstant(-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); }
public override void MakeDiscreteTransition(List <Expression> guards, List <Event> events, List <Expression> programBlocks, List <Process> processes, Model model, SymbolicLTS lts) { Expression allCondition = new BoolConstant(false); for (int i = 0; i < Processes.Length; i++) { guards.Add(Expression.AND(Expression.NOT(allCondition), Conditions[i])); events.Add(new Event(Constants.TAU)); programBlocks.Add(null); processes.Add(Processes[i]); if (i == 0) { allCondition = Conditions[0]; } else { allCondition = Expression.OR(allCondition, Conditions[i]); } } guards.Add(Expression.NOT(allCondition)); events.Add(new Event(Constants.TAU)); programBlocks.Add(null); processes.Add(new Skip()); }
public override void MakeDiscreteTransition(List <Expression> guards, List <Event> events, List <Expression> programBlocks, List <Process> processes, Model model, SymbolicLTS lts) { lts.AddParaInChannelAsLocalVar(ExpressionList); if (model.mapChannelToSize.ContainsKey(ChannelName)) { List <Expression> guardUpdateChannel = AutomataBDD.GetGuardUpdateOfChannelInput(this.ChannelName, new BoolConstant(true), new List <Expression>(ExpressionList), AssignmentExpr, model); guardUpdateChannel[0] = Expression.AND(guardUpdateChannel[0], this.GuardExpression); Event channelInput = new BDDEncoder.EventChannelInfo(this.ChannelName, 0, BDDEncoder.EventChannelInfo.EventType.ASYNC_CHANNEL_INPUT); guards.Add(guardUpdateChannel[0]); events.Add(channelInput); programBlocks.Add(guardUpdateChannel[1]); processes.Add(Process); } else { Event channelInput = new BDDEncoder.EventChannelInfo(this.ChannelName, 0, BDDEncoder.EventChannelInfo.EventType.SYNC_CHANNEL_INPUT); channelInput.ExpressionList = this.ExpressionList; guards.Add(null); events.Add(channelInput); programBlocks.Add(null); processes.Add(Process); } }
/// <summary> /// /// </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> EncodeSyncChannelInTransition(BDDEncoder encoder, string processVariableName, List <int> localVars) { Expression guard = Expression.EQ( new Variable(processVariableName), new IntConstant(encoder.stateIndexOfCurrentProcess[this.FromState.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))); guard = Expression.AND(guard, new Assignment(processVariableName, new IntConstant(encoder.stateIndexOfCurrentProcess[this.ToState.ID]))); //channel input has not program block for (int i = 0; i < parameters.Count; i++) { if (parameters[i] is IntConstant) { //eventParameterVariables[i]' = exps[i] guard = Expression.AND(guard, new Assignment(encoder.model.eventParameterVariables[i], parameters[i])); } else { //eventParameterVariables[i]' = exps[i]' guard = Expression.AND(guard, Expression.EQ(new VariablePrime(encoder.model.eventParameterVariables[i]), new VariablePrime(parameters[i].expressionID))); } } List <CUDDNode> transitions = guard.TranslateBoolExpToBDD(encoder.model).GuardDDs; return(encoder.model.AddVarUnchangedConstraint(transitions, localVars)); }
/// <summary> /// P.init : ∧{i = 1..n}Pi.init and temp = -1 /// </summary> private static void InternalChoiceSetInit(List <AutomataBDD> choices, AutomataBDD result) { result.initExpression = Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(-1)); for (int i = 0; i < choices.Count; i++) { result.initExpression = Expression.AND(result.initExpression, choices[i].initExpression); } }
private Expression <Func <MessageTemplate, bool> > Filtering(string Cause) { Expression <Func <MessageTemplate, bool> > expression = messagetemplate => messagetemplate.Cause == Cause; expression = expression.AND(messagetemplate => messagetemplate.TypeOfMessages.Type.ToLower() == "email"); return(expression); }
/// <summary> /// ∧ Pi.init /// </summary> private static void InterleaveSetInit(List <AutomataBDD> processes, AutomataBDD result) { result.initExpression = processes[0].initExpression; for (int i = 1; i < processes.Count; i++) { result.initExpression = Expression.AND(result.initExpression, processes[i].initExpression); } }
private List <CUDDNode> EncodeTransitionBA(BA.Transition transition, Dictionary <string, Expression> declarationDatabase, string processVariableName) { // Expression transitionDD = Expression.EQ(new Variable(processVariableName), new IntConstant(this.stateIndexOfCurrentProcess[transition.FromState])); transitionDD = Expression.AND(transitionDD, new Assignment(processVariableName, new IntConstant(this.stateIndexOfCurrentProcess[transition.ToState]))); List <CUDDNode> transBDD = new List <CUDDNode> { CUDD.Constant(1) }; foreach (Proposition label in transition.labels) { List <CUDDNode> temp; if (!label.IsSigmal) { //label is a propostion if (declarationDatabase != null && declarationDatabase.ContainsKey(label.Label)) { Expression proposition = (label.Negated) ? Expression.NOT(declarationDatabase[label.Label]) : declarationDatabase[label.Label]; temp = EncodeProposition(transitionDD, proposition); } else { //label is an event //Because we mark event with update with # at the begininig //At this step, we don't know whether the event has update, therefore we check both state Expression eventExpression = Expression.OR( GetEventExpression(label.Label), GetEventExpression(Model.NAME_SEPERATOR + label.Label)); if (label.Negated) { eventExpression = Expression.NOT(eventExpression); } transitionDD = Expression.AND(transitionDD, eventExpression); temp = transitionDD.TranslateBoolExpToBDD(model).GuardDDs; } } else { temp = transitionDD.TranslateBoolExpToBDD(model).GuardDDs; } transBDD = CUDD.Function.And(transBDD, temp); } // return(transBDD); }
private static void TimeInterruptEncodeTransitionChannel(string clk, AutomataBDD m0, AutomataBDD m1, int t, Model model, AutomataBDD result) { Expression guard; List <CUDDNode> guardDD, transTemp; //1. clk <= t and m0.Trans/In/Out and [(event' = termination & clk' = -1) or (event' != termination & clk' = clk)] guard = Expression.AND(Expression.LE(new Variable(clk), new IntConstant(t)), Expression.OR(Expression.AND( AutomataBDD.GetTerminateTransExpression(), new Assignment(clk, new IntConstant(-1))), Expression.AND( AutomataBDD.GetNotTerminateTransExpression(), new Assignment(clk, new Variable(clk))))); 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. clk = t and event' = tau and clk' = t + 1 and m1.Init guard = Expression.AND(Expression.EQ(new Variable(clk), new IntConstant(t)), Expression.AND(AutomataBDD.GetTauTransExpression(), new Assignment(clk, new IntConstant(t + 1)))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; guardDD = CUDD.Function.And(m1.GetInitInColumn(model), CUDD.Function.Or(guardDD)); guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex); result.transitionBDD.AddRange(guardDD); //3. clk = t + 1 and m1.Trans and clk' = t + 1 guard = Expression.AND(Expression.EQ(new Variable(clk), new IntConstant(t + 1)), new Assignment(clk, new IntConstant(t + 1))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; // CUDD.Ref(guardDD); transTemp = CUDD.Function.And(m1.transitionBDD, guardDD); result.transitionBDD.AddRange(guardDD); // CUDD.Ref(guardDD); transTemp = CUDD.Function.And(m1.channelInTransitionBDD, guardDD); result.channelInTransitionBDD.AddRange(guardDD); // //CUDD.Ref(guardDD); transTemp = CUDD.Function.And(m1.channelOutTransitionBDD, guardDD); result.channelOutTransitionBDD.AddRange(guardDD); }
/// <summary> /// ∧ Pi.init /// </summary> private static void ParallelSetInit(List <AutomataBDD> processes, AutomataBDD result) { result.initExpression = processes[0].initExpression; //This loop and the implementation of AND of a list make sure that processes having the same event can run simultaneously for (int i = 1; i < processes.Count; i++) { result.initExpression = Expression.AND(result.initExpression, processes[i].initExpression); } }
/// <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)); }
private static void SkipEncodeTick(Model model, AutomataBDD result) { //2. state = 0 & event' = tick & state = 0 //3. state = 1 & event' = tick & state = 1 Expression guard = Expression.AND(GetTickTransExpression(), new Assignment(result.newLocalVarName, new Variable(result.newLocalVarName))); List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex); result.Ticks.AddRange(guardDD); }
/// <summary> /// choice = i and Tick.i and choice' = i /// </summary> /// <param name="choices"></param> /// <param name="model"></param> /// <param name="result"></param> private static void ResolvedChoiceEncodeTick(List <AutomataBDD> choices, Model model, AutomataBDD result) { //2. choice = i and Tick.i and choice' = i for (int i = 0; i < choices.Count; i++) { Expression guard = Expression.AND(Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(i)), new Assignment(result.newLocalVarName, new IntConstant(i))); List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; guardDD = CUDD.Function.And(guardDD, choices[i].Ticks); result.Ticks.AddRange(guardDD); } }
/// <summary> /// (!temp ∧ event ' = terminate ∧ temp ') /// </summary> private static void SkipEncodeTransition(Model model, AutomataBDD result) { Expression guard = Expression.AND( Expression.AND( new PrimitiveApplication( PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(0)), GetTerminateTransExpression()), new Assignment(result.newLocalVarName, new IntConstant(1))); result.transitionBDD.AddRange(model.AddVarUnchangedConstraint(guard.TranslateBoolExpToBDD(model).GuardDDs, model.GlobalVarIndex)); }
private static void WaitEncodeTransitionChannel(string state, int t, Model model, AutomataBDD result) { //1. state = t and event' = terminate and state' = t + 1 Expression guard; List <CUDDNode> guardDD; guard = Expression.AND(Expression.EQ(new Variable(state), new IntConstant(t)), Expression.AND(AutomataBDD.GetTerminateTransExpression(), new Assignment(state, new IntConstant(t + 1)))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex); result.transitionBDD.AddRange(guardDD); }
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); }
private Expression <Func <Device, bool> > GetFilterExpression(FilteringModel filter) { FillFiltering(filter); Expression <Func <Device, bool> > expression = (Device device) => device.IsDeleted == false; foreach (var prop in filter.GetType().GetProperties()) { if (prop.GetValue(filter) != null) { expression = expression.AND(_filteringRules.GetValueOrDefault(prop.Name.ToLower()) ?? expression); } } return(expression); }
/// <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> /// (!temp ∧ guard∧ ∧ update ∧ temp ' ∧ P1.init) /// </summary> private static void EventPrefixTransitition(Expression guardOfTrans, Expression updateOfTrans, AutomataBDD P1, Model model, AutomataBDD result) { Expression guard = Expression.AND(Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(0)), guardOfTrans); Expression update = new Sequence(updateOfTrans, new Assignment(result.newLocalVarName, new IntConstant(1))); List <CUDDNode> transition = model.EncodeTransition(guard, update, new List <int>()); transition = CUDD.Function.And(transition, P1.GetInitInColumn(model)); transition = model.AddVarUnchangedConstraint(transition, model.GlobalVarIndex); result.transitionBDD.AddRange(transition); }
/// <summary> /// (temp ∧ P1.Trans/In/Out ∧ temp') /// [ REFS: '', DEREFS: 'P1'] /// </summary> private static void CopyTransitionAfterEventChannel(AutomataBDD P1, Model model, AutomataBDD result) { Expression guard = Expression.AND(Expression.EQ(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 static void WithinEncodeTick(string clk, AutomataBDD m0, int t, Model model, AutomataBDD result) { Expression guard; List <CUDDNode> guardDD; //1. m0.Tick and [(clk >= 0 and clk < t and clk' = clk + 1) or (clk = -1 and clk' = -1)] guard = Expression.OR(Expression.AND(Expression.AND( Expression.GE(new Variable(clk), new IntConstant(0)), Expression.LT(new Variable(clk), new IntConstant(t))), new Assignment(clk, Expression.PLUS(new Variable(clk), new IntConstant(1)))), Expression.AND( Expression.EQ(new Variable(clk), new IntConstant(-1)), new Assignment(clk, new IntConstant(-1)))); guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; guardDD = CUDD.Function.And(m0.Ticks, guardDD); result.Ticks.AddRange(guardDD); }
/// <summary> /// Note that this is different from EventPrefixEncodeTick because it need to make sure local variable unchanged /// </summary> /// <param name="P1"></param> /// <param name="model"></param> /// <param name="result"></param> private static void GuardEncodeTick(Expression guard1, AutomataBDD P1, Model model, AutomataBDD result) { //allow time evolution when the guard is not resolved //temp = 0 and P1.init and not (b and P1.init and event = tau and P1.transition) and event = tick and temp = 0 Expression exp; List <CUDDNode> expDD; exp = Expression.AND(guard1, Expression.AND(P1.initExpression, AutomataBDD.GetTauTransExpression())); expDD = exp.TranslateBoolExpToBDD(model).GuardDDs; CUDD.Ref(P1.transitionBDD); expDD = CUDD.Function.And(expDD, P1.transitionBDD); //find state where b is true and tau is enable expDD = CUDD.Abstract.ThereExists(expDD, model.AllColVars); CUDDNode tauIsNotEnabled = CUDD.Function.Not(expDD); exp = Expression.AND( Expression.AND( new PrimitiveApplication( PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(0)), P1.initExpression), GetTickTransExpression()); expDD = exp.TranslateBoolExpToBDD(model).GuardDDs; expDD = CUDD.Function.And(expDD, tauIsNotEnabled); expDD = model.AddVarUnchangedConstraint(expDD, model.GlobalVarIndex); expDD = model.AddVarUnchangedConstraint(expDD, result.variableIndex); result.Ticks.AddRange(expDD); //temp & P1.tick & temp' exp = Expression.AND( new Variable(result.newLocalVarName), new Assignment(result.newLocalVarName, new IntConstant(1))); expDD = exp.TranslateBoolExpToBDD(model).GuardDDs; expDD = CUDD.Function.And(P1.Ticks, expDD); result.Ticks.AddRange(expDD); }
/// <summary> /// [ REFS: '', DEREFS: 'P1'] /// </summary> /// <param name="b"></param> /// <param name="P1"></param> /// <param name="model"></param> /// <param name="result"></param> private static void GuardEncodeTransition(Expression b, AutomataBDD P1, Model model, AutomataBDD result) { //(P1.Trans/In/Out and [(b and !temp and temp') or (temp and temp')] Expression guard = Expression.OR(Expression.AND(b, Expression.AND(Expression.NOT(new Variable(result.newLocalVarName)), new Assignment(result.newLocalVarName, new IntConstant(1)))), Expression.AND( new Variable(result.newLocalVarName), 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)); result.channelOutTransitionBDD.AddRange(CUDD.Function.And(guardDD, P1.channelOutTransitionBDD)); }
public void SetLocalVarsAndInit(BDDEncoder encoder, AutomataBDD processBDD, string stateVar) { processBDD.variableIndex.Add(encoder.model.GetVarIndex(stateVar)); // foreach (string parameter in this.Parameters) { processBDD.variableIndex.Add(encoder.model.GetVarIndex(parameter)); } //Set initial expression processBDD.initExpression = Expression.EQ(new Variable(stateVar), new IntConstant(encoder.stateIndexOfCurrentProcess[this.InitialState.ID])); for (int i = 0; i < this.Arguments.Count; i++) { processBDD.initExpression = Expression.AND(processBDD.initExpression, Expression.EQ(new Variable(this.Parameters[i]), this.Arguments[i])); } }
/// <summary> /// [ REFS: '', DEREFS: ''] /// </summary> /// <param name="choices"></param> /// <param name="model"></param> /// <param name="result"></param> private static void ExternalChoiceEncodeTick(List <AutomataBDD> choices, Model model, AutomataBDD result) { //if all components of the choice may evolve for a particular length of time, then so may the choice //1. choice = -1 and all Tick.i and choice' = -1 Expression guard = Expression.AND(Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(-1)), new Assignment(result.newLocalVarName, new IntConstant(-1))); List <CUDDNode> guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs; for (int i = 0; i < choices.Count; i++) { CUDD.Ref(choices[i].Ticks); guardDD = CUDD.Function.And(guardDD, choices[i].Ticks); } result.Ticks.AddRange(guardDD); //2. choice = i and Tick.i and choice' = i ResolvedChoiceEncodeTick(choices, model, result); }
/// <summary> /// (temp = -1 and tau and temp' in [0, n-1]) /// (temp = i ∧ Pi.transition ∧ temp' = i) /// </summary> /// <param name="choices"></param> /// <param name="model"></param> /// <param name="result"></param> private static void InternalChoiceEncodeTransition(List <AutomataBDD> choices, Model model, AutomataBDD result) { //Tau transition resolves the choice Expression guard = Expression.AND( Expression.AND( new PrimitiveApplication( PrimitiveApplication.AND, new PrimitiveApplication( PrimitiveApplication.EQUAL, new Variable(result.newLocalVarName), new IntConstant(-1)), GetTauTransExpression()), new PrimitiveApplication( PrimitiveApplication.GREATER_EQUAL, new VariablePrime( result.newLocalVarName), new IntConstant(0))), Expression.LE( new VariablePrime(result.newLocalVarName), new IntConstant(choices.Count - 1))); List <CUDDNode> transition = guard.TranslateBoolExpToBDD(model).GuardDDs; model.AddVarUnchangedConstraint(transition, model.GlobalVarIndex); result.transitionBDD.AddRange(transition); //Copy transitions from other processes after the choice is resolved for (int i = 0; i < choices.Count; i++) { //(temp = i ∧ Pi.transition ∧ temp' = i) guard = Expression.AND(Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(i)), new Assignment(result.newLocalVarName, new IntConstant(i))); transition = guard.TranslateBoolExpToBDD(model).GuardDDs; // CUDD.Ref(transition); result.transitionBDD.AddRange(CUDD.Function.And(transition, choices[i].transitionBDD)); CUDD.Ref(transition); result.channelInTransitionBDD.AddRange(CUDD.Function.And(transition, choices[i].channelInTransitionBDD)); result.channelOutTransitionBDD.AddRange(CUDD.Function.And(transition, choices[i].channelOutTransitionBDD)); } }