Minimization of Automata

This chapter is concerned with the design and analysis of algorithms for minimizing finite automata. Getting a minimal automaton is a fundamental issue in the use and implementation of finite automata tools in frameworks like text processing, image analysis, linguistic computer science, and many other applications. There are two main families of minimization algorithms. The first by a sequence of refinements of a partition of the set of states, the second by a sequence of fusions or merges of states. Hopcroft’s and Moore’s algorithms belong to the first family, the linear-time minimization of acyclic automata of Revuz belongs to the second family. One of our studies is upon the comparison of the nature of Moore’s and Hopcroft’s algorithms. This gives some new insight in both algorithms. As we shall see, these algorithms are quite different both in behavior and in complexity. In particular, we show that it is not possible to simulate the computations of one of the algorithm by the other. We describe the minimization algorithm by fusion for so-called local automata. A special case of minimization is the construction o minimal automata for finite sets. We consider briefly this case, and in particular describe incremental algorithms. Finally, we consider the case of updating a minimal automaton when a word is added or removed from the set it recognizes.

💡 Research Summary

The paper provides a comprehensive study of algorithms for minimizing deterministic finite automata (DFA), focusing on two major families of techniques: partition refinement and state fusion. After establishing the necessary formal background—states, languages, Nerode equivalence, and the notion of splitters—the authors discuss Brzozowski’s algorithm, which uses double reversal and determinization. Although conceptually simple and applicable to nondeterministic automata, its worst‑case time and space are exponential, limiting practical use.

The core of the work examines Moore’s and Hopcroft’s partition‑refinement algorithms. Moore’s method starts from the coarse partition {final, non‑final} and repeatedly refines it using splitters for each alphabet symbol. The number of refinement steps, called the depth ℓ, equals the smallest h such that the h‑equivalence coincides with Nerode equivalence. While the average complexity over all DFA of size n is O(n log n) (as proved by Bassino, David, and Nicaud), the worst case can reach ℓ = n − 2, yielding quadratic time. Hopcroft’s algorithm improves the worst‑case bound to O(n log n) by always splitting the smallest block first; a key lemma guarantees that the order of splitting does not affect the final partition. The authors prove that Moore’s and Hopcroft’s procedures are fundamentally different and cannot simulate each other’s computations.

A special class of “slow automata” is introduced: automata for which both algorithms require the maximal number of refinement steps. The paper shows that these automata are characterized by deep language quotients and that the same lower bound applies to Hopcroft’s method.

The second family, state‑fusion algorithms, is explored in depth. Revuz’s linear‑time algorithm for acyclic DFA merges states that share the same right language during a bottom‑up traversal of the trie representation. Almeida and Zeitoun extend this technique to automata whose strongly connected components are simple cycles, defining the notion of local automata where fusion is always possible. Daciuk et al. present an incremental algorithm that avoids building an intermediate trie, directly inserting or deleting words while maintaining minimality, which is especially valuable for large dynamic dictionaries.

Dynamic minimization is addressed: when a word is added to or removed from the language recognized by a minimal DFA, only a localized recomputation of affected partitions or fusions is required, avoiding a full reconstruction. The paper also briefly discusses nondeterministic automata, noting that minimal NFAs are not unique in general, though certain subclasses admit unique minimal representatives.

In conclusion, the authors compare the trade‑offs between the two families. Partition‑refinement algorithms offer strong theoretical guarantees (Hopcroft’s O(n log n) worst case) but can be complex to implement; Moore’s version is simpler but may degrade to quadratic time on pathological inputs. State‑fusion methods excel in practical scenarios involving acyclic or locally cyclic structures, providing linear‑time performance and efficient incremental updates. The paper suggests that future work could combine the strengths of both approaches, develop hybrid algorithms, and further investigate average‑case behavior for a broader class of automata.