/// <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 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);
}
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));
}
/// <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);
}
/// <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>
/// 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);
}
/// <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);
}
}
/// <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>
/// 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>
/// 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);
}
/// <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);
}
/// <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));
}
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 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);
}
/// <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));
}
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>
/// 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);
}
public NondetModelChecker(NonDetModel model)
: base(model)
{
allNondetVars = model.allNondetVars;
FilterStates();
CUDD.Ref(trans01, reach);
nondetMask = CUDD.Function.And(CUDD.Function.Not(CUDD.Abstract.ThereExists(trans01, allColVars)), reach);
Debug.WriteLine("States: " + CUDD.GetNumMinterms(reach, allRowVars.GetNumVars()) + " (" + CUDD.GetNumMinterms(start, allRowVars.GetNumVars()) + " initial)");
Debug.WriteLine("Transitions: " + CUDD.GetNumMinterms(trans01, allRowVars.GetNumVars() * 2 + allNondetVars.GetNumVars()));
Debug.WriteLine("Transition matrix: " + CUDD.Print.GetInfoString(trans, allRowVars.GetNumVars() * 2 + allNondetVars.GetNumVars()) +
", vars: " + allRowVars.GetNumVars() + "r/" + allColVars.GetNumVars() + "c/" + allNondetVars.GetNumVars() + "nd");
}
private void HandleInitBelief(PlanningParser.InitBeliefContext context)
{
if (context != null)
{
StringDictionary assignment = new StringDictionary();
InitBelief = context.gd().GetCuddNode(_predicateDict, assignment);
InitBelief = CUDD.Function.And(InitBelief, _exclusiveAxiom);
}
else
{
InitBelief = InitKnowledge;
CUDD.Ref(InitBelief);
CUDD.Deref(_exclusiveAxiom);
}
}
/// <summary>
/// Return variable expression
/// </summary>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
result.GuardDDs.Add(CUDD.Constant(1));
int variableIndex = model.GetVarIndex(this.expressionID);
CUDDNode varDD = model.variableEncoding[variableIndex];
CUDD.Ref(varDD);
result.ExpressionDDs.Add(varDD);
return(result);
}
/// <summary>
/// Add new local variable
/// </summary>
/// <param name="name"></param>
/// <param name="lower"></param>
/// <param name="upper"></param>
public void AddLocalVar(string name, int lower, int upper)
{
varList.AddNewVariable(name, lower, upper);
int numBits = varList.GetNumberOfBits(name);
CUDDNode vr, vc;
CUDDVars rowVar = new CUDDVars();
CUDDVars colVar = new CUDDVars();
for (int j = 0; j < numBits; j++)
{
vr = CUDD.Var(numverOfBoolVars++);
vc = CUDD.Var(numverOfBoolVars++);
rowVar.AddVar(vr);
colVar.AddVar(vc);
}
this.rowVars.Add(rowVar);
this.colVars.Add(colVar);
this.AllRowVars.AddVars(rowVar);
this.AllRowVarsExceptSingleCopy.AddVars(rowVar);
this.AllColVars.AddVars(colVar);
// used for unchanged variable in transition.
CUDDNode identity = CUDD.Constant(0);
for (int i = lower; i <= upper; i++)
{
identity = CUDD.Matrix.SetMatrixElement(identity, rowVar, colVar, i - lower, i - lower, 1);
}
this.varIdentities.Add(identity);
//
CUDDNode expressionDD = CUDD.MINUS_INFINITY; CUDD.Ref(expressionDD);
for (int i = lower; i <= upper; i++)
{
expressionDD = CUDD.Matrix.SetVectorElement(expressionDD, rowVar, i - lower, i);
}
this.variableEncoding.Add(expressionDD);
//
CUDD.Ref(identity);
allRowVarRanges = CUDD.Function.And(allRowVarRanges, CUDD.Abstract.ThereExists(identity, colVar));
CUDD.Ref(identity);
colVarRanges.Add(CUDD.Abstract.ThereExists(identity, rowVar));
}
/// <summary>
/// Return strongly connected components
/// Does not include Event variable
/// this.transitionsNoEvents is the transtion from reachble states
/// From Feasible algorithm in the article "LTL Symbolic MC"
/// [ REFS: 'result', DEREFS:]
/// </summary>
/// <param name="model"></param>
/// <param name="initState"></param>
/// <param name="cycleMustPass">The cycle must pass all states in the cycleMustPass</param>
/// <returns></returns>
private CUDDNode SCCHull(Model model, CUDDNode initState, List <CUDDNode> cycleMustPass)
{
CUDDNode old = CUDD.Constant(0);
CUDD.Ref(initState);
CUDDNode New = model.SuccessorsStart(initState, this.transitionsNoEvents);
//Limit transition to transition of reachable states
CUDD.Ref(New, New);
transitionsNoEvents[0] = CUDD.Function.And(transitionsNoEvents[0], New);
transitionsNoEvents[1] = CUDD.Function.And(transitionsNoEvents[1], New);
//Pruning step: remove states whose succeessors are not belong to that set
while (!New.Equals(old))
{
CUDD.Deref(old);
CUDD.Ref(New);
old = New;
foreach (var justice in cycleMustPass)
{
//final state as justice requirement
//new = (new and J) x R*
CUDD.Ref(justice);
New = model.SuccessorsStart(CUDD.Function.And(New, justice), this.transitionsNoEvents);
}
//while new is not comprised of the set of all successors of new states
while (true)
{
CUDD.Ref(New, New);
CUDDNode temp = CUDD.Function.And(New, model.Successors(New, this.transitionsNoEvents));
if (temp.Equals(New))
{
CUDD.Deref(temp);
break;
}
else
{
CUDD.Deref(New);
New = temp;
}
}
}
return(New);
}
/// <summary>
/// [ REFS: 'result', DEREFS: 'guard' ]
/// </summary>
/// <param name="moduleIndex"></param>
/// <param name="update"></param>
/// <param name="synch"></param>
/// <param name="guard"></param>
/// <returns></returns>
public CUDDNode EncodeUpdate(int moduleIndex, Update update, CUDDNode guard)
{
List <int> updatedVarIndexes = new List <int>();
CUDDNode result = CUDD.Constant(1);
foreach (var assignment in update.Assignments)
{
int varIndex = varList.GetVarIndex(assignment.LeftHandSide);
updatedVarIndexes.Add(varIndex);
int low = varList.GetVarLow(varIndex);
int high = varList.GetVarHigh(varIndex);
CUDDNode leftDD = CUDD.Constant(0);
for (int i = low; i <= high; i++)
{
leftDD = CUDD.Matrix.SetVectorElement(leftDD, colVars[varIndex], i - low, i);
}
CUDDNode rightDD = EncodeExpression(assignment.RightHandSide);
CUDDNode commandDD = CUDD.Function.Equal(leftDD, rightDD);
CUDD.Ref(guard);
commandDD = CUDD.Function.And(commandDD, guard);
//filter out of range configuration
CUDD.Ref(colVarRanges[varIndex]);
commandDD = CUDD.Function.And(commandDD, colVarRanges[varIndex]);
CUDD.Ref(allRowVarRanges);
commandDD = CUDD.Function.And(commandDD, allRowVarRanges);
result = CUDD.Function.And(result, commandDD);
}
//Global variables and other local variables in the current module if not updated must be the same
for (int i = 0; i < varList.GetNumberOfVar(); i++)
{
if ((varList.GetModuleIndex(i) == moduleIndex || varList.GetModuleIndex(i) == Modules.DefaultMainModuleIndex) && !updatedVarIndexes.Contains(i))
{
CUDD.Ref(varIdentities[i]);
result = CUDD.Function.And(result, varIdentities[i]);
}
}
return(CUDD.Function.Times(result, CUDD.Constant((update.Probability as DoubleConstant).Value)));
}
private void GenerateKnowPrecondition()
{
KnowPrecondition = BelievePrecondition;
if (MaxPlausibilityDegree == 1)
{
CUDD.Ref(KnowPrecondition);
for (int i = _believeEventArray.Length; i < _knowEventArray.Length; i++)
{
CUDDNode eventPreNode = _knowEventArray[i].Precondition;
CUDD.Ref(eventPreNode);
KnowPrecondition = CUDD.Function.Or(KnowPrecondition, eventPreNode);
}
}
}
/// <summary>
/// (temp ∧ P1.Trans/In/Out ∧ temp')
/// [ REFS: '', DEREFS: 'P1']
/// </summary>
private static void CopyTransitionAfterEventChannel(AutomataBDD P1, Model model, AutomataBDD result)
{
Expression guard = new PrimitiveApplication(PrimitiveApplication.AND, new PrimitiveApplication(PrimitiveApplication.EQUAL, 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 void HandleInitKnowledge(PlanningParser.InitKnowledgeContext context)
{
CUDD.Ref(_exclusiveAxiom);
//Console.WriteLine("Exclusive axiom:");
//CUDD.Print.PrintMinterm(_exclusiveAxiom);
if (context != null)
{
StringDictionary assignment = new StringDictionary();
InitKnowledge = context.gd().GetCuddNode(_predicateDict, assignment);
InitKnowledge = CUDD.Function.And(_exclusiveAxiom, InitKnowledge);
}
else
{
InitKnowledge = _exclusiveAxiom;
}
}
public CUDDNode ComputeCumulReward(int rewardStructIndex, int bound)
{
CUDDNode result = CUDD.Constant(0);
if (bound > 0)
{
CUDDNode allRewards = ProbAlgo.ProbCumulReward(trans, stateRewards[rewardStructIndex], transRewards[rewardStructIndex], allRowVars, allColVars, bound);
CUDD.Deref(result);
CUDD.Ref(start);
result = CUDD.Function.Times(allRewards, start);
}
//
return(result);
}
