public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD processAutomataBDD = this.Process.Encode(encoder);
//
return(AutomataBDD.Guard(this.Condition, processAutomataBDD, encoder.model));
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD process1BDD = this.FirstProcess.Encode(encoder);
AutomataBDD process2BDD = this.SecondProcess.Encode(encoder);
return(AutomataBDD.Sequence(process1BDD, process2BDD, encoder.model));
}
private static List <CUDDNode> IsExistPath(Expression goal1, BDDEncoder encoder,
List <CUDDNode> path,
CUDDNode initDD,
AutomataBDD systemBDD,
List <string> letters,
ref bool reach1)
{
CUDDNode goal1DD;
goal1DD = CUDD.Function.Or(goal1.TranslateBoolExpToBDD(encoder.model).GuardDDs);
path = new List <CUDDNode>();
reach1 = encoder.model.PathForward(initDD, goal1DD, new List <List <CUDDNode> >()
{
systemBDD.transitionBDD
}, path, false);
logger.Info("Finish run. Result is " + reach1);
#if DEBUG
StringBuilder builder = new StringBuilder();
PrintResult(builder, path, encoder, letters);
logger.Info(builder.ToString());
#endif
return(path);
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD process1BDD = this.FirstProcess.Encode(encoder);
Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU));
return(AutomataBDD.EventPrefix(this.ConditionalExpression, eventUpdateExpression, process1BDD, encoder.model));
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD processAutomataBDD = this.Process.Encode(encoder);
Expression eventUpdateExpression = encoder.GetEventExpression(this.Event);
//
return(AutomataBDD.EventPrefix(new BoolConstant(true), eventUpdateExpression, processAutomataBDD, encoder.model));
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD process1BDD = this.FirstProcess.Encode(encoder);
AutomataBDD process2BDD = this.SecondProcess.Encode(encoder);
//
AutomataBDD ifBDD = AutomataBDD.Guard(this.ConditionalExpression, process1BDD, encoder.model);
AutomataBDD elseBDD = AutomataBDD.Guard(Expression.NOT(this.ConditionalExpression), process2BDD, encoder.model);
//
return AutomataBDD.Choice(new List<AutomataBDD> { ifBDD, elseBDD }, encoder.model);
}
/// <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();
}
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);
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD process1BDD = this.FirstProcess.Encode(encoder);
AutomataBDD process2BDD = this.SecondProcess.Encode(encoder);
Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU));
//
AutomataBDD ifBDD = AutomataBDD.EventPrefix(this.ConditionalExpression, eventUpdateExpression, process1BDD, encoder.model);
AutomataBDD elseBDD = AutomataBDD.EventPrefix(Expression.NOT(this.ConditionalExpression), eventUpdateExpression, process2BDD, encoder.model);
//
return(AutomataBDD.Choice(new List <AutomataBDD> {
ifBDD, elseBDD
}, encoder.model));
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD processAutomataBDD = this.Process.Encode(encoder);
if (encoder.model.mapChannelToSize.ContainsKey(this.ChannelName))
{
int channelEventIndex = encoder.GetChannelIndex(this.ChannelName, BDDEncoder.EventChannelInfo.EventType.ASYNC_CHANNEL_OUTPUT);
return(AutomataBDD.ChannelOutputPrefixing(this.ChannelName, channelEventIndex, new List <Expression>(this.ExpressionList), AssignmentExpr, processAutomataBDD, encoder.model));
}
else
{
List <Expression> expressionList = (this.ExpressionList != null) ? new List <Expression>(this.ExpressionList) : new List <Expression>();
int channelEventIndex = encoder.GetEventIndex(this.ChannelName, expressionList.Count);
return(AutomataBDD.SyncChannelOutputPrefixing(channelEventIndex, expressionList, processAutomataBDD, encoder.model));
}
}
/// <summary>
/// Could not support GenerateSymbolicLTS because if tau transition happen, choice is not resolve. Diffcult to track current state
/// </summary>
/// <param name="encoder"></param>
/// <returns></returns>
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
List <Process> newnewListProcess = Processes;
if (Processes == null)
{
newnewListProcess = IndexedProcessDefinition.GetIndexedProcesses(new Dictionary <string, Expression>());
}
List <AutomataBDD> processAutomataBDDs = new List <AutomataBDD>();
foreach (Process process in newnewListProcess)
{
processAutomataBDDs.Add(process.Encode(encoder));
}
//
return(AutomataBDD.ExternalChoice(processAutomataBDDs, encoder.model));
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
List <Process> newnewListProcess = Processes;
if (Processes == null)
{
newnewListProcess = IndexedProcessDefinition.GetIndexedProcesses(new Dictionary <string, Expression>());
}
List <AutomataBDD> processBDDs = new List <AutomataBDD>();
List <CUDDNode> alphabets = new List <CUDDNode>();
foreach (Process process in newnewListProcess)
{
processBDDs.Add(process.Encode(encoder));
alphabets.Add(encoder.GetAlphabetInBDD(process.GetAlphabets(new Dictionary <string, string>())));
}
//
return(AutomataBDD.Parallel(processBDDs, alphabets, encoder.model));
}
/// <summary>
/// P = [] {[guardi] tau -> Pi}
/// </summary>
/// <param name="encoder"></param>
/// <returns></returns>
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
List <AutomataBDD> processAutomataBDDs = new List <AutomataBDD>();
Expression previousguardsOR = null;
Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU));
for (int i = 0; i < Processes.Length; i++)
{
Expression guard = null;
if (i == 0)
{
guard = Conditions[i];
}
else //if (previousguardsOR != null)
{
guard = Expression.AND(guard, Expression.NOT(previousguardsOR));
}
AutomataBDD processAutomataBDd = Processes[i].Encode(encoder);
AutomataBDD guardProcessAutomataBDD = AutomataBDD.EventPrefix(guard, eventUpdateExpression, processAutomataBDd, encoder.model);
processAutomataBDDs.Add(guardProcessAutomataBDD);
previousguardsOR = Expression.OR(previousguardsOR, guard);
}
//if all conditions are not satisfied, it becomes Skip
Expression allConditions = new BoolConstant(true);
foreach (var condition in Conditions)
{
allConditions = Expression.OR(allConditions, condition);
}
processAutomataBDDs.Add(AutomataBDD.EventPrefix(Expression.NOT(allConditions), eventUpdateExpression, new Skip().Encode(encoder), encoder.model));
return(AutomataBDD.Choice(processAutomataBDDs, encoder.model));
}
private static void PrintResult(StringBuilder sb, List <CUDDNode> path, BDDEncoder encoder, List <string> letters)
{
foreach (var cuddNode in path)
{
CUDD.Print.PrintMinterm(cuddNode);
// CUDD.Print.PrintBDDTree(path);
encoder.model.PrintAllVariableValue(cuddNode);
letters.ForEach(l =>
{
int valueOfX = encoder.model.GetRowVarValue(cuddNode, l);
sb.AppendLine(l + " = " + valueOfX);
}
);
int v = encoder.model.GetRowVarValue(cuddNode, "#state#0");
sb.AppendLine("#state#0" + " = " + v);
int v1 = encoder.model.GetRowVarValue(cuddNode, "#event");
sb.AppendLine("#event" + " = " + v1);
}
}
/// <summary>
/// Encode sync channel out transition as event!a.b.c
/// </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> EncodeSyncChannelOutTransition(BDDEncoder encoder, string processVariableName, List <int> localVars)
{
Expression guard = Expression.EQ(new Variable(processVariableName),
new IntConstant(encoder.stateIndexOfCurrentProcess[this.FromPNPlace.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)));
for (int i = 0; i < parameters.Count; i++)
{
//assign event parameter to the values in the event expression
guard = Expression.AND(guard, new Assignment(encoder.model.eventParameterVariables[i], parameters[i]));
}
guard = Expression.AND(guard, new Assignment(processVariableName,
new IntConstant(encoder.stateIndexOfCurrentProcess[this.ToPNPlace.ID])));
List <CUDDNode> transitions = guard.TranslateBoolExpToBDD(encoder.model).GuardDDs;
return(encoder.model.AddVarUnchangedConstraint(transitions, localVars));
}
/// <summary>
/// Encode transition, if it is synchronized, then we don't add constraint of unchanged global variables
/// Parallel process only synchorinize event which does not change global variable or each transition changes same to global variables
/// 3 kinds of transition: normal event, async channel input and async channel output
/// </summary>
/// <param name="encoder"></param>
/// <param name="processVariableName"></param>
/// <param name="localVars">Local of the current SymbolicLTS is unchanged</param>
/// <param name="isSynchronized"></param>
/// <returns></returns>
public List <CUDDNode> Encode(BDDEncoder encoder, string processVariableName, List <int> localVars, bool isSynchronized)
{
Expression guardExpressions = Expression.EQ(new Variable(processVariableName),
new IntConstant(encoder.stateIndexOfCurrentProcess[this.FromPNPlace.ID]));
guardExpressions = Expression.CombineGuard(guardExpressions, GuardCondition);
Expression eventUpdateExpression;
if (this.Event is BDDEncoder.EventChannelInfo)
{
int channelIndex = encoder.GetChannelIndex(this.Event.BaseName, (this.Event as BDDEncoder.EventChannelInfo).type);
eventUpdateExpression = new Assignment(Model.EVENT_NAME, new IntConstant(channelIndex));
}
else
{
eventUpdateExpression = encoder.GetEventExpression(this.Event);
}
Assignment PNPlaceUpdateExpression = new Assignment(processVariableName,
new IntConstant(encoder.stateIndexOfCurrentProcess[this.ToPNPlace.ID]));
Sequence updateExpressions = new Sequence(eventUpdateExpression, PNPlaceUpdateExpression);
if (this.ProgramBlock != null)
{
updateExpressions = new Sequence(updateExpressions, this.ProgramBlock);
}
List <int> unchangedVars = new List <int>(localVars);
if (!isSynchronized)
{
unchangedVars.AddRange(encoder.model.GlobalVarIndex);
}
return(encoder.model.EncodeTransition(guardExpressions, updateExpressions, unchangedVars));
}
public void Test1Test()
{
var sb = new StringBuilder();
string varX = "x";
string varY = "y";
//Set number of action names, 2 for a, b
Model.NUMBER_OF_EVENT = 3;
Model.MAX_NUMBER_EVENT_PARAMETERS = 0;
BDDEncoder encoder = new BDDEncoder();
encoder.model.AddGlobalVar(varX, 0, 10);
encoder.model.AddGlobalVar(varY, 0, 10);
SymbolicLTS lts = new SymbolicLTS();
State state1 = lts.AddState();
State state2 = lts.AddState();
State state3 = lts.AddState();
State state4 = lts.AddState();
lts.InitialState = state1;
var primitiveApplication1 = new Assignment(varX, new PrimitiveApplication(PrimitiveApplication.PLUS,
new Variable(varX),
new IntConstant(1)));
var primitiveApplication2 = new Assignment(varY, new PrimitiveApplication(PrimitiveApplication.PLUS,
new Variable(varY),
new IntConstant(4)));
/*
*
* for (int i = 0; i < exps.Count; i++)
* {
* //Update eventParameterVariables[i] = exps[i]
* //Don't need to update exps because later after synchronization, not updated variable keeps the same value
* update = new Sequence(update, new Assignment(model.eventParameterVariables[i], exps[i]));
* }
*/
var primitiveApplication = new Sequence(primitiveApplication1,
primitiveApplication2);
/*PrimitiveApplication.CombineProgramBlock(
* primitiveApplication1,
* primitiveApplication2);*/
logger.Info(primitiveApplication);
Transition trans1 = new Transition(new Event("a"), null,
primitiveApplication,
state1,
state2);
Expression assignment =
new Assignment(varX, new PrimitiveApplication(PrimitiveApplication.PLUS,
new Variable(varX),
new IntConstant(2)));
logger.Info("Assignments: " + assignment);
var secAssignment =
new Assignment(varY,
new PrimitiveApplication(PrimitiveApplication.PLUS,
new Variable(varY), new WildConstant()));
Transition trans2 = new Transition(new Event("b"), null,
primitiveApplication,
state2,
state3);
Transition trans3 = new Transition(new Event("c"), null,
primitiveApplication,
state3,
state4);
lts.AddTransition(trans1);
lts.AddTransition(trans2);
lts.AddTransition(trans3);
AutomataBDD systemBDD = lts.Encode(encoder);
//Variable x is initialised to 1
systemBDD.initExpression = new PrimitiveApplication(PrimitiveApplication.AND,
systemBDD.initExpression,
new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(varX), new IntConstant(1)));
systemBDD.initExpression = new PrimitiveApplication(PrimitiveApplication.AND,
systemBDD.initExpression,
new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(varY), new IntConstant(1)));
CUDDNode initDD = CUDD.Function.Or(systemBDD.initExpression.TranslateBoolExpToBDD(encoder.model).GuardDDs);
logger.Info("init: " + systemBDD.initExpression);
var u = 1;
for (; u < 2; u++)
{
logger.Info($"U is {u}");
//Define 2 goals
Expression goal1 = new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(varX), new IntConstant(3));
goal1 = new PrimitiveApplication(PrimitiveApplication.AND, goal1, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(varY), new IntConstant(9)));
//Encode 2 goals to BDD
CUDDNode goal1DD = CUDD.Function.Or(goal1.TranslateBoolExpToBDD(encoder.model).GuardDDs);
logger.Info("Goal: " + goal1);
List <CUDDNode> path = new List <CUDDNode>();
bool reach1 = encoder.model.PathForward(initDD, goal1DD, new List <List <CUDDNode> >()
{
systemBDD.transitionBDD
}, path, true);
if (reach1)
{
sb.AppendLine("goal1 is reachable");
foreach (var cuddNode in path)
{
encoder.model.PrintAllVariableValue(cuddNode);
logger.Info("after");
CUDD.Print.PrintMinterm(cuddNode);
// CUDD.Print.PrintBDDTree(path);
int valueOfX = encoder.model.GetRowVarValue(cuddNode, varX);
sb.AppendLine(varX + " = " + valueOfX);
int valueOfY = encoder.model.GetRowVarValue(cuddNode, varY);
sb.AppendLine(varY + " = " + valueOfY);
}
}
else
{
sb.AppendLine("goal1 is unreachable");
}
path.Clear();
}
/*
* bool reach2 = encoder.model.PathForward(initDD, goal2DD, new List<List<CUDDNode>>() { systemBDD.transitionBDD }, path, true);
* if (reach2)
* {
* sb.AppendLine("goal2 is reachable");
* foreach (var cuddNode in path)
* {
* int valueOfX = encoder.model.GetRowVarValue(cuddNode, varX);
* sb.AppendLine(varX + " = " + valueOfX);
* }
* }
* else
* {
* sb.AppendLine("goal2 is unreachable");
* }
*/
logger.Info(sb);
encoder.model.Close();
}
public bool IsValidPath(GeneNode automata, List <GeneLink> booleanNetwok, Dictionary <string, List <int> > availableFunctions = null)
{
lock (locker)
{
var tempAutomata = automata;
// new GeneNode()
//{
// NodeName = "Start",
// CurrentCondition = new Condition(),
// Transitions = new List<GeneTransition>()
// {
// new GeneTransition()
// {
// Node = automata
// }
// }
//};
var letters = new List <string>();
int z = 0;
var depth = tempAutomata.NodeLength;
tempAutomata.GetAllConditionLetters(letters);
letters = letters.SelectMany(l => Enumerable.Range(0, depth).ToList().Select(n => Formater.FormatParameter(l, n))).ToList();
logger.Info(tempAutomata.NodeLength + 1);
Model.NUMBER_OF_EVENT = tempAutomata.NodeLength + 2;
Model.MAX_NUMBER_EVENT_PARAMETERS = 0;
BDDEncoder encoder = new BDDEncoder();
letters.Distinct().ToList().ForEach(l => encoder.model.AddLocalVar(l, 0, 1));
logger.Info(string.Join(",", letters));
SymbolicLTS lts = new SymbolicLTS();
List <State> states = new List <State>();
var state0 = lts.AddState();
states.Add(state0);
lts.InitialState = states[0];
var state1 = lts.AddState();
states.Add(state1);
//var goal2 = CreateExpressionBasedOnAutomata(tempAutomata);
var dictValues = BDDLogicHelper.CreateDictBasedOnAutomata(tempAutomata);
Expression seq = null;
/*CreateExpressionsFromBooleanNetwork(booleanNetwok,
* availableFunctions, depth, Mode.Assignment, dictValues);*/
if (dictValues.Any())
{
dictValues.ToList().ForEach(f =>
{
Expression curr = new Assignment(f.Key, new BoolConstant(f.Value));
seq = seq == null ? curr : new Sequence(seq, curr);
});
}
//seq = new Sequence(seq, goal2);
// //
logger.Info("Assignments: " + seq);
var trans1 =
new Transition(new Event("a0"), null, seq,
states[0], states[1]);
lts.Transitions.Add(trans1);
logger.Info(lts);
AutomataBDD systemBDD = lts.Encode(encoder);
systemBDD.PrintTransition();
CUDDNode initDD = CUDD.Function.Or(
systemBDD.initExpression.TranslateBoolExpToBDD(encoder.model).GuardDDs);
bool reach1 = true;
var path = new List <CUDDNode>();
var geneTransition = tempAutomata;
InitInitialState(geneTransition, systemBDD, letters);
var goal = SetGoalsBasedOnAutomata(geneTransition);
var goal3 = CreateExpressionsFromBooleanNetwork(booleanNetwok,
availableFunctions, depth, Mode.Equal);
goal = new PrimitiveApplication(PrimitiveApplication.AND, goal, goal3);
logger.Info("Goal: " + goal);
path = IsExistPath(goal, encoder, path, initDD, systemBDD, letters, ref reach1);
path.Clear();
encoder.model.Close();
return(reach1);
}
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
return(AutomataBDD.Stop());
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
return(AutomataBDD.Skip(encoder.model));
}
