public DFA make_FA_from_partition(List <List <State> > l)
{
List <State> fa = new List <State>();
for (int i = 0; i < l.Count; i++)
{
State temp = new State("q" + i);
if (l[i][0].isFinal)
{
temp.isFinal = true;
}
foreach (var j in l[i])
{
if (j.isInit)
{
temp.isInit = true;
}
}
fa.Add(temp);
}
List <DeletableTransition> value = new List <DeletableTransition>();
for (int i = 0; i < l.Count; i++)
{
for (int z = 0; z < State.alphabets.Count; z++)
{
if (l[i][0].DTransitions.TryGetValue(State.alphabets[z], out value))
{
for (int j = 0; j < l.Count; j++)
{
for (int t = 0; t < l[j].Count; t++)
{
if (l[j][t].name == value[0].State.name)
{
DeletableTransition temp = new DeletableTransition(new State(fa[j].name));
fa[i].DTransitions.Add(State.alphabets[z], new List <DeletableTransition>()
{
temp
});
}
}
}
}
}
}
State initial = fa[0];;
for (int i = 0; i < fa.Count; i++)
{
if (fa[i].isInit)
{
initial = fa[i];
}
}
return(new DFA(initial, fa));
}
public State Merge(State s, NFA TempNfa)
{
State merged = new State(this.name + s.name);
DeletableTransition MERGED = new DeletableTransition(merged);
if (this.isInit || s.isInit)
{
merged.isInit = true;
}
if (this.isFinal || s.isFinal)
{
merged.isFinal = true;
}
if (this.DTransitions.TryGetValue("", out List <DeletableTransition> value))
{
for (int i = 0; i < value.Count; i++)
{
if (value[i].State.name == s.name || value[i].State.name == this.name)
{
value.RemoveAt(i);
}
}
}
if (s.DTransitions.TryGetValue("", out List <DeletableTransition> value1))
{
for (int i = 0; i < value1.Count; i++)
{
if (value1[i].State.name == this.name || value1[i].State.name == s.name)
{
value.RemoveAt(i);
}
}
}
for (int i = 0; i < State.alphabets.Count; i++)
{
List <DeletableTransition> temp = new List <DeletableTransition>();
if (this.DTransitions.TryGetValue(State.alphabets[i], out value))
{
for (int j = 0; j < value.Count; j++)
{
if (value[j].State.name == this.name || value[j].State.name == s.name)
{
temp.Add(MERGED);
}
else
{
temp.Add(value[j]);
}
}
}
if (s.DTransitions.TryGetValue(State.alphabets[i], out value1))
{
for (int j = 0; j < value1.Count; j++)
{
if (value1[j].State.name == this.name || value1[j].State.name == s.name)
{
temp.Add(MERGED);
}
else
{
temp.Add(value1[j]);
}
}
}
merged.DTransitions.Add(State.alphabets[i], temp);
}
for (int i = 0; i < TempNfa.States.Count; i++)
{
for (int j = 0; j < State.alphabets.Count; j++)
{
if (TempNfa.States[i].DTransitions.TryGetValue(State.alphabets[j], out value))
{
for (int t = 0; t < value.Count; t++)
{
if (value[t].State.name == this.name || value[t].State.name == s.name)
{
value.RemoveAt(t);
value.Add(MERGED);
}
}
}
}
}
return(merged);
}
public DFA CreateEquivalentDFA()
{
NFA TEMP = this.RemoveLambda();
List <ConvertionalState> table = new List <ConvertionalState>();
State trap = new State("trap");
TEMP.States.Add(trap);
ConvertionalState Trap = new ConvertionalState(new List <State>()
{
trap
});
for (int i = 0; i < State.alphabets.Count; i++)
{
Trap.DTransitions.Add(State.alphabets[i], trap.name);
}
List <State> name = new List <State>()
{
TEMP.initialState
};
table.Add(new ConvertionalState(name, true));
for (int i = 0; i < table.Count; i++)
{
for (int j = 0; j < State.alphabets.Count; j++)
{
List <State> transition = new List <State>();
for (int t = 0; t < table[i].name.Count; t++)
{
if (table[i].name[t].DTransitions.TryGetValue(State.alphabets[j], out List <DeletableTransition> value))
{
for (int z = 0; z < value.Count; z++)
{
bool Its_new = true;
for (int x = 0; x < transition.Count; x++)
{
if (value[z].State.name == transition[x].name)
{
Its_new = false;
}
}
if (Its_new)
{
transition.Add(value[z].State);
}
}
}
}
if (transition.Count == 0)
{
table[i].DTransitions.Add(State.alphabets[j], trap.name);
}
else
{
string Name = "";
for (int t = 0; t < transition.Count; t++)
{
Name += transition[t].name;
}
table[i].DTransitions.Add(State.alphabets[j], Name);
}
bool flag = false;
string Value = "";
if (table[i].DTransitions.TryGetValue(State.alphabets[j], out Value))
{
if (Value.Length != 0)
{
for (int t = 0; t < table.Count; t++)
{
string tempname = "";
List <char> c = new List <char>();
for (int z = 0; z < table[t].name.Count; z++)
{
tempname += table[t].name[z].name;
}
for (int z = 0; z < tempname.Length; z++)
{
c.Add(tempname[z]);
}
for (int z = 0; z < c.Count; z++)
{
for (int x = z; x < c.Count; x++)
{
if (c[z] < c[x])
{
char s = c[z];
c[z] = c[x];
c[x] = s;
}
}
}
tempname = "";
for (int z = 0; z < c.Count; z++)
{
tempname += c[z];
}
c = new List <char>();
for (int z = 0; z < Value.Length; z++)
{
c.Add(Value[z]);
}
for (int z = 0; z < c.Count; z++)
{
for (int x = z; x < c.Count; x++)
{
if (c[z] < c[x])
{
char s = c[z];
c[z] = c[x];
c[x] = s;
}
}
}
Value = "";
for (int z = 0; z < c.Count; z++)
{
Value += c[z];
}
if (tempname == Value)
{
flag = true;
break;
}
}
}
}
if (!flag && transition.Count != 0)
{
table.Add(new ConvertionalState(transition));
}
}
}
List <State> dfa = new List <State>();
for (int i = 0; i < table.Count; i++)
{
bool finalSt = false;
string NAME = "";
for (int j = 0; j < table[i].name.Count; j++)
{
NAME += table[i].name[j].name;
if (table[i].name[j].isFinal)
{
finalSt = true;
}
}
if (i == 0)
{
dfa.Add(new State(NAME, true));
}
else
{
dfa.Add(new State(NAME));
}
dfa[dfa.Count - 1].isFinal = finalSt;
}
for (int i = 0; i < table.Count; i++)
{
for (int j = 0; j < State.alphabets.Count; j++)
{
for (int t = 0; t < dfa.Count; t++)
{
if (table[i].DTransitions.TryGetValue(State.alphabets[j], out string value))
{
if (dfa[t].name == value)
{
DeletableTransition tempp = new DeletableTransition(dfa[t]);
dfa[i].DTransitions.Add(State.alphabets[j], new List <DeletableTransition>()
{
tempp
});
}
}
}
}
}
DFA ReDfa = new DFA(dfa[0], dfa);
for (int i = 0; i < ReDfa.States.Count; i++)
{
for (int j = 0; j < State.alphabets.Count - 1; j++)
{
if (!ReDfa.States[i].DTransitions.TryGetValue(State.alphabets[j], out List <DeletableTransition> value))
{
DeletableTransition tempp = new DeletableTransition(trap);
ReDfa.States[i].DTransitions.Add(State.alphabets[j], new List <DeletableTransition> {
tempp
});
}
}
}
return(ReDfa);
}
