/// <summary>
/// Minimizes the given automaton using Huffman's algorithm.
/// </summary>
/// <param name="a">The automaton.</param>
internal static void MinimizeHuffman(Automaton a)
{
a.Determinize();
a.Totalize();
HashSet <State> ss = a.GetStates();
var transitions = new Transition[ss.Count][];
State[] states = ss.ToArray();
var mark = new List <List <bool> >();
var triggers = new List <List <HashSet <IntPair> > >();
foreach (State t in states)
{
var v = new List <HashSet <IntPair> >();
Initialize(ref v, states.Length);
triggers.Add(v);
}
// Initialize marks based on acceptance status and find transition arrays.
for (int n1 = 0; n1 < states.Length; n1++)
{
states[n1].Number = n1;
transitions[n1] = states[n1].GetSortedTransitions(false).ToArray();
for (int n2 = n1 + 1; n2 < states.Length; n2++)
{
if (states[n1].Accept != states[n2].Accept)
{
mark[n1][n2] = true;
}
}
}
// For all pairs, see if states agree.
for (int n1 = 0; n1 < states.Length; n1++)
{
for (int n2 = n1 + 1; n2 < states.Length; n2++)
{
if (!mark[n1][n2])
{
if (MinimizationOperations.StatesAgree(transitions, mark, n1, n2))
{
MinimizationOperations.AddTriggers(transitions, triggers, n1, n2);
}
else
{
MinimizationOperations.MarkPair(mark, triggers, n1, n2);
}
}
}
}
// Assign equivalence class numbers to states.
int numclasses = 0;
foreach (State t in states)
{
t.Number = -1;
}
for (int n1 = 0; n1 < states.Length; n1++)
{
if (states[n1].Number == -1)
{
states[n1].Number = numclasses;
for (int n2 = n1 + 1; n2 < states.Length; n2++)
{
if (!mark[n1][n2])
{
states[n2].Number = numclasses;
}
}
numclasses++;
}
}
// Make a new state for each equivalence class.
var newstates = new State[numclasses];
for (int n = 0; n < numclasses; n++)
{
newstates[n] = new State();
}
// Select a class representative for each class and find the new initial state.
for (int n = 0; n < states.Length; n++)
{
newstates[states[n].Number].Number = n;
if (states[n] == a.Initial)
{
a.Initial = newstates[states[n].Number];
}
}
// Build transitions and set acceptance.
for (int n = 0; n < numclasses; n++)
{
State s = newstates[n];
s.Accept = states[s.Number].Accept;
foreach (Transition t in states[s.Number].Transitions)
{
s.Transitions.Add(new Transition(t.Min, t.Max, newstates[t.To.Number]));
}
}
a.RemoveDeadTransitions();
}
internal static void MinimizeHopcroft(Automaton a)
{
a.Determinize();
IList <Transition> tr = a.Initial.Transitions;
if (tr.Count == 1)
{
Transition t = tr[0];
if (t.To == a.Initial && t.Min == char.MinValue && t.Max == char.MaxValue)
{
return;
}
}
a.Totalize();
// Make arrays for numbered states and effective alphabet.
HashSet <State> ss = a.GetStates();
var states = new State[ss.Count];
int number = 0;
foreach (State q in ss)
{
states[number] = q;
q.Number = number++;
}
char[] sigma = a.GetStartPoints();
// Initialize data structures.
var reverse = new List <List <LinkedList <State> > >();
foreach (State s in states)
{
var v = new List <LinkedList <State> >();
Initialize(ref v, sigma.Length);
reverse.Add(v);
}
var reverseNonempty = new bool[states.Length, sigma.Length];
var partition = new List <LinkedList <State> >();
Initialize(ref partition, states.Length);
var block = new int[states.Length];
var active = new StateList[states.Length, sigma.Length];
var active2 = new StateListNode[states.Length, sigma.Length];
var pending = new LinkedList <IntPair>();
var pending2 = new bool[sigma.Length, states.Length];
var split = new List <State>();
var split2 = new bool[states.Length];
var refine = new List <int>();
var refine2 = new bool[states.Length];
var splitblock = new List <List <State> >();
Initialize(ref splitblock, states.Length);
for (int q = 0; q < states.Length; q++)
{
splitblock[q] = new List <State>();
partition[q] = new LinkedList <State>();
for (int x = 0; x < sigma.Length; x++)
{
reverse[q][x] = new LinkedList <State>();
active[q, x] = new StateList();
}
}
// Find initial partition and reverse edges.
foreach (State qq in states)
{
int j = qq.Accept ? 0 : 1;
partition[j].AddLast(qq);
block[qq.Number] = j;
for (int x = 0; x < sigma.Length; x++)
{
char y = sigma[x];
State p = qq.Step(y);
reverse[p.Number][x].AddLast(qq);
reverseNonempty[p.Number, x] = true;
}
}
// Initialize active sets.
for (int j = 0; j <= 1; j++)
{
for (int x = 0; x < sigma.Length; x++)
{
foreach (State qq in partition[j])
{
if (reverseNonempty[qq.Number, x])
{
active2[qq.Number, x] = active[j, x].Add(qq);
}
}
}
}
// Initialize pending.
for (int x = 0; x < sigma.Length; x++)
{
int a0 = active[0, x].Size;
int a1 = active[1, x].Size;
int j = a0 <= a1 ? 0 : 1;
pending.AddLast(new IntPair(j, x));
pending2[x, j] = true;
}
// Process pending until fixed point.
int k = 2;
while (pending.Count > 0)
{
IntPair ip = pending.RemoveAndReturnFirst();
int p = ip.N1;
int x = ip.N2;
pending2[x, p] = false;
// Find states that need to be split off their blocks.
for (StateListNode m = active[p, x].First; m != null; m = m.Next)
{
foreach (State s in reverse[m.State.Number][x])
{
if (!split2[s.Number])
{
split2[s.Number] = true;
split.Add(s);
int j = block[s.Number];
splitblock[j].Add(s);
if (!refine2[j])
{
refine2[j] = true;
refine.Add(j);
}
}
}
}
// Refine blocks.
foreach (int j in refine)
{
if (splitblock[j].Count < partition[j].Count)
{
LinkedList <State> b1 = partition[j];
LinkedList <State> b2 = partition[k];
foreach (State s in splitblock[j])
{
b1.Remove(s);
b2.AddLast(s);
block[s.Number] = k;
for (int c = 0; c < sigma.Length; c++)
{
StateListNode sn = active2[s.Number, c];
if (sn != null && sn.StateList == active[j, c])
{
sn.Remove();
active2[s.Number, c] = active[k, c].Add(s);
}
}
}
// Update pending.
for (int c = 0; c < sigma.Length; c++)
{
int aj = active[j, c].Size;
int ak = active[k, c].Size;
if (!pending2[c, j] && 0 < aj && aj <= ak)
{
pending2[c, j] = true;
pending.AddLast(new IntPair(j, c));
}
else
{
pending2[c, k] = true;
pending.AddLast(new IntPair(k, c));
}
}
k++;
}
foreach (State s in splitblock[j])
{
split2[s.Number] = false;
}
refine2[j] = false;
splitblock[j].Clear();
}
split.Clear();
refine.Clear();
}
// Make a new state for each equivalence class, set initial state.
var newstates = new State[k];
for (int n = 0; n < newstates.Length; n++)
{
var s = new State();
newstates[n] = s;
foreach (State q in partition[n])
{
if (q == a.Initial)
{
a.Initial = s;
}
s.Accept = q.Accept;
s.Number = q.Number; // Select representative.
q.Number = n;
}
}
// Build transitions and set acceptance.
foreach (State s in newstates)
{
s.Accept = states[s.Number].Accept;
foreach (Transition t in states[s.Number].Transitions)
{
s.Transitions.Add(new Transition(t.Min, t.Max, newstates[t.To.Number]));
}
}
a.RemoveDeadTransitions();
}
/// <summary>
/// Returns a (deterministic) automaton that accepts the complement of the language of the
/// given automaton.
/// </summary>
/// <param name="a">The automaton.</param>
/// <returns>A (deterministic) automaton that accepts the complement of the language of the
/// given automaton.</returns>
/// <remarks>
/// Complexity: linear in number of states (if already deterministic).
/// </remarks>
internal static Automaton Complement(Automaton a)
{
a = a.CloneExpandedIfRequired();
a.Determinize();
a.Totalize();
foreach (State p in a.GetStates())
{
p.Accept = !p.Accept;
}
a.RemoveDeadTransitions();
return a;
}