DFA minimization

Unreachable states

Given a DFA ${\displaystyle M=(Q,\mathrm{\Sigma },\delta ,q_0,F)}$, a state ${\displaystyle q\in Q}$ is reachable if there exists an input string ${\displaystyle w\in {\mathrm{\Sigma }}^{\ast }}$ that terminates at state q. That is, ${\displaystyle {\delta }^{\ast }(q_0,w)=q}$. A state q is unreachable if it is not a reachable state. In the definition above:

• Q is the set of states,
• ${\displaystyle \mathrm{\Sigma }}$ is the set of input symbols,
• ${\displaystyle \delta :Q\times \mathrm{\Sigma }\to Q}$ is the transition function,
• ${\displaystyle {\delta }^{\ast }:Q\times {\mathrm{\Sigma }}^{\ast }\to Q}$ is the extended transition function,
• ${\displaystyle q_0}$ is the initial state,
• and F is the set of accepting (or final) states.

Reachable states can be obtained with the following algorithm:

Algorithm

Given input (Q, Σ, δ, q₀, F):

1. Place a mark on state q₀.
2. Repeat the following until no previously unmarked states are marked.
   1. For each marked node q and a in Σ, mark δ(q,a).
3. Return the set of marked states.

Assuming an efficient implementation of state sets and operations, this algorithm can be implemented with time complexity ${\displaystyle O(n+m)}$, where ${\displaystyle n}$ is the number of states and ${\displaystyle m}$ is the number of transitions of the input automaton.

Let R be the set of reachable states. The set of unreachable states is ${\displaystyle Q\setminus R}$, that is, the states unmarked by the algorithm. Unreachable states can be removed from the DFA without affecting the language that it accepts.

Nondistinguishable states

The following algorithms present various approaches to merging nondistinguishable states.

Hopcroft's algorithm

One algorithm for merging the nondistinguishable states of a DFA, due to Hopcroft (1971), is based on partition refinement, partitioning the DFA states into groups by their behavior. These groups represent equivalence classes of the Nerode congruence, whereby every two states are equivalent if they have the same behavior for every input sequence. That is, for every two states p₁ and p₂ that belong to the same block of the partition P, and every input word w, the transitions determined by w should always take states p₁ and p₂ to either states that both accept or states that both reject. It should not be possible for w to take p₁ to an accepting state and p₂ to a rejecting state or vice versa.

The following pseudocode describes the form of the algorithm as given by Xu. Alternative forms have also been presented.

