State Minimization: A Comprehensive
Summary
Abacan, Arjay M.
Batangas State University
Email: jcngs2497@yahoo.com
AbstractThis research paper aims to discuss
describe the nature of state machines and to give
techniques on how to effectively minimize state
machines.
I. INTRODUCTION
Problems associated with constructing and
minimizing finite state machines arise repeatedly in
software and hardware design applications. Finite
state machines are best thought of as pattern
recognizers, and minimum-size machines
correspond to recognizers that require less time and
space. Complicated control systems and compilers
are often built using finite state machines to encode
the current state and associated actions, as well as
the set of possible transitions to other states.
Minimizing the size of this machine minimizes its
cost.
Finite state machines are best thought of as
edge-labeled directed graphs, where each vertex
represents one of n states and each edge a transition
from one state to the other on receipt of the
alphabet symbol that labels the edge. The
automaton above analyzes a given sequence of coin
tosses, with the dark states signifying that an even
number of heads have been observed. Automata
can be represented using any graph data structure,
or by using an transition matrix,
where is the size of the alphabet.
Finite state machines are often used to specify
search patterns in the guise of regular expressions,
which are patterns formed by and-ing, or-ing, and
looping over smaller regular expressions. For
example, the regular
expression matches any string on
(a,b,c) that begins and ends with
an a (including a itself). The best way to test
whether a string is described by a given regular
expression (especially if many strings will be
tested) is to construct the equivalent finite
automaton and then simulate the machine on the
string.
II. CONSIDERATIONS
Minimizing deterministic finite state
machines - Transition matrices for finite automata
quickly become prohibitively large for
sophisticated machines, thus fueling the need for
tighter encodings. The most direct approach is to
eliminate redundant states in the automaton. As the
example above illustrates, automata of widely
varying sizes can compute the same function.
Algorithms for minimizing the number of
states in a deterministic finite automaton (DFA)
appear in any book on automata theory. The basic
approach works by partitioning the states into gross
equivalence classes and then refining the partition.
Initially, the states are partitioned into accepting,
rejecting, and other classes. The transitions from
each node branch to a given class on a given
symbol. Whenever two states , t in the same
class C branch to elements of different classes, the
class C must be partitioned into two subclasses, one
containing , the other containing t.
This algorithm makes a sweep though all the
classes looking for a new partition, and repeating
the process from scratch if it finds one. This yields
an algorithm, since at most n-1 sweeps need
ever be performed. The final equivalence classes
correspond to the states in the minimum
automaton. In fact, a more
efficient, algorithm is known with
available implementations discussed below.
Constructing deterministic machines from
nondeterministic machines - DFAs are simple to
understand and work with, because the machine is
always in exactly one state at any given time. length m require states in any DFA
Nondeterministic automata (NFAs) can be in more implementing them, such
than one state at a time, so its current ``state'' as . There is no
represents a subset of all possible machine states. way to avoid this exponential blowup in the space
required. Note, however, that it takes linear time to
In fact, any NFA can be mechanically simulate an input string on any automaton,
converted to an equivalent DFA, which can then be regardless of the size of the automaton.
minimized as above. However, converting an NFA
to a DFA can cause an exponential blowup in the III. FSM OPTIMIZATION FLOW CHART
number of states, which perversely might later be
eliminated in the minimization. This exponential
blowup makes automaton minimization problems
NP-hard whenever you do not start with a DFA.

The proofs of equivalence between NFAs,

DFAs, and regular expressions are elementary
enough to be covered in undergraduate automata
theory classes. However, they are surprisingly
nasty to implement, for reasons including but not
limited to the exponential blowup of states.
Implementations are discussed below.

Constructing machines from regular

