public override ExpressionBDDEncoding TranslateBoolExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
result.GuardDDs.Add(CUDD.Constant(1));
result = TranslateStatementToBDD(result, model);
return(result);
}
/// <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 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));
}
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);
}
/// <summary>
/// Close the model, dereference variables
/// </summary>
public void Close()
{
this.AllRowVarsExceptSingleCopy.Deref();
this.AllColVars.Deref();
CUDD.Deref(this.varIdentities);
CUDD.Deref(this.variableEncoding);
CUDD.Deref(this.variableRanges);
CUDD.CloseDownCUDD();
}
/// <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>
/// [ REFS: 'none', DEREFS: 'dd if failed to add' ]
/// </summary>
public void AddNodeToGuard(CUDDNode dd)
{
if (!dd.Equals(CUDD.ZERO))
{
this.GuardDDs.Add(dd);
}
else
{
CUDD.Deref(dd);
}
}
/// <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);
}
public void Deref()
{
CUDD.Deref(ind.guards, ind.trans);
CUDD.Deref(ind.rewards);
foreach (var componentDDse in synchs)
{
CUDD.Deref(componentDDse.guards, componentDDse.trans);
CUDD.Deref(componentDDse.rewards);
}
CUDD.Deref(id);
}
/// <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);
}
private void HandlePredicateDefine(PlanningParser.PredicateDefineContext context)
{
_exclusiveAxiom = CUDD.Constant(1);
_predicateDict = new Dictionary <string, Predicate>();
foreach (var atomFormSkeleton in context.atomFormSkeleton())
{
PredicateEnumerator enumerator = new PredicateEnumerator(atomFormSkeleton, _predicateDict, _currentCuddIndex);
Algorithms.IterativeScanMixedRadix(enumerator);
_currentCuddIndex = enumerator.CurrentCuddIndex;
if (atomFormSkeleton.oneofDefine() != null)
{
Console.WriteLine("Predicate {0} have oneOf", atomFormSkeleton.predicate().GetText());
//Console.WriteLine("Hello!");
//Console.ReadLine();
string predicateName = atomFormSkeleton.predicate().GetText();
int oneOfVarsCount = atomFormSkeleton.oneofDefine().VAR().Count;
string[] oneOfVarNameArray = new string[oneOfVarsCount];
var varNameList = atomFormSkeleton.listVariable().GetVariableNameList();
var collection = atomFormSkeleton.listVariable().GetCollection();
IList <string>[] notOneOfVarCollection = new IList <string> [varNameList.Count - oneOfVarsCount];
Parallel.For(0, oneOfVarsCount,
i => oneOfVarNameArray[i] = atomFormSkeleton.oneofDefine().VAR(i).GetText());
for (int i = 0, k = 0; i < varNameList.Count; i++)
{
bool exists = oneOfVarNameArray.Any(s => s == varNameList[i]);
if (!exists)
{
notOneOfVarCollection[k] = collection[i];
k++;
if (k == notOneOfVarCollection.Length)
{
break;
}
}
}
ExclusiveAxiomEnumerator exclusiveAxiomEnumerator = new ExclusiveAxiomEnumerator(predicateName,
_predicateDict, notOneOfVarCollection);
Algorithms.IterativeScanMixedRadix(exclusiveAxiomEnumerator);
_exclusiveAxiom = CUDD.Function.And(_exclusiveAxiom, exclusiveAxiomEnumerator.ExclusiveAxiom);
}
}
//foreach (var predicate in _predicateDict.Values)
//{
// Console.WriteLine("name: {0}, Previous index: {1}, successive index: {2}", predicate.FullName, predicate.PreviousCuddIndex, predicate.SuccessiveCuddIndex);
//}
}
/// <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);
}
}
static void Test1(string domainFileName, string problemFileName)
{
CUDD.InitialiseCUDD(256, 256, 262144, 0.1);
// Create a TextReader that reads from a file
TextReader tr = new StreamReader(domainFileName);
// create a CharStream that reads from standard input
AntlrInputStream input = new AntlrInputStream(tr);
// create a lexer that feeds off of input CharStream
PlanningLexer lexer = new PlanningLexer(input);
// create a buffer of tokens pulled from the lexer
CommonTokenStream tokens = new CommonTokenStream(lexer);
// create a parser that feeds off the tokens buffer
PlanningParser parser = new PlanningParser(tokens);
var domainContext = parser.domain();// begin parsing at init rule
//Console.WriteLine(domainContext.ToStringTree(parser));
tr.Close();
//var domain = Domain.CreateInstance(domainContext);
//ShowDomainInfo(domain);
// Create a TextReader that reads from a file
tr = new StreamReader(problemFileName);
// create a CharStream that reads from standard input
input = new AntlrInputStream(tr);
// create a lexer that feeds off of input CharStream
lexer = new PlanningLexer(input);
// create a buffer of tokens pulled from the lexer
tokens = new CommonTokenStream(lexer);
// create a parser that feeds off the tokens buffer
parser = new PlanningParser(tokens);
var serverProblemContext = parser.serverProblem();// begin parsing at init rule
//Console.WriteLine(serverProblemContext.ToStringTree(parser));
tr.Close();
//Console.ReadLine();
ServerProblem problem = ServerProblem.CreateInstance(domainContext, serverProblemContext);
problem.ShowInfo();
Server server = new Server(port, listenBacklog, problem);
server.Run();
Console.ReadLine();
}
/// <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>
/// 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>
/// 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>
/// [ 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));
}
/// <summary>
/// [ REFS: 'result', DEREFS: none ]
/// </summary>
/// <returns></returns>
private CUDDNode GetKbNode()
{
//OK
CUDDNode result = CUDD.Constant(1);
foreach (var pair in _predBooleanMap)
{
string name = pair.Key;
int index = _predicateDict[name].PreviousCuddIndex;
CUDDNode literal = pair.Value ? CUDD.Var(index) : CUDD.Function.Not(CUDD.Var(index));
result = CUDD.Function.And(result, literal);
}
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);
}
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);
}
public void Update(Event e)
{
var literalList = GenerateLiteralList(CurrentCuddNode, e);
UpdateByLiteralList(literalList);
CUDD.Deref(CurrentCuddNode);
CurrentCuddNode = GetKbNode();
if (Changed != null)
{
var tuple = new Tuple <IReadOnlyDictionary <string, bool>, Event>(_predBooleanMap, e);
Changed(this, tuple);
}
}
/// <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);
}
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 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>
/// Use when the boolen constant is used as expression: a = true
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
string channelName = Arguments[0].ToString();
string countChannelVariable = Model.GetCountVarChannel(channelName);
string topChannelVariable = Model.GetTopVarChannel(channelName);
switch (MethodName)
{
case Constants.cfull:
Expression isFull = Expression.EQ(new Variable(countChannelVariable), new IntConstant(model.mapChannelToSize[channelName]));
ExpressionBDDEncoding isFullTemp = isFull.TranslateBoolExpToBDD(model);
isFullTemp.ExpressionDDs = new List <CUDDNode>(isFullTemp.GuardDDs);
isFullTemp.GuardDDs = new List <CUDDNode>()
{
CUDD.Constant(1)
};
return(isFullTemp);
case Constants.cempty:
Expression isEmpty = Expression.EQ(new Variable(countChannelVariable), new IntConstant(0));
ExpressionBDDEncoding isEmptyTemp = isEmpty.TranslateBoolExpToBDD(model);
isEmptyTemp.ExpressionDDs = new List <CUDDNode>(isEmptyTemp.GuardDDs);
isEmptyTemp.GuardDDs = new List <CUDDNode>()
{
CUDD.Constant(1)
};
return(isEmptyTemp);
case Constants.ccount:
return(new Variable(countChannelVariable).TranslateIntExpToBDD(model));
case Constants.csize:
return(new IntConstant(model.mapChannelToSize[channelName]).TranslateIntExpToBDD(model));
case Constants.cpeek:
//(top_a - count_a) % L
Expression popedElementPosition = new PrimitiveApplication(PrimitiveApplication.MOD,
Expression.MINUS(new Variable(topChannelVariable), new Variable(countChannelVariable)),
new IntConstant(model.mapChannelToSize[channelName]));
//a[top_a - count_a % L][i]
return(new PrimitiveApplication(PrimitiveApplication.ARRAY, new Variable(channelName), Expression.TIMES(
popedElementPosition,
new IntConstant(Model.MAX_MESSAGE_LENGTH))
).TranslateIntExpToBDD(model));
}
throw new Exception("Static call can not be encoded in BDD");
}
/// <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);
}
///
/// <summary>
/// Use when the boolen constant is used as expression: a = true
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
result.GuardDDs.Add(CUDD.Constant(1));
if (Value)
{
result.ExpressionDDs.Add(CUDD.Constant(1));
}
else
{
result.ExpressionDDs.Add(CUDD.Constant(0));
}
return(result);
}