<span id="mweg"></span><span class="nc" id="mwew">P</span> <span class="o" id="mwfA">:=</span> <span class="o" id="mwfQ">{</span><span class="nc" id="mwfg">F</span><span class="o" id="mwfw">,</span> <span class="nc" id="mwgA">Q</span> <span class="err" id="mwgQ">\</span> <span class="nc" id="mwgg">F</span><span class="o" id="mwgw">}</span> <span class="nc" id="mwhA">W</span> <span class="o" id="mwhQ">:=</span> <span class="o" id="mwhg">{</span><span class="nc" id="mwhw">F</span><span class="o" id="mwiA">,</span> <span class="nc" id="mwiQ">Q</span> <span class="err" id="mwig">\</span> <span class="nc" id="mwiw">F</span><span class="o" id="mwjA">}</span> <span class="k" id="mwjQ">while</span> <span class="o" id="mwjg">(</span><span class="nc" id="mwjw">W</span> <span class="n" id="mwkA">is</span> <span class="n" id="mwkQ">not</span> <span class="n" id="mwkg">empty</span><span class="o" id="mwkw">)</span> <span class="k" id="mwlA">do</span> <span class="n" id="mwlQ">choose</span> <span class="k" id="mwlg">and</span> <span class="n" id="mwlw">remove</span> <span class="n" id="mwmA">a</span> <span class="n" id="mwmQ">set</span> <span class="nc" id="mwmg">A</span> <span class="n" id="mwmw">from</span> <span class="nc" id="mwnA">W</span> <span class="k" id="mwnQ">for</span> <span class="n" id="mwng">each</span> <span class="n" id="mwnw">c</span> <span class="k" id="mwoA">in</span> <span class="n" id="mwoQ">Σ</span> <span class="k" id="mwog">do</span> <span class="k" id="mwow">let</span> <span class="nc" id="mwpA">X</span> <span class="n" id="mwpQ">be</span> <span class="n" id="mwpg">the</span> <span class="n" id="mwpw">set</span> <span class="k" id="mwqA">of</span> <span class="n" id="mwqQ">states</span> <span class="k" id="mwqg">for</span> <span class="n" id="mwqw">which</span> <span class="n" id="mwrA">a</span> <span class="n" id="mwrQ">transition</span> <span class="n" id="mwrg">on</span> <span class="n" id="mwrw">c</span> <span class="n" id="mwsA">leads</span> <span class="k" id="mwsQ">to</span> <span class="n" id="mwsg">a</span> <span class="n" id="mwsw">state</span> <span class="k" id="mwtA">in</span> <span class="nc" id="mwtQ">A</span> <span class="k" id="mwtg">for</span> <span class="n" id="mwtw">each</span> <span class="n" id="mwuA">set</span> <span class="nc" id="mwuQ">Y</span> <span class="k" id="mwug">in</span> <span class="nc" id="mwuw">P</span> <span class="k" id="mwvA">for</span> <span class="n" id="mwvQ">which</span> <span class="nc" id="mwvg">X</span> <span class="err" id="mwvw">∩</span> <span class="nc" id="mwwA">Y</span> <span class="n" id="mwwQ">is</span> <span class="n" id="mwwg">nonempty</span> <span class="k" id="mwww">and</span> <span class="nc" id="mwxA">Y</span> <span class="err" id="mwxQ">\</span> <span class="nc" id="mwxg">X</span> <span class="n" id="mwxw">is</span> <span class="n" id="mwyA">nonempty</span> <span class="k" id="mwyQ">do</span> <span class="n" id="mwyg">replace</span> <span class="nc" id="mwyw">Y</span> <span class="k" id="mwzA">in</span> <span class="nc" id="mwzQ">P</span> <span class="n" id="mwzg">by</span> <span class="n" id="mwzw">the</span> <span class="n" id="mw0A">two</span> <span class="n" id="mw0Q">sets</span> <span class="nc" id="mw0g">X</span> <span class="err" id="mw0w">∩</span> <span class="nc" id="mw1A">Y</span> <span class="k" id="mw1Q">and</span> <span class="nc" id="mw1g">Y</span> <span class="err" id="mw1w">\</span> <span class="nc" id="mw2A">X</span> <span class="k" id="mw2Q">if</span> <span class="nc" id="mw2g">Y</span> <span class="n" id="mw2w">is</span> <span class="k" id="mw3A">in</span> <span class="nc" id="mw3Q">W</span> <span class="n" id="mw3g">replace</span> <span class="nc" id="mw3w">Y</span> <span class="k" id="mw4A">in</span> <span class="nc" id="mw4Q">W</span> <span class="n" id="mw4g">by</span> <span class="n" id="mw4w">the</span> <span class="n" id="mw5A">same</span> <span class="n" id="mw5Q">two</span> <span class="n" id="mw5g">sets</span> <span class="k" id="mw5w">else</span> <span class="k" id="mw6A">if</span> <span class="o" id="mw6Q">|</span><span class="nc" id="mw6g">X</span> <span class="err" id="mw6w">∩</span> <span class="nc" id="mw7A">Y</span><span class="o" id="mw7Q">|</span> <span class="o" id="mw7g"><=</span> <span class="o" id="mw7w">|</span><span class="nc" id="mw8A">Y</span> <span class="err" id="mw8Q">\</span> <span class="nc" id="mw8g">X</span><span class="o" id="mw8w">|</span> <span class="n" id="mw9A">add</span> <span class="nc" id="mw9Q">X</span> <span class="err" id="mw9g">∩</span> <span class="nc" id="mw9w">Y</span> <span class="k" id="mw-A">to</span> <span class="nc" id="mw-Q">W</span> <span class="k" id="mw-g">else</span> <span class="n" id="mw-w">add</span> <span class="nc" id="mw_A">Y</span> <span class="err" id="mw_Q">\</span> <span class="nc" id="mw_g">X</span> <span class="k" id="mw_w">to</span> <span class="nc" id="mwAQA">W</span>

