private bool NextStateSimulated(HashSet <Pair <FAState, FAState> > sim, FiniteAutomaton omega, FAState p, FAState q)
{
foreach (KeyValuePair <string, HashSet <FAState> > symbol_it in p.next)
{
String a = symbol_it.Key;
if (symbol_it.Value == null)
{
return(false);
}
foreach (FAState p_next in symbol_it.Value)
{
bool hasSimulatingState = false;
foreach (FAState q_next in q.next[a])
{
if (sim.Contains(new Pair <FAState, FAState>(p_next, q_next)))
{
hasSimulatingState = true;
break;
}
}
if (!hasSimulatingState)
{
return(false);
}
}
}
return(true);
}
public void Check10Returns2()
{
var finalStates = new List <State>
{
State.S0,
State.S1,
State.S2
};
var finiteAutomaton = new FiniteAutomaton(State.S0, finalStates);
finiteAutomaton.CreateTransition(State.S0, 0, State.S0);
finiteAutomaton.CreateTransition(State.S0, 1, State.S1);
finiteAutomaton.CreateTransition(State.S1, 0, State.S2);
finiteAutomaton.CreateTransition(State.S1, 1, State.S0);
finiteAutomaton.CreateTransition(State.S2, 0, State.S1);
finiteAutomaton.CreateTransition(State.S2, 1, State.S2);
var input = "10";
bool result = finiteAutomaton.ProcessInput(input);
Assert.IsTrue(result, "Resulting state of input " + input + "should be part of the set of final states");
Assert.AreEqual(finiteAutomaton.GetCurrentState(), State.S2, "Remainder of " + input + " should be 2");
finiteAutomaton.ResetState();
Assert.AreEqual(finiteAutomaton.GetCurrentState(), State.S0, "FSA should be reset back to state 0");
}
private bool PreStateSimulated(HashSet <Pair <FAState, FAState> > sim, FiniteAutomaton omega, FAState p, FAState q)
{
foreach (KeyValuePair <string, HashSet <FAState> > keyValuePair in p.pre)
{
String a = keyValuePair.Key;
if (keyValuePair.Value == null)
{
return(false);
}
foreach (FAState p_pre in keyValuePair.Value)
{
bool hasSimulatingState = false;
foreach (FAState q_pre in q.pre[a])
{
if (sim.Contains(new Pair <FAState, FAState>(p_pre, q_pre)))
{
hasSimulatingState = true;
break;
}
}
if (!hasSimulatingState)
{
return(false);
}
}
}
return(true);
}
/**
* Compute backward simulation relation of a Buchi automaton
* @param omega: a Buchi automaton
* @param BSim: the maximal bound of simulation relation
*
* @return maximal simulation relation on states of the input automaton with BSim
*/
public HashSet <Pair <FAState, FAState> > BSimRelNBW(FiniteAutomaton omega, HashSet <Pair <FAState, FAState> > BSim)
{
HashSet <Pair <FAState, FAState> > nextBSim = new HashSet <Pair <FAState, FAState> >();
bool changed = true;
while (changed)
{
changed = false;
foreach (Pair <FAState, FAState> pair in BSim)
{
if (PreStateSimulated(BSim, omega, pair.Left, pair.Right))
{
nextBSim.Add(new Pair <FAState, FAState>(pair.Left, pair.Right));
}
else
{
changed = true;
}
}
BSim = nextBSim;
nextBSim = new HashSet <Pair <FAState, FAState> >();
}
return(BSim);
}
/**
* Simplify a finite automaton by merging simulation equivalent states
* @param fa: a finite automaton
* @param Sim: some simulation rel_specation over states in the spec automaton
*
* @return an equivalent finite automaton
*/
private FiniteAutomaton quotient(FiniteAutomaton fa, HashSet <Pair <FAState, FAState> > rel)
{
FiniteAutomaton result = new FiniteAutomaton();
Dictionary <FAState, FAState> map = new Dictionary <FAState, FAState>();
Dictionary <FAState, FAState> reducedMap = new Dictionary <FAState, FAState>();
foreach (FAState state in fa.states)
{
map.Add(state, state);
foreach (FAState state2 in fa.states)
{
if (rel.Contains(new Pair <FAState, FAState>(state, state2)) &&
rel.Contains(new Pair <FAState, FAState>(state2, state)))
{
map.Add(state, state2);
}
}
}
FAState init = result.createState();
reducedMap.Add(map[fa.InitialState], init);
result.InitialState = init;
foreach (FAState state in fa.states)
{
if (!reducedMap.ContainsKey(map[state]))
{
reducedMap.Add(map[state], result.createState());
}
if (fa.F.Contains(state))
{
result.F.Add(reducedMap[map[state]]);
}
foreach (KeyValuePair <string, HashSet <FAState> > sym_it in state.next)
{
String sym = sym_it.Key;
foreach (FAState to in sym_it.Value)
{
if (!reducedMap.ContainsKey(map[to]))
{
reducedMap.Add(map[to], result.createState());
}
result.addTransition(reducedMap[map[state]], reducedMap[map[to]], sym);
}
}
}
HashSet <Pair <FAState, FAState> > newrel_spec = new HashSet <Pair <FAState, FAState> >();
foreach (Pair <FAState, FAState> sim in rel)
{
newrel_spec.Add(new Pair <FAState, FAState>(reducedMap[map[sim.Left]], reducedMap[map[sim.Right]]));
}
rel.Clear();
rel = new HashSet <Pair <FAState, FAState> >(newrel_spec);
return(result);
}
public void ConvertToDFA()
{
AutomatonFromViewModel();
ResetStates();
automaton = automaton.ToDFA();
ViewModelFromAutomaton();
}
public void Minimize()
{
AutomatonFromViewModel();
ResetStates();
automaton = automaton.ToMinimizedDFA();
ViewModelFromAutomaton();
}
public SCC(FiniteAutomaton fa)
{
this.fa = fa;
foreach (FAState st in fa.states)
{
if (!v_index.ContainsKey(st.id))
{
tarjan(st);
}
}
}
////UPGRADE_ISSUE: The following fragment of code could not be parsed and was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1156'"
//public Set < FAState > getNext(String a)
////UPGRADE_ISSUE: The following fragment of code could not be parsed and was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1156'"
//public Set < FAState > getPre(String a)
public virtual void addNext(System.String a, FAState b, FiniteAutomaton auto)
{
if (!next.ContainsKey(a))
{
//UPGRADE_ISSUE: The following fragment of code could not be parsed and was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1156'"
HashSet <FAState> S = new HashSet <FAState>();
S.Add(b);
next.Add(a, S);
}
else
{
next[a].Add(b);
}
}
public bool inclusionTest()
{
this.computeSim();
if (quotient_var)
{
spec = quotient(spec, rel_spec);
system = quotient(system, rel_system);
}
//debug("Spec.:");
//debug(spec.ToString());
//debug("Sim="+showSim(rel_spec));
//debug("System:");
//debug(system.ToString());
//debug("Sim="+showSim(rel_system));
return(included());
}
public void CheckResultStateNotFinal()
{
var finalStates = new List <State>
{
State.S0,
};
var finiteAutomaton = new FiniteAutomaton(State.S0, finalStates);
finiteAutomaton.CreateTransition(State.S0, 1, State.S1);
var input = "1";
bool result = finiteAutomaton.ProcessInput(input);
Assert.IsFalse(result, "1 is not in the set of final states, therefore result should be false");
finiteAutomaton.ResetState();
Assert.AreEqual(finiteAutomaton.GetCurrentState(), State.S0, "FSA should be reset back to state 0");
}
public static void Main(string[] args)
{
try
{
var grammar = RegularGrammar.FromPath("");
var automaton = new FiniteAutomaton(grammar);
automaton.Determine();
automaton.Print();
foreach (var token in SingletonAlphabet.Instance.Tokens)
{
Console.Write(token.Value);
}
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
private static void NFAToDFA()
{
var alphabet = new[] { '0', '1' };
int statesCount = 4,
initialIndex = 0;
int[] acceptingIndexes = new[] { 2, 3 };
var transitions = new[] { new Transition(0, 'ε', 2),
new Transition(0, '0', 1),
new Transition(1, '1', 1),
new Transition(1, '1', 3),
new Transition(2, 'ε', 1),
new Transition(2, '0', 3),
new Transition(3, '0', 2) };
var nfa = new FiniteAutomaton(statesCount, alphabet, transitions, initialIndex, acceptingIndexes);
var dfa = nfa.ToDFA();
int dfaStatesCount = dfa.StatesCount;
int dfaAcceptingsCount = dfa.AcceptingIndexes.Count();
Debug.Assert(dfaStatesCount == 5);
Debug.Assert(dfaAcceptingsCount == 4);
}
public void EvenZeroesTest()
{
var q = new States(2);
var f = new AcceptingStates(q[0]);
var tf = new TransitionFunction()
{
new Transition(q[0], '1', q[0]),
new Transition(q[0], '0', q[1]),
new Transition(q[1], '0', q[0]),
new Transition(q[1], '1', q[1])
};
var m = new FiniteAutomaton(q, Alphabet.Binary, tf, q[0], f);
Assert.True(m.Run("1111"));
Assert.True(m.Run("1100"));
Assert.True(m.Run("10101"));
Assert.True(m.Run("00"));
Assert.True(m.Run("10111111110"));
Assert.False(m.Run("101"));
Assert.False(m.Run("000"));
Assert.False(m.Run("11111011111"));
}
private static void Main()
{
Alphabet a = new Alphabet(new List <object> {
'a', 'b', 'c'
});
FiniteAutomaton automaton = new FiniteAutomaton(a);
State s0 = automaton.AddState("0");
State s1 = automaton.AddState("1");
State s2 = automaton.AddState("2");
s0.AddFollow('a', s2);
s0.AddFollow('c', s1);
s1.AddFollow('a', s2);
s1.AddFollow('c', s1);
s2.AddFollow('b', s0);
automaton.AddEndstate(s2);
FiniteAutomaton minimized = automaton.Minimize();
Console.WriteLine(automaton.GetTable() + "\n");
Console.WriteLine(minimized.GetTable() + "\n");
}
private static void NFAToDFA()
{
var alphabet = new[] { '0', '1' };
int statesCount = 4,
initialIndex = 0;
int[] acceptingIndexes = new[] { 2, 3 };
var transitions = new[] { new Transition(0, 'ε', 2),
new Transition(0, '0', 1),
new Transition(1, '1', 1),
new Transition(1, '1', 3),
new Transition(2, 'ε', 1),
new Transition(2, '0', 3),
new Transition(3, '0', 2) };
var nfa = new FiniteAutomaton(statesCount, alphabet, transitions, initialIndex, acceptingIndexes);
var dfa = nfa.ToDFA();
int dfaStatesCount = dfa.StatesCount;
int dfaAcceptingsCount = dfa.AcceptingIndexes.Count();
Debug.Assert(dfaStatesCount == 5);
Debug.Assert(dfaAcceptingsCount == 4);
}
private void AutomatonFromViewModel()
{
var characters = new List <char>(Characters.Count);
foreach (var characterVM in Characters)
{
if (characterVM.Character != epsilon)
{
characters.Add(characterVM.Character);
}
}
var alphabet = characters.ToArray();
var transitions = new List <Transition>(Transitions.Count);
foreach (var transition in Transitions)
{
int currentStateIndex = IndexFromID(transition.CurrentStateID),
nextStateIndex = IndexFromID(transition.NextStateID);
char character = transition.Character;
transitions.Add(new Transition(currentStateIndex, character, nextStateIndex));
}
List <int> acceptingStateIndexes = new List <int>();
foreach (var state in States)
{
if (state.IsAccepting)
{
acceptingStateIndexes.Add(IndexFromID(state.ID));
}
}
automaton = new FiniteAutomaton(States.Count, alphabet, transitions.ToArray(),
InitialStateIndex, acceptingStateIndexes.ToArray());
}
private void AutomatonFromViewModel()
{
var characters = new List<char>(Characters.Count);
foreach (var characterVM in Characters)
if (characterVM.Character != epsilon)
characters.Add(characterVM.Character);
var alphabet = characters.ToArray();
var transitions = new List<Transition>(Transitions.Count);
foreach (var transition in Transitions)
{
int currentStateIndex = IndexFromID(transition.CurrentStateID),
nextStateIndex = IndexFromID(transition.NextStateID);
char character = transition.Character;
transitions.Add(new Transition(currentStateIndex, character, nextStateIndex));
}
List<int> acceptingStateIndexes = new List<int>();
foreach (var state in States)
if (state.IsAccepting)
acceptingStateIndexes.Add(IndexFromID(state.ID));
automaton = new FiniteAutomaton(States.Count, alphabet, transitions.ToArray(),
InitialStateIndex, acceptingStateIndexes.ToArray());
}
public void Minimize()
{
AutomatonFromViewModel();
ResetStates();
automaton = automaton.ToMinimizedDFA();
ViewModelFromAutomaton();
}
public void ConvertToDFA()
{
AutomatonFromViewModel();
ResetStates();
automaton = automaton.ToDFA();
ViewModelFromAutomaton();
}
private void InitializeParsers()
{
#region Grammar
Grammar = new Grammar();
//Grammar.Load();
var finiteAutomaton = new FiniteAutomaton();
dynamic parser = ParserManager.InitializeParser(
"GrammarParser.dll",
"GrammarParser.GrammarParser",
Configuration.Path.GrammarInputXml,
Configuration.Parser.ShouldIncludeTerminalsFromInsideOfDefinedTokens,
Configuration.Parser.ShouldConvertLeftRecursionToRight);
Grammar.Parse(parser);
var controlTerminals = Grammar.Nodes.Terminals.Where(n => n.IsControl).Select(n => n.Name).ToArray();
Editor.DocumentOpened += (doc) => mainWindow.ScriptEditor.ApplyTextColor(doc, controlTerminals, Color.FromRgb(0, 0, 255));
// Parse finite automaton
parser = ParserManager.InitializeParser(
"FiniteAutomatonParser.dll",
"FiniteAutomatonParser.FiniteAutomatonParser",
Grammar.ClassTable,
Grammar.Nodes,
Grammar.UnclassifiedTerminals);
finiteAutomaton.Parse(parser);
//finiteAutomaton.Save();
//finiteAutomaton.Load();
SaveGrammarTxt(Grammar);
SaveGrammarFactorizedTxt(Grammar);
//Grammar.Save();
#endregion
ParserManager.InitializeParser(
"SyntaxRecursiveParser.dll",
"SyntaxRecursiveParser.SyntaxRecursiveParser",
true,
Grammar.ClassTable.TokenClasses.Forward(Grammar.ClassTable.UndefinedTokenClassName),
Grammar.Nodes.Axiom);
//PushdownAutomaton pushdownAutomaton = new PushdownAutomaton();
//pushdownAutomaton.Load();
//ParserManager.InitializeParser(
// "SyntaxPushdownParser.dll",
// "SyntaxPushdownParser.SyntaxPushdownParser",
// pushdownAutomaton,
// Grammar.Nodes,
// true,
// Grammar.ClassTable.TokenClasses.Forward(Grammar.ClassTable.UndefinedTokenClassName));
ParserManager.InitializeParser(
"TokenParser.dll",
"TokenParser.TokenParser",
Grammar.Nodes,
Grammar.ClassTable,
finiteAutomaton);
ParserManager.InitializeParser(
"SemanticParser.dll",
"SemanticParser.SemanticParser",
Grammar.ClassTable,
Grammar.Nodes);
#region Predescence
//Create predescence table
//parser = ParserManager.InitializeParser(
// "PredescenceTableParser.dll",
// "PredescenceTableParser.PredescenceTableParser",
// Grammar.Nodes);
//var predescenceTable = new PredescenceTable();
//predescenceTable.Parse(parser);
//var f = (Func<IEnumerable<IParsedToken>>)(() => ParsedTokens);
//parser = ParserManager.InitializeParser(
// "SyntaxPredescenceTableParserWithPOLIZ.dll",
// "SyntaxPredescenceTableParser.SyntaxPredescenceTableParser",
// predescenceTable.Nodes,
// f,
// Grammar.Nodes,
// Grammar.Nodes.Axiom);
//parser = ParserManager.InitializeParser(
// "SyntaxPredescenceTableParser.dll",
// "SyntaxPredescenceTableParser.SyntaxPredescenceTableParser",
// predescenceTable.Nodes,
// f,
// Grammar.Nodes,
// Grammar.Nodes.Axiom);
//SavePredescenceTableTxt(predescenceTable, Grammar);
#endregion
ParserManager.InitializeParser(
"RpnParser.dll",
"RpnParser.RpnParser",
Grammar.Nodes,
Configuration.Path.StatementRulesXml);
}
public Determinizer(FiniteAutomaton automaton)
{
this.automaton = automaton;
}
private FiniteAutomaton Concat(FiniteAutomaton operand1, FiniteAutomaton operand2)
{
throw new NotImplementedException();
}
private FiniteAutomaton Star(FiniteAutomaton operand)
{
throw new NotImplementedException();
}
public HashSet <Pair <FAState, FAState> > FastFSimRelNBW(FiniteAutomaton omega, bool[,] fsim)
{
//implement the HHK algorithm
int n_states = omega.states.Count;
int n_symbols = omega.alphabet.Count;
FAState[] states = omega.states.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].next[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]));
}
}
}
return(FSim2);
}
public AntMover(FiniteAutomaton automation, AppleField field)
{
Ant = automation;
_originalField = field;
Restart();
}
public InclusionAnti(FiniteAutomaton system, FiniteAutomaton spec)
{
this.spec = spec;
this.system = system;
}
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()))
{
FiniteAutomaton fa = new FiniteAutomaton();
OneToOneTreeMap <int, 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);
}
/**
* Compute forward simulation relation of a Buchi automaton using Henzinger, Henzinger, Kopke FOCS 1995
* @param omega: a Buchi automaton
* @param FSim: maximum simulation relation
*
* @return simulation relation on states of the input automaton
*/
public HashSet <Pair <FAState, FAState> > FastFSimRelNBW2(FiniteAutomaton omega, HashSet <Pair <FAState, FAState> > FSim)
{
Dictionary <State_Label, HashSet <FAState> > Remove = new Dictionary <State_Label, HashSet <FAState> >();
Dictionary <String, int> symMap = new Dictionary <String, int>();
int [,,] counter = new int[omega.states.Count, omega.states.Count, omega.alphabet.Count];
for (int i = 0; i < omega.states.Count; i++)
{
for (int j = 0; j < omega.states.Count; j++)
{
for (int k = 0; k < omega.alphabet.Count; k++)
{
counter[i, j, k] = 0;
}
}
}
foreach (FAState v in omega.states)
{
HashSet <String> sym_it = omega.getAllTransitionSymbols();
int sym_index = 0;
foreach (string sym in sym_it)
{
symMap.Add(sym, sym_index);
sym_index++;
HashSet <FAState> allStates = new HashSet <FAState>(omega.states);
Remove.Add(new State_Label(v, sym), allStates);
}
}
foreach (Pair <FAState, FAState> cur in FSim)
{
FAState v = cur.Left;
FAState sim_v = cur.Right;
foreach (KeyValuePair <string, HashSet <FAState> > symbol_it in sim_v.pre)
{
String symbol = symbol_it.Key;
foreach (FAState from in symbol_it.Value)
{
State_Label label = new State_Label(v, symbol);
if (Remove.ContainsKey(label))
{
Remove[label].Remove(from);
}
counter[from.id, v.id, symMap[symbol]]++;
}
}
}
while (Remove.Count > 0)
{
Dictionary <State_Label, HashSet <FAState> > .Enumerator iterator = Remove.GetEnumerator();
State_Label key = iterator.Current.Key;
HashSet <FAState> remove = iterator.Current.Value;
Remove.Remove(key);
FAState v = key.State;
String symbol = key.Label;
if (!v.pre.ContainsKey(symbol))
{
continue;
}
foreach (FAState u in v.pre[symbol])
{
foreach (FAState w in remove)
{
if (FSim.Contains(new Pair <FAState, FAState>(u, w)))
{
FSim.Remove(new Pair <FAState, FAState>(u, w));
foreach (KeyValuePair <string, HashSet <FAState> > symbol_it in w.pre)
{
String w_symbol = symbol_it.Key;
foreach (FAState w_pre in symbol_it.Value)
{
counter[w_pre.id, u.id, symMap[w_symbol]]--;
if (counter[w_pre.id, u.id, symMap[w_symbol]] == 0)
{
State_Label label = new State_Label(u, w_symbol);
if (!Remove.ContainsKey(label))
{
HashSet <FAState> emptyStates = new HashSet <FAState>();
Remove.Add(label, emptyStates);
}
Remove[label].Add(w_pre);
}
}
}
}
}
}
}
return(FSim);
}
