public bool Equals(ConfigurationBase other) { if ((object)other == null) return false; return this.GlobalEnv.GetID() == other.GlobalEnv.GetID(); }
public TarjanThread(ConfigurationBase initialStep, BuchiAutomata ba, PATThreadPool threadPool, FairnessType FairnessType) { this.initialStep = initialStep; this.VerificationResult = VerificationResultType.UNKNOWN; this.BA = ba; this.ThreadPool = threadPool; this.FairnessType = FairnessType; this.FairSCC = null; this.JobFinished = false; }
public void GetCounterxampleString(StringBuilder sb) { if (GenerateCounterExample) { sb.Append("<"); bool hasVisibleEvent = false; for (int i = 0; i < CounterExampleTrace.Count; i++) { ConfigurationBase step = CounterExampleTrace[i]; if (step.Event == Constants.INITIAL_EVENT) { sb.Append(step.Event); } else { sb.Append(" -> "); if (LoopIndex >= 0 && i == LoopIndex) { sb.Append("("); } sb.Append(step.GetDisplayEvent()); if (step.Event != Constants.TAU && i >= LoopIndex && LoopIndex >= 0) { hasVisibleEvent = true; } } } if (LoopIndex >= 0 && !hasVisibleEvent) { sb.Append(" -> (" + Constants.TAU + " -> "); } if (LoopIndex >= 0) { sb.Append(")*"); } sb.AppendLine(">"); } else { sb.AppendLine("Counterexample generation is ignored."); } }
/// <summary> /// To get all states which can be reached by tau-transitions only; meanwhile, identify which of them are divergent states. /// </summary> /// <param name="States"></param> /// <returns></returns> private static bool IsDivergent(ConfigurationBase States) { Dictionary<string, int[]> DFSData = new Dictionary<string, int[]>(); Dictionary<string, List<string>> transitions = new Dictionary<string, List<string>>(); List<string> StronglyConnectedComponets = new List<string>(); Stack<ConfigurationBase> TaskStack = new Stack<ConfigurationBase>(); TaskStack.Push(States); DFSData.Add(States.GetID(), new int[] { VISITED_NOPREORDER, 0 }); transitions.Add(States.GetID(), new List<string>()); Stack<ConfigurationBase> stepStack = new Stack<ConfigurationBase>(); //# Preorder counter int ii = 0; //store the expended event step of a node to avoid multiple invocation of the make one move. Dictionary<string, List<ConfigurationBase>> ExpendedNode = new Dictionary<string, List<ConfigurationBase>>(); do { ConfigurationBase pair = TaskStack.Peek(); string v = pair.GetID(); List<string> outgoing = transitions[v]; int[] nodeData = DFSData[v]; if (nodeData[0] == VISITED_NOPREORDER) { nodeData[0] = ii; ii++; } bool done = true; if (ExpendedNode.ContainsKey(v)) { List<ConfigurationBase> list = ExpendedNode[v]; if (list.Count > 0) { //transverse all steps for (int k = list.Count - 1; k >= 0; k--) { ConfigurationBase step = list[k]; string tmp = step.GetID(); //if the step is a unvisited step //if (!preorder.ContainsKey(t)) if (DFSData[tmp][0] == VISITED_NOPREORDER) { //only add the first unvisited step //for the second or more unvisited steps, ignore at the monent if (done) { TaskStack.Push(step); //procPath.Add(step.GetID()); done = false; list.RemoveAt(k); } } else { list.RemoveAt(k); } } } } else { List<ConfigurationBase> product = new List<ConfigurationBase>(pair.MakeOneMove(Constants.TAU)); //.AmpleTau(procPath, false); for (int k = product.Count - 1; k >= 0; k--) { ConfigurationBase step = product[k]; string tmp = step.GetID(); //if (DFSData.ContainsKey(tmp)) int[] data; if (DFSData.TryGetValue(tmp, out data)) { //int t = visited[stateString]; outgoing.Add(tmp); //if this node is still not visited //if (!preorder.ContainsKey(tmp)) if (data[0] == VISITED_NOPREORDER) { //only put the first one to the work list stack. //if there are more than one node to be visited, //simply ignore them and keep its event step in the list. if (done) { TaskStack.Push(step); done = false; product.RemoveAt(k); } else { product[k] = step; } } //this node is truly visited. can be removed else { product.RemoveAt(k); } } else { DFSData.Add(tmp, new int[] { VISITED_NOPREORDER, 0 }); transitions.Add(tmp, new List<string>(8)); outgoing.Add(tmp); //only put the first one into the stack. if (done) { TaskStack.Push(step); done = false; product.RemoveAt(k); } else { product[k] = step; } } } //create the remaining steps as the expending list for v ExpendedNode.Add(v, product); } if (done) { int lowlinkV = nodeData[0]; int preorderV = lowlinkV; bool selfLoop = false; for (int j = 0; j < outgoing.Count; j++) { string w = outgoing[j]; if (w == v) { selfLoop = true; } int[] wdata = DFSData[w]; if (wdata[0] != SCC_FOUND) { if (wdata[0] > preorderV) { lowlinkV = Math.Min(lowlinkV, wdata[1]); } else { lowlinkV = Math.Min(lowlinkV, wdata[0]); } } } nodeData[1] = lowlinkV; TaskStack.Pop(); if (lowlinkV == preorderV) { StronglyConnectedComponets.Add(v); nodeData[0] = SCC_FOUND; while (stepStack.Count > 0 && DFSData[stepStack.Peek().GetID()][0] > preorderV) { ConfigurationBase s = stepStack.Pop(); string tmp = s.GetID(); //int k = visited[tmp]; StronglyConnectedComponets.Add(tmp); //scc_found.Add(tmp); } //outgoing.Count == 0 --> deadlock, we need to check //outgoing.Count == 0 //StronglyConnectedComponets.Count > 1 || selfLoop -> non-trivial case, we need to check if (StronglyConnectedComponets.Count > 1 || selfLoop) { return true; } foreach (string componet in StronglyConnectedComponets) { ExpendedNode.Remove(componet); } StronglyConnectedComponets.Clear(); } else { stepStack.Push(pair); } } } while (TaskStack.Count > 0); foreach (string key in DFSData.Keys) { VisitedNonDivStates.Add(key); } return false; }
/// <summary> /// Given one environment, get the initial states of the product of the system and the automata. Notice that the automata /// is allowed to make one move first. This is necessary to check the very first state of the system. /// </summary> /// <param name="initialStep"></param> /// <returns></returns> public static List<LocalPair> GetInitialPairsLocal(BuchiAutomata BA, ConfigurationBase initialStep) { List<LocalPair> toReturn = new List<LocalPair>(); HashSet<string> existed = new HashSet<string>(); foreach (string s in BA.InitialStates) { List<string> next = BA.MakeOneMove(s, initialStep); foreach (string var in next) { if (existed.Add(var)) { toReturn.Add(new LocalPair(initialStep, var)); } } } return toReturn; }
//public List<string> Engaged; public LocalPair(ConfigurationBase e, string s) { configuration = e; state = s; Enabled = new List<string>(); }
public bool EqualsV(ConfigurationBase input) { return(GlobalEnv.GetID() == input.GlobalEnv.GetID()); }
private void AddCounterExamplePrefixPathNode(ref string sourceProcess, ConfigurationBase stepOld, bool firstSCC) { Node n = null; Edge edge = null; //EventStepSim fromStep = CounterExampleTrace[j-1]; EventStepSim step = new EventStepSim(stepOld); step.SourceProcess = sourceProcess; //change all nodes to white node! foreach (Node mapN in g.NodeMap.Values) { if (mapN.Attr.FillColor == Color.Red) { mapN.Attr.FillColor = Color.White; } } string stepString; ////string nextState = step.ToFullString(); if (step.StepVisited(visited, out stepString)) { Node srcNode = g.FindNode(step.SourceProcess); edge = null; foreach (Edge outEdge in srcNode.OutEdges) { if (outEdge.LabelText == step.Event && outEdge.Target == stepString) { //duplicate edge is found edge = outEdge; break; } } if (edge == null) { edge = g.AddEdge(step.SourceProcess, step.Event, stepString); } n = edge.TargetNode; // g.NodeMap[stepString] as Node; AddToTrace(edge.SourceNode.LabelText, step, edge.TargetNode.LabelText, stepString); } else { visited.Add(stepString, null); //add the new node and set it to red. n = g.AddNode(stepString); n.LabelText = (g.NodeCount - 1).ToString(); n.UserData = step; //// nextState; edge = g.AddEdge(step.SourceProcess, step.Event, stepString); AddToTrace(edge.SourceNode.LabelText, step, n.LabelText, stepString); } if (firstSCC) { n.Attr.FillColor = Color.LightGreen; } else { n.Attr.FillColor = Color.Red; } sourceProcess = stepString; string key = GetTraceEvent(this.ListView_Trace.Items.Count) + stepString; if (!Mapping.ContainsKey(key)) { Mapping.Add(key, new ProcessData(step, CloneGraph(g), CloneEnabledEvent())); } UpdateStore(step); }
private void AddAllTauReachableSteps(ConfigurationBase step, List<EventStepSim> listResutlt) { NormalizedState NState = NormalizedState.TauReachable(new List<ConfigurationBase>() {step}); foreach (ConfigurationBase state in NState.States) { //for each step in this IEnumerable<ConfigurationBase> templist = state.MakeOneMove(); bool hasNonTauEvent = false; foreach (ConfigurationBase step1 in templist) { if (step1.Event != Common.Classes.Ultility.Constants.TAU) { hasNonTauEvent = true; break; } } //if the step has non-tau transition, this should be a boundary step, and we need to keep it if (hasNonTauEvent || state.IsDeadLock) { if (state.Event == Common.Classes.Ultility.Constants.TAU) { //do we need to add the * state.Event = step.Event; //+ "*" state.DisplayName = null; } EventStepSim step1Sim = new EventStepSim(state); bool contains = false; foreach (EventStepSim sim in listResutlt) { if (sim.Event == step1Sim.Event && sim.StepID == step1Sim.StepID) { contains = true; break; } } //duplicated steps should not be added in. if (!contains) { listResutlt.Add(step1Sim); } } } }
public List<string> MakeOneMove(string state, ConfigurationBase config) { List<string> returnList = new List<string>(); Transition[] trans = fromTransitions[state]; string evt = config.Event; foreach (Transition tran in trans) { bool toAdd = true; foreach (Proposition label in tran.labels) { //If the transition is labelled with Sigma, there should not be any other labels. if (label.IsSigmal) { returnList.Add(tran.ToState); break; } string labelstring = label.Label; Expression exp; //If the labed is negated, e.g., !eat0. if (label.Negated) { //if (!DeclarationDatabase.ContainsKey(labelstring)) //If the label is an event. if(!DeclarationDatabase.TryGetValue(labelstring, out exp)) { //if the label says that this event can not happen, the event is eat0 and the label is !eat0. if (labelstring == evt) { toAdd = false; break; } } else //If the label is a proposition. { //if (config.ImplyCondition(DeclarationDatabase[labelstring])) if (config.ImplyCondition(exp)) { toAdd = false; break; } } } else //if (!label.Negated) { //if (!DeclarationDatabase.ContainsKey(labelstring)) //If the label is an event. if (!DeclarationDatabase.TryGetValue(labelstring, out exp)) { if (labelstring != evt) { toAdd = false; break; } } else //If the label is a proposition. { if (!config.ImplyCondition(exp)) { toAdd = false; break; } } } } if (toAdd && !returnList.Contains(tran.ToState)) { returnList.Add(tran.ToState); } } return returnList; }
private List<ConfigurationBase> MakeOneMove(ConfigurationBase currentStep) { List<ConfigurationBase> listResult = new List<ConfigurationBase>(); IEnumerable<ConfigurationBase> list = currentStep.MakeOneMove(); foreach (ConfigurationBase step in list) { bool contains = false; foreach (ConfigurationBase dest in listResult) { if (dest.Event == step.Event) { contains = true; break; } } //duplicated steps should not be added in. if (!contains) { listResult.Add(step); } } return listResult; }
public bool EqualsV(ConfigurationBase input) { return GlobalEnv.GetID() == input.GlobalEnv.GetID(); }
public bool IsDivergent() { Stack <ConfigurationBase> working = new Stack <ConfigurationBase>(); List <string> path = new List <string>(100); StringHashTable visited = new StringHashTable(100); //The following are for identifying the current path. Stack <int> depthStack = new Stack <int>(1024); depthStack.Push(0); List <int> depthList = new List <int>(1024); //The above are for identifying the current path. working.Push(this); visited.Add(GetID()); while (working.Count > 0) { ConfigurationBase current = working.Pop(); IEnumerable <ConfigurationBase> nextStates = current.MakeOneMove(Constants.TAU); //The following are for identifying the current path. int depth = depthStack.Pop(); if (depth > 0) { while (depthList[depthList.Count - 1] >= depth) { int lastIndex = depthList.Count - 1; depthList.RemoveAt(lastIndex); path.RemoveAt(lastIndex); } } path.Add(current.GetID()); depthList.Add(depth); if (nextStates != null) { //for (int i = 0; i < nextStates.Length; i++) foreach (ConfigurationBase next in nextStates) { //ConfigurationBase next = nextStates[i]; string ID = next.GetID(); if (path.Contains(ID)) { return(true); } else { if (!visited.ContainsKey(ID)) { visited.Add(ID); working.Push(next); depthStack.Push(depth + 1); } } } } } return(false); }
public static DeterministicAutomata BuildDeterministicAutomataWithRefusalsAndDiv(ConfigurationBase initStep) { return BuildAutomataWithRefusalsAndDiv(initStep).DeterminizeWithRefusalsAndDiv(); }
public EventBAPairSafety(ConfigurationBase e, List<string> s) { configuration = e; States = s; }
private static Automata BuildAutomataWithRefusalsAndDiv(ConfigurationBase InitSpecStep) { Dictionary<string, FAState> visited = new Dictionary<string, FAState>(); Stack<ConfigurationBase> working = new Stack<ConfigurationBase>(1024); working.Push(InitSpecStep); Automata auto = new Automata(); FAState init = auto.AddState(); auto.SetInitialState(init); visited.Add(InitSpecStep.GetID(), init); do { ConfigurationBase current = working.Pop(); FAState currentState = visited[current.GetID()]; if (current.IsDivergent()) { currentState.IsDiv = true; } else { IEnumerable<ConfigurationBase> list = current.MakeOneMove(); List<string> negateRefusal = new List<string>(); bool hasTau = false; //for (int i = 0; i < list.Length; i++) foreach (ConfigurationBase step in list) { //ConfigurationBase step = list[i]; if (step.Event == Constants.TAU) { hasTau = true; } else { negateRefusal.Add(step.Event); } FAState target; string nextID = step.GetID(); if (visited.ContainsKey(nextID)) { target = visited[nextID]; } else { target = auto.AddState(); working.Push(step); visited.Add(nextID, target); } auto.AddTransition(currentState, step.Event, target); } if (hasTau) { currentState.NegatedRefusal = null; } else { currentState.NegatedRefusal = negateRefusal; } } } while (working.Count > 0); return auto; }
public static EventBAPairSafety GetInitialPairs(BuchiAutomata BA, ConfigurationBase initialStep) { List<string> intialBAStates = new List<string>(); //List<string> existed = new List<string>(); foreach (string s in BA.InitialStates) { List<string> next = BA.MakeOneMove(s, initialStep); foreach (string var in next) { if (!intialBAStates.Contains(var)) { //existed.Add(var); intialBAStates.Add(var); } } } return new EventBAPairSafety(initialStep, intialBAStates); }
/// <summary> /// This method checks whether the found counterexample is spurious or not. /// This checking only works for abstraction for parameterized systems. /// </summary> /// <returns></returns> protected virtual bool IsCounterExampleSpurious() { Stack <ConfigurationBase> working = new Stack <ConfigurationBase>(1024); List <ConfigurationBase> ConcreteCounterExampleTrace = new List <ConfigurationBase>(64); working.Push(InitialStep); Stack <int> depthStack = new Stack <int>(1024); depthStack.Push(0); List <int> depthList = new List <int>(1024); StringHashTable visited = new StringHashTable(1024); visited.Add("0-" + InitialStep.GetID()); do { ConfigurationBase current = working.Pop(); int depth = depthStack.Pop(); if (depth > 0) { while (depthList[depthList.Count - 1] >= depth) { int lastIndex = depthList.Count - 1; depthList.RemoveAt(lastIndex); ConcreteCounterExampleTrace.RemoveAt(lastIndex); } } ConcreteCounterExampleTrace.Add(current); depthList.Add(depth); if (ConcreteCounterExampleTrace.Count == VerificationOutput.CounterExampleTrace.Count) { VerificationOutput.CounterExampleTrace = ConcreteCounterExampleTrace; Ultility.Ultility.CutNumber = 2; return(false); } else { ConfigurationBase abstractStep = VerificationOutput.CounterExampleTrace[depth + 1]; IEnumerable <ConfigurationBase> steps = current.MakeOneMove(abstractStep.Event); //for (int j = 0; j < steps.Length; j++) foreach (ConfigurationBase step in steps) { if (abstractStep.EqualsV(step)) { string tmp = (depth + 1) + "-" + step.GetID(); if (!visited.ContainsKey(tmp)) { working.Push(step); depthStack.Push(depth + 1); visited.Add(tmp); } } } } } while (working.Count > 0); return(true); }
public EventBAPairSafety[] Next(BuchiAutomata BA, ConfigurationBase[] steps) { EventBAPairSafety[] product = new EventBAPairSafety[steps.Length]; // * BA.States.Length); for (int i = 0; i < steps.Length; i++) { List<string> targetStates = new List<string>(); foreach (string state in States) { List<string> states = BA.MakeOneMove(state, steps[i]); Ultility.Ultility.Union(targetStates, states); } product[i] = new EventBAPairSafety(steps[i], targetStates); } return product; }
public EventStepSim(ConfigurationBase configuration) { Config = configuration; }
public virtual Bitmap MapConfigurationToImage(ConfigurationBase config, int imageSize) { return null; }
public virtual Bitmap MapConfigurationToImage(ConfigurationBase config, int imageSize) { return(null); }
protected List<ConfigurationBase> GetConcreteTrace(ConfigurationBase init, List<string> trace) { System.Diagnostics.Debug.Assert(trace.Count == 0 || init.GetIDWithEvent() == GetConfigID(trace[0])); List<ConfigurationBase> toReturn = new List<ConfigurationBase>(64); ConfigurationBase currentConfig = init; toReturn.Add(currentConfig); for (int i = 1; i < trace.Count; i++) { string id = GetConfigID(trace[i]); IEnumerable<ConfigurationBase> next = currentConfig.MakeOneMove(); foreach (ConfigurationBase configurationBase in next) { if (configurationBase.GetIDWithEvent() == id) { toReturn.Add(configurationBase); currentConfig = configurationBase; break; } } } return toReturn; }