expressions - There are two approaches to
converting a regular expression to an equivalent
finite automaton, the difference being whether the
output automaton is to be a nondeterministic or
deterministic machine. The former is easier to
construct but less efficient to simulate.
The goal is to identify and combine states that
The nondeterministic construction uses - have equivalent behavior.
moves, which are optional transitions that require
no input to fire. On reaching a state with an - First is to identify and combine states that have
move, we must assume that the machine can be in equivalent behavior
either state. Using such -moves, it is
straightforward to construct an automaton from a Algorithm sketch
depth-first traversal of the parse tree of the regular
expression. This machine will have O(m) states, 1. place all states in one set
if m is the length of the regular expression. Further, 2. initially partition set based on the output
simulating this machine on a string of behavior
length n takes O(m n) time, since we need consider 3. successively partition the resulting subsets
each state/prefix pair only once. based on next state transitions
4. repeat (3) until no further partitioning is
The deterministic construction starts with the possible
parse tree for the regular expression, observing that
each leaf represents one of the alphabet symbols in states left in the same set are equivalent
the pattern. After recognizing a prefix of the text,
we can be left in some subset of these possible Si, Sj are compatible if for each input they
positions, which would correspond to a state in the have consistent outputs, and their successors are
finite automaton. The derivatives method builds up the same or compatible.
this automaton state by state as it is needed. Even
so, some regular expressions of

Si, Sj are conditionally compatible if their
outputs and next states are consistent for some
pairs of successors
IV. MINIMIZATION ALGORITHM
1) Find all Find all pairs of compatible states,
pairs of compatible states
2) Calculate maximal sets of compatible states
(MCC) states (MCC)
3) Select sets that satisfy the covering
condition (a) and the closure condition (b):
a) Each state must be in at least one class;
b) For each input symbol all next states of each
class must be included into one class.
State minimization straight forward in fully-
specified machines
Find compatible states
Define maximal compatibility class
Select states that satisfy g covering and
closure condition
V. IMPLEMENTATION
FIRE Engine is a finite automaton toolkit,
written in C++ by Bruce Watson. It provides
production-quality implementations of finite
automata and regular expression algorithms.
Several finite automaton minimization algorithms
have been implemented, including
Hopcroft's algorithm. Both deterministic
and nondeterministic automata are supported. FIRE
Engine has been used for compiler construction,
hardware modeling, and computational biology
applications. It is strictly a computing engine and
does not provide a graphical user interface. FIRE
Engine is available by anonymous ftp from
ftp.win.tue.nl in the directory
/pub/techreports/pi/watson.phd/. A greatly
improved commercial version is available from
www.RibbitSoft.com.
Grail is a C++ package for symbolic
computation with finite automata and regular
expressions, from Darrell Raymond and Derrick
Wood. Grail enables one to convert between
different machine representations and to minimize
automata. It can handle machines with 100,000
states and dictionaries of 20,000 words. All code
and documentation are accessible from the WWW
site http://www.csd.uwo.ca/research/grail, as well
as pointers to a variety of other automaton
packages. Commercial use of Grail is not allowed
without approval, although it is freely available to
students and educators.
An implementation in C of a regular-
expression matching algorithm appears in [BR95].
The source code for this program is printed in the
text and is available on disk for a modest fee. A
bare bones implementation in C of a regular-
expression pattern matching algorithm appears in
[GBY91].
FLAP (Formal Languages and Automata
Package) is a tool by Susan Rodger for drawing
and simulating finite automata, pushdown
automata, and Turing machines. Using FLAP, one
can draw a graphical representation (transition
diagram) of an automaton, edit it, and simulate the
automaton on some input. FLAP was developed in
C++ for X-Windows.
REFERENCES
https://cseweb.ucsd.edu/classes/sp08/cse140/le
ctures/wk6.pdf
http://www.cs.columbia.edu/~nowick/minimali
st/node9.html
http://jjackson.eng.ua.edu/courses/ece380/lectu
res/LECT32.pdf
https://courses.cs.washington.edu/courses/cse3
70/09wi/LectureSlides/22-
Minimization.pdf
https://www.tutorialspoint.com/automata_theor
y/dfa_minimization.htm