/// <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));
}
}
