The.Algorithm.Design.Manual.Springer-Verlag.1998

Finite State Machine Minimization
● 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 nondeterministic construction uses -moves, which are optional transitions that require no
input to fire. On reaching a state with an -move, we must assume that the machine can be in
either state. Using such -moves, it is straightforward to construct an automaton from a depth-first
traversal of the parse tree of the regular expression. This machine will have O(m) states, if m is
the length of the regular expression. Further, simulating this machine on a string of length n takes
O(m n) time, since we need consider each state/prefix pair only once.
The deterministic construction starts with the parse tree for the regular expression, observing that
each leaf represents one of the alphabet symbols in the pattern. After recognizing a prefix of the
text, we can be left in some subset of these possible positions, which would correspond to a state
in the finite automaton. The derivatives method builds up this automaton state by state as it is
needed. Even so, some regular expressions of length m require states in any DFA
implementing them, such as . There is no way to avoid this
exponential blowup in the space required. Note, however, that it takes linear time to simulate an
input string on any automaton, regardless of the size of the automaton.
Implementations: 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]. See
file:///E|/BOOK/BOOK5/NODE207.HTM (3 of 4) [19/1/2003 1:32:15]