The algorithm starts with a partition that is too coarse: every pair of states that are equivalent according to the Nerode congruence belong to the same set in the partition, but pairs that are inequivalent might also belong to the same set. It gradually refines the partition into a larger number of smaller sets, at each step splitting sets of states into pairs of subsets that are necessarily inequivalent. The initial partition is a separation of the states into two subsets of states that clearly do not have the same behavior as each other: the accepting states and the rejecting states. The algorithm then repeatedly chooses a set A from the current partition and an input symbol c, and splits each of the sets of the partition into two (possibly empty) subsets: the subset of states that lead to A on input symbol c, and the subset of states that do not lead to A. Since A is already known to have different behavior than the other sets of the partition, the subsets that lead to A also have different behavior than the subsets that do not lead to A. When no more splits of this type can be found, the algorithm terminates.

Lemma. Given a fixed character c and an equivalence class Y that splits into equivalence classes B and C, only one of B or C is necessary to refine the whole partition.

Example: Suppose we have an equivalence class Y that splits into equivalence classes B and C. Suppose we also have classes D, E, and F; D and E have states with transitions into B on character c, while F has transitions into C on character c. By the Lemma, we can choose either B or C as the distinguisher, let's say B. Then the states of D and E are split by their transitions into B. But F, which doesn't point into B, simply doesn't split during the current iteration of the algorithm; it will be refined by other distinguisher(s).

Observation. All of B or C is necessary to split referring classes like D, E, and F correctly—subsets won't do.

The purpose of the outermost if statement (if Y is in W) is to patch up W, the set of distinguishers. We see in the previous statement in the algorithm that Y has just been split. If Y is in W, it has just become obsolete as a means to split classes in future iterations. So Y must be replaced by both splits because of the Observation above. If Y is not in W, however, only one of the two splits, not both, needs to be added to W because of the Lemma above. Choosing the smaller of the two splits guarantees that the new addition to W is no more than half the size of Y; this is the core of the Hopcroft algorithm: how it gets its speed, as explained in the next paragraph.

The worst case running time of this algorithm is O(ns log n), where n is the number of states and s is the size of the alphabet. This bound follows from the fact that, for each of the ns transitions of the automaton, the sets drawn from Q that contain the target state of the transition have sizes that decrease relative to each other by a factor of two or more, so each transition participates in O(log n) of the splitting steps in the algorithm. The partition refinement data structure allows each splitting step to be performed in time proportional to the number of transitions that participate in it. This remains the most efficient algorithm known for solving the problem, and for certain distributions of inputs its average-case complexity is even better, O(n log log n).

Once Hopcroft's algorithm has been used to group the states of the input DFA into equivalence classes, the minimum DFA can be constructed by forming one state for each equivalence class. If S is a set of states in P, s is a state in S, and c is an input character, then the transition in the minimum DFA from the state for S, on input c, goes to the set containing the state that the input automaton would go to from state s on input c. The initial state of the minimum DFA is the one containing the initial state of the input DFA, and the accepting states of the minimum DFA are the ones whose members are accepting states of the input DFA.

Moore's algorithm

