/**
* Compute forward simulation relation of a Buchi automaton
* @param omega: a Buchi automaton
* @param FSim: the maximal bound of simulation relation
*
* @return maximal simulation relation on states of the input automaton with FSim
*/
//public static StatePairComparator StatePairComparator = new StatePairComparator();
//public HashSet<Pair<FAState, FAState>> FSimRelNBW(FiniteAutomaton omega, HashSet<Pair<FAState, FAState>> FSim)
//{
// HashSet<Pair<FAState, FAState>> nextFSim = new HashSet<Pair<FAState, FAState>>();
// bool changed = true;
// while (changed)
// {
// changed = false;
// foreach (Pair<FAState, FAState> pair in FSim)
// {
// if (NextStateSimulated(FSim, omega, pair.Left, pair.Right))
// {
// nextFSim.Add(new Pair<FAState, FAState>(pair.Left, pair.Right));
// }
// else
// {
// changed = true;
// }
// }
// FSim = nextFSim;
// nextFSim = new HashSet<Pair<FAState, FAState>>();
// }
// return FSim;
//}
public Dictionary <string, HashSet <FAState> > FastFSimRelNBW(Automata omega, bool[,] fsim)
{
//implement the HHK algorithm
int n_states = omega.States.Count;
int n_symbols = omega.Alphabet.Count;
FAState[] states = omega.States.Values.ToArray();
List <String> symbols = new List <String>(omega.Alphabet);
// fsim[u][v]=true iff v in fsim(u) iff v forward-simulates u
int[,,] pre = new int[n_symbols, n_states, n_states];
int[,,] post = new int[n_symbols, n_states, n_states];
int[,] pre_len = new int[n_symbols, n_states];
int[,] post_len = new int[n_symbols, n_states];
//state[post[s][q][r]] is in post_s(q) for 0<=r<adj_len[s][q]
//state[pre[s][q][r]] is in pre_s(q) for 0<=r<adj_len[s][q]
for (int s = 0; s < n_symbols; s++)
{
string a = symbols[s];
for (int p = 0; p < n_states; p++)
{
for (int q = 0; q < n_states; q++)
{
HashSet <FAState> next = states[p].Post[a];
if (next != null && next.Contains(states[q]))
{
//if p --a--> q, then p is in pre_a(q), q is in post_a(p)
pre[s, q, pre_len[s, q]++] = p;
post[s, p, post_len[s, p]++] = q;
}
}
}
}
int[] todo = new int[n_states * n_symbols];
int todo_len = 0;
int[,,] remove = new int[n_symbols, n_states, n_states];
int[,] remove_len = new int[n_symbols, n_states];
for (int a = 0; a < n_symbols; a++)
{
for (int p = 0; p < n_states; p++)
{
if (pre_len[a, p] > 0) // p is in a_S
{
//Sharpen_S_a:
for (int q = 0; q < n_states; q++) // {all q} --> S_a
{
bool skipQ = false;
if (post_len[a, q] > 0) /// q is in S_a
{
for (int r = 0; r < post_len[a, q]; r++)
{
if (fsim[p, post[a, q, r]]) // q is in pre_a(sim(p))
{
skipQ = true;
break;
}
//continue Sharpen_S_a; // skip q
}
if (!skipQ)
{
remove[a, p, remove_len[a, p]++] = q;
}
}
}
if (remove_len[a, p] > 0)
{
todo[todo_len++] = a * n_states + p;
}
}
}
}
int[] swap = new int[n_states];
int swap_len = 0;
bool using_swap = false;
while (todo_len > 0)
{
todo_len--;
int v = todo[todo_len] % n_states;
int a = todo[todo_len] / n_states;
int len = (using_swap ? swap_len : remove_len[a, v]);
remove_len[a, v] = 0;
for (int j = 0; j < pre_len[a, v]; j++)
{
int u = pre[a, v, j];
for (int i = 0; i < len; i++)
{
int w = (using_swap ? swap[i] : remove[a, v, i]);
if (fsim[u, w])
{
fsim[u, w] = false;
for (int b = 0; b < n_symbols; b++)
{
if (pre_len[b, u] > 0)
{
//Sharpen_pre_b_w:
for (int k = 0; k < pre_len[b, w]; k++)
{
bool skipww = false;
int ww = pre[b, w, k];
for (int r = 0; r < post_len[b, ww]; r++)
{
if (fsim[u, post[b, ww, r]]) // ww is in pre_b(sim(u))
//continue Sharpen_pre_b_w; // skip ww
{
skipww = true;
break;
}
}
if (!skipww)
{
if (b == a && u == v && !using_swap)
{
swap[swap_len++] = ww;
}
else
{
if (remove_len[b, u] == 0)
{
todo[todo_len++] = b * n_states + u;
}
remove[b, u, remove_len[b, u]++] = ww;
}
}
}
}
}
} //End of if(fsim[u][w])
}
}
if (swap_len > 0)
{
if (!using_swap)
{
todo[todo_len++] = a * n_states + v;
using_swap = true;
}
else
{
swap_len = 0;
using_swap = false;
}
}
}
//HashSet<Pair<FAState, FAState>> FSim2 = new HashSet<Pair<FAState, FAState>>();
//for (int p = 0; p < n_states; p++)
// for (int q = 0; q < n_states; q++)
// if (fsim[p, q]) // q is in sim(p), q simulates p
// FSim2.Add(new Pair<FAState, FAState>(states[p], states[q]));
Dictionary <string, HashSet <FAState> > Fsim3 = new Dictionary <string, HashSet <FAState> >();
for (int p = 0; p < n_states; p++)
{
for (int q = 0; q < n_states; q++)
{
if (fsim[p, q]) // q is in sim(p), q simulates p
{
//FSim2.Add(new Pair<FAState, FAState>(states[p], states[q]));
HashSet <FAState> list = null;
if (Fsim3.TryGetValue(states[p].ID, out list))
{
list.Add(states[q]);
}
else
{
list = new HashSet <FAState>();
Fsim3.Add(states[p].ID, list);
}
}
}
}
return(Fsim3);
}
public InclusionOpt(Automata system, Automata spec){
this.spec=spec;
this.system=system;
}
public static void TraceInclusionCheck(ConfigurationBase currentImpl, Automata spec, VerificationOutput VerificationOutput)
{
FAState[] states = spec.States.Values.ToArray();
//bool[] isFinal = new bool[states.Length];
bool[,] fsim = new bool[states.Length, states.Length];
// sim[u][v]=true iff v in sim(u) iff v simulates u
//for (int i = 0; i < states.Length; i++)
//{
// isFinal[i] = spec.F.Contains(states[i]);
//}
for (int i = 0; i < states.Length; i++)
{
for (int j = i; j < states.Length; j++)
{
fsim[i, j] = states[j].covers(states[i]); //(!isFinal[i] || isFinal[j]) &&
fsim[j, i] = states[i].covers(states[j]); //(isFinal[i] || !isFinal[j]) &&
}
}
Dictionary <string, HashSet <FAState> > rel_spec = FastFSimRelNBW(spec, fsim);
StringHashTable Visited = new StringHashTable(Ultility.Ultility.MC_INITIAL_SIZE);
List <ConfigurationBase> toReturn = new List <ConfigurationBase>();
Stack <ConfigurationBase> pendingImpl = new Stack <ConfigurationBase>(1024);
Stack <NormalizedFAState> pendingSpec = new Stack <NormalizedFAState>(1024);
//The following are for identifying a counterexample trace.
Stack <int> depthStack = new Stack <int>(1024);
depthStack.Push(0);
List <int> depthList = new List <int>(1024);
//The above are for identifying a counterexample trace.
//implementation initial state
pendingImpl.Push(currentImpl);
//specification initial state
NormalizedFAState currentSpec = new NormalizedFAState(spec.InitialState, rel_spec);
#if TEST
pendingSpec.Push(currentSpec.TauReachable());
#else
pendingSpec.Push(currentSpec);
#endif
while (pendingImpl.Count > 0)
{
currentImpl = pendingImpl.Pop();
currentSpec = pendingSpec.Pop();
string ID = currentImpl.GetID() + Constants.SEPARATOR + currentSpec.GetID();
if (Visited.ContainsKey(ID))
{
continue;
}
Visited.Add(ID);
//The following are for identifying a counterexample trace.
int depth = depthStack.Pop();
while (depth > 0 && depthList[depthList.Count - 1] >= depth)
{
int lastIndex = depthList.Count - 1;
depthList.RemoveAt(lastIndex);
toReturn.RemoveAt(lastIndex);
}
toReturn.Add(currentImpl);
depthList.Add(depth);
//If the specification has no corresponding state, then it implies that the trace is allowed by the
//implementation but not the specification -- which means trace-refinement is failed.
if (currentSpec.States.Count == 0)
{
VerificationOutput.NoOfStates = Visited.Count;
VerificationOutput.CounterExampleTrace = toReturn;
VerificationOutput.VerificationResult = VerificationResultType.INVALID;
return;
}
ConfigurationBase[] nextImpl = currentImpl.MakeOneMove();
VerificationOutput.Transitions += nextImpl.Length;
for (int k = 0; k < nextImpl.Length; k++)
{
ConfigurationBase next = nextImpl[k];
if (next.Event != Constants.TAU)
{
NormalizedFAState nextSpec = currentSpec.Next(next.Event, rel_spec);
pendingImpl.Push(next);
pendingSpec.Push(nextSpec);
depthStack.Push(depth + 1);
}
else
{
pendingImpl.Push(next);
pendingSpec.Push(currentSpec);
depthStack.Push(depth + 1);
}
}
}
VerificationOutput.NoOfStates = Visited.Count;
VerificationOutput.VerificationResult = VerificationResultType.VALID;
//return null;
}
private bool lasso_finding_test(HashSet<Arc> g, HashSet<Arc> h, int init){
if(!Head.ContainsKey(g.ToString())){
HashSet<int> H=new HashSet<int>();
foreach (Arc arc_g in g)
{
if(arc_g.From==init){
H.Add(arc_g.To);
}
}
Head.Add(g.ToString(), H);
}
if(!Tail.ContainsKey(h.ToString())){
Automata fa=new Automata();
OneToOneTreeMap<int,cav2010.automata.FAState> st=new OneToOneTreeMap<int,FAState>();
foreach (Arc arc_h in h)
{
if(!st.containsKey(arc_h.From))
st.put(arc_h.From, fa.createState());
if(!st.containsKey(arc_h.To))
st.put(arc_h.To, fa.createState());
fa.addTransition(st.getValue(arc_h.From), st.getValue(arc_h.To), arc_h.Label?"1":"0");
}
SCC s=new SCC(fa);
HashSet<int> T=new HashSet<int>();
foreach (FAState state in s.getResult())
{
T.Add(st.getKey(state));
}
int TailSize=0;
HashSet<Arc> isolatedArcs=h;
while(TailSize!=T.Count){
TailSize = T.Count;
HashSet<Arc> isolatedArcsTemp=new HashSet<Arc>();
foreach (Arc arc in isolatedArcs)
{
if(!T.Contains(arc.To)){
isolatedArcsTemp.Add(arc);
}else{
T.Add(arc.From);
}
}
isolatedArcs=isolatedArcsTemp;
}
Tail.Add(h.ToString(), T);
}
HashSet<int> intersection = new HashSet<int>(Head[g.ToString()]);
//intersection.retainAll(Tail[h.ToString()]);
intersection.IntersectWith(Tail[h.ToString()]);
//if(debug){
// if(intersection.isEmpty()){
// //debug("g_graph:"+g+", Head: "+Head.get(g.ToString()));
// //debug("h_graph:"+h+", Tail: "+Tail.get(h.ToString()));
// }
//}
return intersection.Count > 0;
}
