public override Process ClearConstant(Dictionary<string, Expression> constMapping)
{
Expression[] newArgs = new Expression[Args.Length];
for (int i = 0; i < Args.Length; i++)
{
Expression arg = Args[i].ClearConstant(constMapping);
if (!arg.HasVar)
newArgs[i] = EvaluatorDenotational.Evaluate(arg, null);
else
newArgs[i] = arg;
}
DefinitionRef newRef = new DefinitionRef(Name, newArgs);
//this is a special cases happened in the middle of parsing, where the current Def is not initialized in the parser.
//so need to put the newRef into the def list to initialize the Def once the parsing is done.
if (Def == null)
{
//TreeWalker.dlist.Add(newRef);
//TreeWalker.dtokens.Add(null);
}
else
{
newRef.Def = Def;
}
return newRef;
}
/// <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;
}
}
/// <summary>
/// Tick transition if done is false, don't need to add unchanged condition of other local variables.
/// They will be updated after the event becomes true
/// use the tick transition of P1 if done is true
/// </summary>
/// <param name="P1"></param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void EventPrefixEncodeTick(Expression guardOfTick, AutomataBDD P1, Model model, AutomataBDD result)
{
Expression guard;
List<CUDDNode> guardDD;
//1. !done and guardOfTick and event = tick and !done'
if (!(guardOfTick is BoolConstant && !(guardOfTick as BoolConstant).Value))
{
guard = Expression.AND(
Expression.EQ(
new Variable(result.newLocalVarName),
new IntConstant(0)),
Expression.AND(
guardOfTick,
new PrimitiveApplication(
PrimitiveApplication.AND,
AutomataBDD.
GetTerminateTransExpression
(),
new Assignment(
result.newLocalVarName,
new IntConstant(0)))));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = model.AddVarUnchangedConstraint(guardDD, model.GlobalVarIndex);
result.Ticks.AddRange(guardDD);
}
//2. done and p1.Tick and done'
guard = Expression.AND(Expression.EQ(new Variable(result.newLocalVarName), new IntConstant(1)),
new Assignment(result.newLocalVarName, new IntConstant(0)));
guardDD = guard.TranslateBoolExpToBDD(model).GuardDDs;
guardDD = CUDD.Function.And(guardDD, P1.Ticks);
result.Ticks.AddRange(guardDD);
}
public IndexInterleaveAbstract(Process processBase, Expression range)
{
Processes = new List<Process>();
Processes.Add(processBase);
RangeExpression = range;
}
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);
}
/// <summary>
/// Return AutomataBDD of the guard process
/// </summary>
/// <param name="guard">The guard expression of the process P1</param>
/// <param name="P1">AutomataBDD of the process P1</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD Guard(Expression guard, AutomataBDD P1, Model model)
{
AutomataBDD result = AutomataBDD.Guard(guard, P1, model);
GuardEncodeTick(guard, P1, model, result);
//
return result;
}
/// <summary>
/// Return the AutomataBDD of the Channel Output
/// </summary>
/// <param name="channelName">Channel's name</param>
/// <param name="channelEventIndex"></param>
/// <param name="exps">List of output expressions of the channel</param>
/// <param name="guardOfTick"></param>
/// <param name="P1"><AutomataBDD of process P1 after the channel input/param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD SyncChannelOutputPrefixing(int channelEventIndex, List<Expression> exps, Expression guardOfTick, AutomataBDD P1, Model model)
{
AutomataBDD result = AutomataBDD.SyncChannelOutputPrefixing(channelEventIndex, exps, P1, model);
EventPrefixEncodeTick(guardOfTick, P1, model, result);
//
return result;
}
public PrimitiveApplication(String op, Expression a1)
{
ExpressionType = ExpressionType.PrimitiveApplication;
Operator = op;
Argument1 = a1;
this.HasVar = a1.HasVar;
expressionID = Operator + Argument1.ExpressionID;
}
public ClassPropertyAssignment(ClassProperty property, Expression rhs)
{
ClassProperty = property;
RightHandExpression = rhs;
ExpressionType = ExpressionType.ClassPropertyAssignment;
HasVar = ClassProperty.HasVar || rhs.HasVar;
expressionID = ClassProperty.ExpressionID + "=" + RightHandExpression.ExpressionID;
}
public Sequence(Expression f, Expression s)
{
FirstPart = f;
SecondPart = s;
HasVar = f.HasVar || s.HasVar;
ExpressionType = ExpressionType.Sequence;
expressionID = FirstPart.ExpressionID + ";" + SecondPart.ExpressionID;
}
/// <summary>
/// Return AutomataBDD of the not tau event prefix process with guard [b] e -> P1
/// </summary>
/// <param name="guard"></param>
/// <param name="updateOfEvent">Update command happening with the event</param>
/// <param name="guardOfTick">Guard of the tick before engaging the event</param>
/// <param name="P1">AutomataBDD of the process P1 engaging after the event</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD EventPrefix(Expression guard, Expression updateOfEvent, Expression guardOfTick, AutomataBDD P1, Model model)
{
AutomataBDD result = AutomataBDD.EventPrefix(guard, updateOfEvent, P1, model);
EventPrefixEncodeTick(guardOfTick, P1, model, result);
//
return result;
}
public DataOperationPrefix(Event e, Expression assignment, Process process, string[] localvar)
{
Event = e;
AssignmentExpr = assignment;
Process = process;
LocalVariables = localvar;
ProcessID = DataStore.DataManager.InitializeProcessID(Event.GetID() + "{" + AssignmentExpr.ExpressionID + "}" + Constants.EVENTPREFIX + Process.ProcessID);
}
/// <summary>
/// Return the AutomataBDD of the Channel Output
/// </summary>
/// <param name="channelName">Channel's name</param>
/// <param name="channelEventIndex"></param>
/// <param name="exps">List of output expressions of the channel</param>
/// <param name="assignmentExp"></param>
/// <param name="guardOfTick"></param>
/// <param name="P1"><AutomataBDD of process P1 after the channel input/param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD ChannelOutputPrefixing(string channelName, int channelEventIndex, List<Expression> exps, Expression assignmentExp, Expression guardOfTick, AutomataBDD P1, Model model)
{
AutomataBDD result = AutomataBDD.ChannelOutputPrefixing(channelName, channelEventIndex, exps, assignmentExp,
P1, model);
EventPrefixEncodeTick(guardOfTick, P1, model, result);
//
return result;
}
public Assignment(string l, Expression r)
{
LeftHandSide = l;
RightHandSide = r;
ExpressionType = ExpressionType.Assignment;
HasVar = true;
expressionID = LeftHandSide + "=" + RightHandSide.ExpressionID;
}
//string[] localvar,
public PNTransition(Event e, ParallelDefinition[] selects, Expression guard, Expression assignment, PNPlace from, PNPlace to)
{
Event = e;
Selects = selects;
ProgramBlock = assignment;
GuardCondition = guard;
FromPNPlace = from;
ToPNPlace = to;
}
/// <summary>
///
/// </summary>
/// <param name="channelName">The channel Name</param>
/// <param name="channelEventIndex"></param>
/// <param name="guard">If no guard, give BoolConstant(true)</param>
/// <param name="exps">List of expressions of channel out</param>
/// <param name="assignmentExp">If no guard, give BoolConstant(true)</param>
/// <param name="P1">Process after channel in</param>
/// <param name="model"></param>
/// <param name="result"></param>
private static void ChannelInputEncodeTransition(string channelName, int channelEventIndex, Expression guard, List<Expression> exps, Expression assignmentExp, AutomataBDD P1, Model model, AutomataBDD result)
{
List<Expression> guardUpdateChannel = GetGuardUpdateOfChannelInput(channelName, guard, exps, assignmentExp, model);
//set update Model.Event_Name
guardUpdateChannel[1] = new Sequence(guardUpdateChannel[1], new Assignment(Model.EVENT_NAME, new IntConstant(channelEventIndex)));
EventPrefixEncodeTransition(guardUpdateChannel[0], guardUpdateChannel[1], P1, model, result);
}
public While(Expression t, Expression b)
{
Test = t;
Body = b;
this.HasVar = t.HasVar || b.HasVar;
ExpressionType = ExpressionType.While;
expressionID = "W@" + Test.ExpressionID + "{" + Body.ExpressionID + "}";
}
public LetDefinition(String v, Expression rhe)
{
Variable = v;
RightHandExpression = rhe;
HasVar = true;
ExpressionType = ExpressionType.Let;
expressionID = Variable + "=" + RightHandExpression.ExpressionID;
}
public PropertyAssignment(Expression rec, Expression p, Expression rhs)
{
RecordExpression = rec;
PropertyExpression = p;
RightHandExpression = rhs;
ExpressionType = ExpressionType.PropertyAssignment;
this.HasVar = RecordExpression.HasVar || PropertyExpression.HasVar || rhs.HasVar;
expressionID = RecordExpression.ExpressionID + "[" + PropertyExpression.ExpressionID + "]=" + RightHandExpression.ExpressionID;
}
public override Process ClearConstant(Dictionary<string, Expression> constMapping)
{
Expression[] newExpression = new Expression[ExpressionList.Length];
for (int i = 0; i < ExpressionList.Length; i++)
{
newExpression[i] = ExpressionList[i].ClearConstant(constMapping);
}
return new ChannelOutput(ChannelName, newExpression, Process.ClearConstant(constMapping));
}
public ParallelDefinition(string para, IToken token)
{
Parameter = para;
Domain = new List<Expression>();
DomainValues = new List<int>();
//HasVaraible = false;
LowerBound = null;
UpperBound = null;
Token = token;
}
public ConditionalChoice(Process firstProcess, Process secondProcess, Expression conditionExpression)
{
FirstProcess = firstProcess;
SecondProcess = secondProcess;
ConditionalExpression = conditionExpression;
ProcessID = DataStore.DataManager.InitializeProcessID(FirstProcess.ProcessID + Constants.CONDITIONAL_CHOICE +
conditionExpression.ExpressionID + Constants.CONDITIONAL_CHOICE +
SecondProcess.ProcessID);
}
//string[] localvar,
public Transition(Event e, ParallelDefinition[] selects, Expression Guard, Expression assignment, State from, State to)
{
Event = e;
Selects = selects;
ProgramBlock = assignment;
//LocalVariables = localvar;
GuardCondition = Guard;
FromState = from;
ToState = to;
}
private static Expression CreateFunctionApplication(
Dictionary <string, List <int> > availableFunctions,
IEnumerable <IGrouping <string, GeneLink> > toDictionary,
int i,
Mode mode,
Dictionary <string, bool> values)
{
Expression res = null;
toDictionary.ToList().ForEach(ff =>
{
Expression ass = null;
var to = ff.Key;
var froms = ff.Where(a => !a.IsOptional).ToList();
// can be null!!
if (availableFunctions == null || !availableFunctions.ContainsKey(to))
{
res = AddIfExist(res, CreateAssignment(ff.FirstOrDefault(), i, GetFunction(mode)), mode);
}
else
{
var availableFunc = availableFunctions[to];
var funcAssignmentHelper = new FuncAssignmentHelper();
var toFormatted = Formater.FormatParameter(to, i + 1);
availableFunc.ForEach(f =>
{
ass =
funcAssignmentHelper.CreateFuncAssignment(to, froms, i, f);
//if (values != null && values.ContainsKey(toFormatted))
//{
// ass = new PrimitiveApplication(PrimitiveApplication.AND, ass, new BoolConstant(values[toFormatted]));
// values.Remove(toFormatted);
//}
});
if (mode == Mode.Equal)
{
res = new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(toFormatted),
ass);
}
else
{
res = GetFunction(mode).Invoke(toFormatted, ass);
}
}
});
return(res);
}
public override Expression ClearConstant(Dictionary<string, Expression> constMapping)
{
Expression[] newArgs = new Expression[Arguments.Length];
for (int i = 0; i < Arguments.Length; i++)
{
newArgs[i] = Arguments[i].ClearConstant(constMapping);
}
return new NewObjectCreation(ClassName, newArgs);
}
public override Expression ClearConstant(Dictionary<string, Expression> constMapping)
{
Expression[] newArgs = new Expression[Arguments.Length];
for (int i = 0; i < Arguments.Length; i++)
{
newArgs[i] = Arguments[i].ClearConstant(constMapping);
}
return new ClassMethodCallInstance(Variable.ClearConstant(constMapping), MethodName, newArgs);
}
/// <summary>
/// Return the AutomataBDD of the Channel Input
/// Currently Channel Input is translated as assginment, not guard. We don't support using channel input to expect a certain value
/// </summary>
/// <param name="channelName">Channel's name</param>
/// <param name="channelEventIndex"></param>
/// <param name="guard">Guard expression of the channel input</param>
/// <param name="exps">List of input expression to the channel</param>
/// <param name="assignmetExp"></param>
/// <param name="P1">AutomataBDD of process P1 after the channel input</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD ChannelInputPrefixing(string channelName, int channelEventIndex, Expression guard, List<Expression> exps, Expression assignmetExp, AutomataBDD P1, Model model)
{
AutomataBDD result = new AutomataBDD();
ChannelInputSetVariable(exps, P1, model, result);
EventPrefixSetInit(result);
ChannelInputEncodeTransition(channelName, channelEventIndex, guard, exps, assignmetExp, P1, model, result);
//
return result;
}
/// <summary>
/// Return AutomataBDD of the guard process
/// </summary>
/// <param name="guard">The guard expression of the process P1</param>
/// <param name="P1">AutomataBDD of the process P1</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD Guard(Expression guard, AutomataBDD P1, Model model)
{
AutomataBDD result = new AutomataBDD();
GuardSetVariable(P1, model, result);
GuardSetInit(P1, result);
GuardEncodeTransition(guard, P1, model, result);
//
return result;
}
public override Expression ClearConstant(Dictionary<string, Expression> constMapping)
{
Expression[] newAssociations = new Expression[Associations.Length];
for (int i = 0; i < Associations.Length; i++)
{
newAssociations[i] = Associations[i].ClearConstant(constMapping);
}
return new Record(newAssociations);
}
/// <summary>
/// Return AutomataBDD of the not tau event prefix process with guard [b] e -> P1
/// </summary>
/// <param name="guard">Guard of this event to happen</param>
/// <param name="updateOfEvent">Update command happening with the event</param>
/// <param name="P1">AutomataBDD of the process P1 engaging after the event</param>
/// <param name="model"></param>
/// <returns></returns>
public static AutomataBDD EventPrefix(Expression guard, Expression updateOfEvent, AutomataBDD P1, Model model)
{
AutomataBDD result = new AutomataBDD();
EventPrefixSetVariable(P1, model, result);
EventPrefixSetInit(result);
EventPrefixEncodeTransition(guard, updateOfEvent, P1, model, result);
//
return result;
}
public int HVal(Expression exp)
{
PrimitiveApplication pa = exp as PrimitiveApplication;
foreach (StringDictionaryEntryWithKey<ExpressionValue> expVal in Variables._entries)
{
if ("P3".Equals(expVal.Key))
{
return (expVal.Value as IntConstant).Value;
}
}
return -1;
}
public ChannelOutputEvent(string name, Expression ex)
: base(name)
{
if (ex == null)
{
ExpressionList = new Expression[0];
}
else
{
ExpressionList = new Expression[] { ex };
}
}
private static Expression SetGoalBasedOnFunction(List <GeneLink> booleanNetwok,
Dictionary <string, List <int> > availableFunctions, int depth)
{
Expression seq = null;
var toDictionary = booleanNetwok.GroupBy(a => a.To);
for (int i = 0; i < depth - 1; i++)
{
Expression ass = null;
toDictionary.ToList().ForEach(ff =>
{
var b = ff.FirstOrDefault();
var from = Formater.FormatParameter(b.From, i);
var to = Formater.FormatParameter(b.To, i + 1);
if (b.IsPositive)
{
//ass = new Assignment(b.To,
// new Variable(b.From));
ass = new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(to), new Variable(from));
}
else
{
ass = new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(to),
new PrimitiveApplication(
PrimitiveApplication.AND, new PrimitiveApplication(nOT, new Variable(from))));
}
if (seq == null)
{
seq = ass;
}
else
{
seq =
new PrimitiveApplication(PrimitiveApplication.AND,
seq,
ass);
}
});
}
return(seq);
}
private static Expression CreateExpressionBasedOnAutomata(GeneNode automata)
{
Expression goal1 = null;
if (automata == null || automata.Transitions == null || !automata.Transitions.Any())
{
return(null);
}
int i = 0;
automata.Visit(l =>
{
var tr = GetTransitions(l);
if (tr == null)
{
return;
}
tr
.ForEach(
f =>
{
var primitiveApplication =
new Assignment(Formater.FormatParameter(f.Key, i), new BoolConstant(f.Value.Value));
if (goal1 == null)
{
goal1 = primitiveApplication;
}
else
{
goal1 = new Sequence(
goal1,
primitiveApplication);
}
});
i++;
});
logger.Info("Goal: " + goal1);
return(goal1);
}
private static Expression SetGoalsBasedOnAutomata(GeneNode automata)
{
Expression goal1 = null;
if (automata == null || automata.Transitions == null || !automata.Transitions.Any())
{
return(null);
}
int i = 0;
automata.Visit(l =>
{
var tr = GetTransitions(l);
if (tr == null)
{
return;
}
tr
.ForEach(
f =>
{
var primitiveApplication =
BddHelper.SetBooleanValue(i, f.Value.Value, f.Key);
if (goal1 == null)
{
goal1 = primitiveApplication;
}
else
{
goal1 = new PrimitiveApplication(PrimitiveApplication.AND,
goal1,
primitiveApplication);
}
});
i++;
});
return(goal1);
}
private static Expression AddIfExist(Expression res, Expression createAssignment, Mode mode)
{
if (res == null)
{
return(createAssignment);
}
if (mode == Mode.Equal)
{
res = new PrimitiveApplication(PrimitiveApplication.AND, res, createAssignment);
}
else
{
res = new Sequence(res, createAssignment);
}
return(res);
}
private static Expression CreateExpressionsFromBooleanNetwork(List <GeneLink> booleanNetwok,
Dictionary <string, List <int> > availableFunctions,
int depth,
Mode mode,
Dictionary <string, bool> values = null)
{
Expression seq = null;
var toDictionary = booleanNetwok.GroupBy(a => a.To);
for (int i = 0; i < depth - 1; i++)
{
var ass = CreateFunctionApplication(availableFunctions, toDictionary, i, mode, values);
seq = AddIfExist(seq, ass, mode);
}
return(seq);
}
private static Assignment CreateAssignment(string toFormatted, Expression ass)
{
return(new Assignment(toFormatted, ass));
}
private static Expression CreateEquality(string toFormatted, Expression ass)
{
return(new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(toFormatted), ass));
}
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);
}
}