Moore's algorithm for DFA minimization is due to Edward F. Moore (1956). Like Hopcroft's algorithm, it maintains a partition that starts off separating the accepting from the rejecting states, and repeatedly refines the partition until no more refinements can be made. At each step, it replaces the current partition with the coarsest common refinement of s + 1 partitions, one of which is the current one and the rest of which are the preimages of the current partition under the transition functions for each of the input symbols. The algorithm terminates when this replacement does not change the current partition. Its worst-case time complexity is O(n²s): each step of the algorithm may be performed in time O(ns) using a variant of radix sort to reorder the states so that states in the same set of the new partition are consecutive in the ordering, and there are at most n steps since each one but the last increases the number of sets in the partition. The instances of the DFA minimization problem that cause the worst-case behavior are the same as for Hopcroft's algorithm. The number of steps that the algorithm performs can be much smaller than n, so on average (for constant s) its performance is O(n log n) or even O(n log log n) depending on the random distribution on automata chosen to model the algorithm's average-case behavior.

Brzozowski's algorithm

Reversing the transitions of a non-deterministic finite automaton (NFA) ${\displaystyle M}$ and switching initial and final states produces an NFA ${\displaystyle M^R}$ for the reversal of the original language. Converting this NFA to a DFA using the standard powerset construction (keeping only the reachable states of the converted DFA) leads to a DFA ${\displaystyle M_D^R}$ for the same reversed language. As Brzozowski (1963) observed, repeating this reversal and determinization a second time, again keeping only reachable states, produces the minimal DFA for the original language.

The intuition behind the algorithm is this: determinizing the reverse automaton merges states that are nondistinguishable in the original automaton, but may produce several accepting states. In such case, when we reverse the automaton for the second time, these accepting states become initial, and thus the automaton will not be deterministic due to having multiple initial states. That is why we need to determinize it again, obtaining the minimal DFA.

Proof of correctness

After we determinize ${\displaystyle M^R}$ to obtain ${\displaystyle M_D^R}$, we reverse this ${\displaystyle M_D^R}$ to obtain ${\displaystyle (M_D^R{)}^R=M^{\prime }}$. Now ${\displaystyle M^{\prime }}$ recognises the same language as ${\displaystyle M}$, but there's one important difference: there are no two states in ${\displaystyle M^{\prime }}$ from which we can accept the same word. This follows from ${\displaystyle M_D^R}$ being deterministic, viz. there are no two states in ${\displaystyle M_D^R}$ that we can reach from the initial state through the same word. The determinization of ${\displaystyle M^{\prime }}$ then creates powerstates (sets of states of ${\displaystyle M^{\prime }}$), where every two powerstates ${\displaystyle \mathcal{R},\mathcal{S}}$ differ ‒ naturally ‒ in at least one state ${\displaystyle q}$ of ${\displaystyle M^{\prime }}$. Assume ${\displaystyle q\in \mathcal{R}}$ and ${\displaystyle q\notin \mathcal{S}}$; then ${\displaystyle q}$ contributes at least one word to the language of ${\displaystyle \mathcal{R}}$, which couldn't possibly be present in ${\displaystyle \mathcal{S}}$, since this word is unique to ${\displaystyle q}$ (no other state accepts it). We see that this holds for each pair of powerstates, and thus each powerstate is distinguishable from every other powerstate. Therefore, after determinization of ${\displaystyle M^{\prime }}$, we have a DFA with no indistinguishable or unreachable states; hence, the minimal DFA ${\displaystyle \overline{M}}$ for the original ${\displaystyle M}$.

Complexity

The worst-case complexity of Brzozowski's algorithm is exponential in the number of states of the input automaton. This holds regardless of whether the input is a NFA or a DFA. In the case of DFA, the exponential explosion can happen during determinization of the reversal of the input automaton; in the case of NFA, it can also happen during the initial determinization of the input automaton. However, the algorithm frequently performs better than this worst case would suggest.

NFA minimization

While the above procedures work for DFAs, the method of partitioning does not work for non-deterministic finite automata (NFAs). While an exhaustive search may minimize an NFA, there is no polynomial-time algorithm to minimize general NFAs unless P = PSPACE, an unsolved conjecture in computational complexity theory that is widely believed to be false. However, there are methods of NFA minimization that may be more efficient than brute force search.

For a given language, several structurally different (i.e. non-isomorphic) state-minimal NFA may exist. They may have strictly less states than the unique minimal DFA (example here).