/// <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));
}
/// <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));
}
/// <summary>
/// [ REFS: traces, DEREFS: ]
/// </summary>
/// <param name="automataBDD"></param>
/// <param name="model"></param>
public void MCForTA(AutomataBDD automataBDD, Model model)
{
//Clear the old data
this.traces.Clear();
List<CUDDNode> allTransitions = new List<CUDDNode>(automataBDD.transitionBDD);
CUDDNode deadlockGoadDD = GetDeadlockDD(allTransitions, model);
ExpressionBDDEncoding initEncoding = automataBDD.initExpression.TranslateBoolExpToBDD(model);
if (initEncoding.GuardDDs.Count == 0)
{
this.VerificationOutput.VerificationResult = VerificationResultType.VALID;
}
else
{
CUDD.Ref(automataBDD.transitionBDD);
List<CUDDNode> discreteTrans = CUDD.Function.And(automataBDD.transitionBDD,
CUDD.Function.Not(AutomataBDD.GetTerminationTransEncoding(model)));
discreteTrans = CUDD.Abstract.ThereExists(discreteTrans, model.GetAllEventVars());
CUDD.Ref(automataBDD.Ticks);
List<CUDDNode> tickTrans = CUDD.Function.And(automataBDD.Ticks,
CUDD.Function.Not(AutomataBDD.GetTerminationTransEncoding(model)));
tickTrans = CUDD.Abstract.ThereExists(tickTrans, model.GetAllEventVars());
bool reachable = model.PathForTA(CUDD.Function.Or(initEncoding.GuardDDs), deadlockGoadDD, discreteTrans,
tickTrans, automataBDD.SimulationRel, SelectedEngineName);
CUDD.Deref(discreteTrans, tickTrans);
this.VerificationOutput.VerificationResult = (reachable) ? VerificationResultType.INVALID : VerificationResultType.VALID;
}
}
/// <summary>
/// Return a computation of a buchi automata in form "prefix (period)*"
/// [ REFS: 'prefix, period', DEREFS:]
/// </summary>
/// <param name="automataBDD"></param>
/// <param name="model"></param>
public void MC(AutomataBDD automataBDD, Model model)
{
//Clear the old data
this.transitionsNoEvents.Clear();
this.prefix.Clear();
this.period.Clear();
ExpressionBDDEncoding initEncoding = automataBDD.initExpression.TranslateBoolExpToBDD(model);
if (initEncoding.GuardDDs.Count == 0)
{
return;
}
ExpressionBDDEncoding finalStateEncoding = automataBDD.acceptanceExpression.TranslateBoolExpToBDD(model);
if (finalStateEncoding.GuardDDs.Count == 0)
{
return;
}
CUDDNode initState = CUDD.Function.Or(initEncoding.GuardDDs);
CUDDNode finalState = CUDD.Function.Or(finalStateEncoding.GuardDDs);
CUDDNode finalStateWithNoEvent = CUDD.Abstract.ThereExists(finalState, model.GetAllEventVars());
CUDD.Ref(automataBDD.transitionBDD);
this.transitionsNoEvents = CUDD.Abstract.ThereExists(automataBDD.transitionBDD, model.GetAllEventVars());
CUDDNode allSCCs = SCCHull(model, initState, finalStateWithNoEvent);
if (!allSCCs.Equals(CUDD.ZERO) && VerificationOutput.GenerateCounterExample)
{
this.VerificationOutput.VerificationResult = VerificationResultType.INVALID;
//Transitions out from allSCCs
CUDD.Ref(transitionsNoEvents);
CUDD.Ref(allSCCs);
List<CUDDNode> R = CUDD.Function.And(transitionsNoEvents, allSCCs);
//pick one state from the set final
CUDD.Ref(allSCCs);
CUDDNode s = CUDD.RestrictToFirst(allSCCs, model.AllRowVars);
//while the states from which we can reach s are not all states that can be reached from s
CUDDNode scc;
while (true)
{
CUDD.Ref(s);
CUDDNode backwardOfS = model.PredecessorsStart(s, R);
CUDD.Ref(s);
CUDDNode forwardOfS = model.SuccessorsStart(s, R);
//
CUDD.Ref(backwardOfS, forwardOfS);
CUDDNode temp = CUDD.Function.Different(backwardOfS, forwardOfS);
if (temp.Equals(CUDD.ZERO))
{
scc = backwardOfS;
CUDD.Deref(forwardOfS, temp);
break;
}
else
{
CUDD.Deref(backwardOfS, forwardOfS, s);
s = CUDD.RestrictToFirst(temp, model.AllRowVars);
}
}
//R now contains only transitions within the SCC scc
CUDD.Ref(scc, scc, scc, scc);
R[0] = CUDD.Function.And(CUDD.Function.And(R[0], scc), model.SwapRowColVars(scc));
R[1] = CUDD.Function.And(CUDD.Function.And(R[1], scc), model.SwapRowColVars(scc));
CUDD.Ref(scc);
CUDDNode notInSCC = CUDD.Function.Not(scc);
List<CUDDNode> transitionNotInSCC = new List<CUDDNode>();
CUDD.Ref(transitionsNoEvents, transitionsNoEvents);
CUDD.Ref(notInSCC, notInSCC);
transitionNotInSCC.AddRange(CUDD.Function.And(transitionsNoEvents, notInSCC));
transitionNotInSCC.AddRange(CUDD.Function.And(transitionsNoEvents, model.SwapRowColVars(notInSCC)));
//prefix is now a shortest path from an initial state to a state in final
model.Path(initState, scc, transitionNotInSCC, prefix, true);
CUDD.Deref(transitionNotInSCC[0], transitionNotInSCC[1]);
//Dummy value
period.Add((prefix.Count == 0) ? initState : prefix[prefix.Count - 1]);
//cycle must pass final state
CUDD.Ref(period);
CUDD.Ref(finalStateWithNoEvent);
CUDDNode temp1 = CUDD.Function.And(CUDD.Function.Or(period), finalStateWithNoEvent);
if (temp1.Equals(CUDD.ZERO))
{
CUDD.Ref(scc, finalStateWithNoEvent);
CUDDNode acceptanceStateInCyle = CUDD.Function.And(scc, finalStateWithNoEvent);
model.Path(period[period.Count - 1], acceptanceStateInCyle, R, period, true);
CUDD.Deref(acceptanceStateInCyle);
}
CUDD.Deref(temp1);
//
bool isEmptyPathAllowed = period.Count != 1;
model.Path(period[period.Count - 1], period[0], R, period, isEmptyPathAllowed);
//Remove dummy
CUDD.Deref(period[0]); period.RemoveAt(0);
//
CUDD.Deref(initState, finalStateWithNoEvent, allSCCs, s, scc, notInSCC);
CUDD.Deref(transitionsNoEvents[0], transitionsNoEvents[1]);
CUDD.Deref(R[0], R[1]);
}
else
{
this.VerificationOutput.VerificationResult = VerificationResultType.VALID;
CUDD.Deref(initState, finalStateWithNoEvent, allSCCs);
CUDD.Deref(transitionsNoEvents[0], transitionsNoEvents[1]);
}
}
/// <summary>
/// Check whethere the goal can be reachable from the initial state of automataBDD
/// [ REFS: traces, DEREFS: ]
/// </summary>
/// <param name="automataBDD"></param>
/// <param name="goal"></param>
/// <param name="model"></param>
public void MC(AutomataBDD automataBDD, Expression goal, Model model)
{
//Clear the old data
this.traces.Clear();
ExpressionBDDEncoding goalBddEncoding = goal.TranslateBoolExpToBDD(model);
ExpressionBDDEncoding initEncoding = automataBDD.initExpression.TranslateBoolExpToBDD(model);
if (initEncoding.GuardDDs.Count == 0)
{
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
}
else
{
CUDDNode initDD = CUDD.Function.Or(initEncoding.GuardDDs);
CUDDNode goalDD = CUDD.Function.Or(goalBddEncoding.GuardDDs);
CUDD.Ref(automataBDD.transitionBDD);
List<CUDDNode> noEventTrans = CUDD.Abstract.ThereExists(automataBDD.transitionBDD, model.GetAllEventVars());
bool reachable = model.Path(initDD, goalDD, noEventTrans, traces, SelectedEngineName, VerificationOutput.GenerateCounterExample);
CUDD.Deref(noEventTrans);
//
CUDD.Deref(initDD, goalDD);
VerificationOutput.VerificationResult = (reachable) ? VerificationResultType.VALID : VerificationResultType.INVALID;
}
}
