Finite Automata
Closure Properties of Regular Languages
Theorem. The class of regular languages is closed under union,
intersection, subtraction, complementation, concatenation, Kleene
closure and reversal.
Note: closure under union, concatenation and Kleene closure comes
from the fact that regular languages are represented by regular
expressions; closure under intersection, subtraction and
complementation comes from from the fact that regular languages are
represented by DFAs. The only part still missing is the closure under
reversal.
4/12/2020
FCS
1
Finite Automata
Closure Properties of Regular Languages
Proof. We could prove it by structural induction (on the number of
operators applied), since R =  , {}R = {} and {a}R = {a} for every a
 , and the extension through union, concatenation and Kleene
closure is not hard.
We will prove it by construction, instead:
 Assume M is an NFA (or DFA), with language L(M).
 We construct and NFA M' such that L(M') = L(M)R.
 The equivalence of DFAs and NFAs will do the rest. This is the only
proof (of any of the statements of the theorem) where NFAs are really
used
4/12/2020
FCS
2
Finite Automata
Closure Properties of Regular Languages
Details: Let M = (Q, , , q0, F). We construct M' as follows: if |F| > 1,
introduce a new state s and connect every element in F to it via an transition. Otherwise, let s be the single state in F.
Define: M' = (Q{s}, , ', {s}, {q0}), where q'  '(q, a)  q  (q', a),
a  {}
All we have done is to "reverse the arrows", after a small adjustment.
We have an NFA (we cannot expect a DFA, even if M was a DFA with
a singleton accepting state - why?) whose accepting paths are exactly
the reversal of the accepting paths of the original.
4/12/2020
FCS
3
Finite Automata
Closure Properties of Regular Languages - Substitutions
Substitution. Let f be a mapping: f (a) = La, where a   and La is a
language over an alphabet . Extend the function f to * by f() = {}
and f(a1a2…ak)  f(a1)f(a2)…f(ak) for a1, …, ak  . For any language
L  *, we apply f to L: f(L) = xLf(x).
Ex.: L = {01, 10}; f(0) = 0(0+1)*; f(1) = (0+1)*1.
f(L)
= f(01)  f(10) = f(0)f(1) f(1)f(0)
= 0(0+1)*(0+1)*1 (0+1)*10(0+1)*
= 0(0+1)*1  (0+1)*10(0+1)*
A substitution is called a homomorphism if, for any a   , f (a) is a
language with a single string (= a singleton string).
4/12/2020
FCS
4
Finite Automata
Closure Properties of Regular Languages - Substitutions
Proposition. Let f be a substitution over ; assume that L  * is a
regular language and that f(a) is a regular language for each a  .
Then f(L) is a regular language.
Proof. Let r be a RE for L, ra a RE for f(a) for each a  . Replace
each occurrence of a in r by f(a). We obtain a new regular expression
r'.
We observe:
a) For any two sets A, B  *, f(AB) = f(A)  f(B), f(AB) = f(A) f(B),
and f(A*) = f(A)*.
b) For any two regular expressions r and s, (r + s)' = r' + s', (rs)' = r's',
and (r*)' = (r')*.
This could use detailed proof as set inclusions and RE equalities…
4/12/2020
FCS
5
Finite Automata
Closure Properties of Regular Languages - Substitutions
We now start the induction:
The base cases (0 operators):
 f() =  (extending the definition to the empty language). Regularity
is preserved: the empty language is regular and its image (also the
empty language) is also regular.
 f({}) = {}. The image of the language consisting of the empty
string is a regular language.
 f({a}) is a regular language for each a  , by definition of f.
All three basis steps give rise to regular languages and their regular
expressions starting from the regular language building blocks and
their regular expressions.
4/12/2020
FCS
6
Finite Automata
Closure Properties of Regular Languages
The structural induction step: Let r and s be regular expressions
defining regular languages A and B  * such that f(A) and f(B) are
regular languages with regular expressions r' and s'. Assume the
result holds for sets constructed with up to n operators; prove it holds if
you apply any one of the operators to two such sets.
We have:
r+s AB : f(AB) = f(A)f(B)  r'+s' = (r+s)'
and the image language is regular. Identical arguments will work for
the remaining structural operations (concatenation and Kleene
closure).
4/12/2020
FCS
7
Finite Automata
Closure Properties of Regular Languages - Quotients
Definition. The quotient of two languages, denoted by L1/L2 is given by
L1/L2 = {x | (y  L2)[xy  L1]}.
Proposition. If L1 is a regular language, then L1/L2 is regular.
Proof. Let M = (Q, , , q0, F) be a DFA accepting L1. By definition, for
any x  L1/L2 y  L2 s.t. (q0, xy) = ((q0, x), y)  F. If we define
F' = {q  Q | (y  L2)[(q, y)  F]},
M' = (Q, , , q0, F') is a DFA that accepts L1/L2.
Note: The proof is not quite constructive, at the moment, since we
would need to show that a finite number of strings in L2 suffices to
construct F'.
4/12/2020
FCS
8
Finite Automata
Closure Properties of Regular Languages - Examples
Ex. 2.37. Let L be regular over , k a pos. integer and : k  . Then
L1 = {(a1, a2, …, ak)…(a(n-1)k, a(n-1)k+1, …, ank) | a1a2…ank  L}
is regular. Note that a string of length nk in L becomes a string of
length n in L1.
Proof. Let L = L(M) for M = (Q, , , s, F). Let M' = (Q, , ', s, F), with
 (q  Q, a  ) '(q, a) = {(q, a1…ak) | (a1, …, ak) = a}.
Note: there is no requirement for  to be 1-1.
We can see that L1 = L(M').
Note that (q, a1…ak) is the state of M reached from q after consuming
the string a1…ak.
4/12/2020
FCS
9
Finite Automata
Closure Properties of Regular Languages - Examples
Def.: for any language L,
MIN(L) = {x  L | no proper prefix of x belongs to L}.
Ex. 2.38. If L is regular, then MIN(L) is regular.
Proof. Let L = L(M), where M = (Q, , , s, F) is a DFA. Let M' be the
NFA obtained from M by deleting all the out-edges from the final
states.
It is clear that M' accepts MIN(L)…
4/12/2020
FCS
10
Finite Automata
Closure Properties of Regular Languages - Examples
Def.: for a, b  {0, 1}, let a  b denote the disjunction of a and b; for
any two binary strings x and y, with |x| = |y|, let x  y denote the bitwise
disjunction of x and y.
Ex. 2.39. Let A and B be regular over {0, 1}. Then
A  B = {x  y | x  A, y  B, |x| = |y|}
is regular.
Proof. Let MA = (QA, {0, 1}, A, sA, FA) and MB = (QB, {0, 1}, B, sB, FB) be
the respective DFAs. We build a product NFA M' as follows:
M' = (QA  QB, {0, 1}, ', [sA, sB], FA  FB) where
'([p, q], 0) = {[A(p, 0), B(q, 0)]}
'([p, q], 1) = {[A(p, 0), B(q, 1)], [A(p, 1), B(q, 0)], [A(p, 1), B(q, 1)]}.
4/12/2020
FCS
11
Finite Automata
Minimum Deterministic Finite Automata
We have seen that regular languages give rise to at least three
different, and equivalent, notational devices that represent them. For
one of them, at least, the following question is meaningful: does a
regular language have a corresponding (unique) minimal DFA, in the
sense that no other DFA accepting the language has fewer states? if
the answer is yes, can we construct it?
The constructions we have, from REs to NFAs to DFAs tend to "blow
up" the number of states, up to exponential cardinality in the number
of states of the NFA - which already "bloats" the number of atomic
terms in the regular expression (digraph construction).
We could use a different characterization of regular languages.
4/12/2020
FCS
12
Finite Automata
Minimum Deterministic Finite Automata - the Index
Definition. For any language L  *, we define a relation RL on *:
x RL y  (w  *) [xw  L  yw  L].
Proposition. RL is an equivalence relation on *:
1)
2)
3)
it is reflexive: (x  *) [x RL x]
it is symmetric: (x, y  *) [x RL y  y RL x]
it is transitive: (x, y, z  *) [x RL y, y RL z  x RL z]
Proof. An easy exercise.
Corollary. RL partitions * into disjoint equivalence classes, where the
class containing x is denoted by [x]RL.
Proof. Another easy exercise.
Definition. The number of equivalence classes of R in * is called the
index of R and denoted by Index(R).
4/12/2020
FCS
13
Finite Automata
Minimum Deterministic Finite Automata - the Index - Example
Ex. 2.46: Let L be the set of binary strings starting and ending with the
same symbol. Find all equivalence classes of RL (in *).
Soln.: a) we first show that 8 x, y 2 *, x RL y  x and y start with the
same symbol and end with the same symbol.
 By contradiction. Assume x and y start with different symbols, with,
say, x starting with a 0 and y starting with a 1. Then x0  L while y0 
L, so that x RL y does not hold. This implies that x and y must start with
the same symbol. Note further that x RL y  x  L  y  L (  *),
and therefore, since they start with the same symbol, they must end
with the same symbol.
4/12/2020
FCS
14
Finite Automata
Minimum Deterministic Finite Automata - the Index - Example
 Assume x and y start with the same symbol and end with the same
symbol. Since they start with the same symbol: xw  L  yw  L for
all w  (0+1)+. Since x and y end with the same symbol, x  L  y  L.
Thus xw  L  yw  L for any w  (0+1)* = *.
We can now characterize the (5) equivalence classes:
[]RL = ,
[0] RL = 0 + 0(0 + 1)*0,
[1] RL = 1 + 1(0 + 1)*1,
[01] RL = 0(0 + 1)*1,
[10] RL = 1(0 + 1)*0
4/12/2020
FCS
15
Finite Automata
Minimum Deterministic Finite Automata - the Index - Example
How do we find the classes of * induced by the relation RL? If we
cannot guess them - and we usually can't - the only strategy left is to
be systematic.
1. Start from the string  2 * and find the strings in * that belong to its
class.
2. Move to the strings of length 1
3. Move to the strings of length 2 … etc.
4. Either the classes will begin repeating after a finite number of
constructions (in which case the index will be finite), or not, in which
case the index will be infinite.
4/12/2020
FCS
16
Finite Automata
Minimum Deterministic Finite Automata - the Index - Example
Details: recall x RL y  (w  *) [xw  L  yw  L], where
L =  + 0 + 1 + 0(0+1)*0 + 1(0+1)*1
Show: []RL = {}, where
[]RL ´ { y | y 2 * and (w  *) [w = w  L  yw  L]}
Since w 2 L , w 2 L, we are looking for those strings y s.t. yw 2 L , w 2
L. y =  is, obviously, OK. Let's now start with the shortest non-trivial
candidates: y = 0, 1. For each w 2 L, 0w 2 L if w =  or w ends in 0,
otherwise 0w  L. So 0  []RL. The same argument gives that 1 
[]RL. If y is any other nontrivial string, it must be one of 0(0+1)*0,
0(0+1)*1, 1(0+1)*0 and 1(0+1)*1. Then 11 2 L and 0(0+1)*011,
0(0+1)*111  L. Similarly for 00 and 1(0+1)*000, 1(0+1)*100.
So []RL contains just one string: .
4/12/2020
FCS
17
Finite Automata
Minimum Deterministic Finite Automata - the Index - Example
We now look at the classes of longer strings. The strings of length 1
will give rise to the classes [0] RL and [1] RL.
Claim: [0] RL = 0 + 0(0 + 1)*0,
[1] RL = 1 + 1(0 + 1)*1.
Let's construct [0] RL, the construction of [1] RL being similar.
[0]RL ´ { y | y 2 * and (w  *) [0w = w  L  yw  L]
Obviously, 0 2 [0] RL. The rest of the candidates must be of the form y =
1, 0(0 + 1)*0, 0(0 + 1)*1, 1(0 + 1)*0 and 1(0 + 1)*1. For y = 1, the choice w
= 1 will invalidate the condition; for y = 0(0 + 1)*0, the condition will hold
for w =  (both 0 and 0(0+1)*0 begin and end in 0) and for all other
choices of w it will depend only on the last character of w being 0 or
not. For y having the form of one the three remaining string types, we
find failures for w =  in the cases 0(0 + 1)*1 and 1(0 + 1)*0 and for w = 0
in the last one.
4/12/2020
FCS
18
Finite Automata
Minimum Deterministic Finite Automata - the Index - Example
We still have to place two sets of strings: the ones denoted by 0(0 +
1)*1 and 1(0 + 1)*0. It should be clear that, after this placement, all
strings in * will have been taken care of.
An argument similar to those already encountered allows us to
conclude that:
[01] RL = 0(0 + 1)*1,
[10] RL = 1(0 + 1)*0
4/12/2020
FCS
19
Finite Automata
Minimum DFAs - the Index - Second Example
Problem 2.7.1a: find all equivalence classes of RL for the language
L = (0 + 1)*01(0 + 1)*.
Soln: first observe that  = {0, 1}. RL is defined over * (= all strings
over {0, 1} - we are partitioning the set of all strings over {0, 1}) and,
specifically,
x RL y , 8(w 2 *){xw 2 L , yw 2 L}
for any two strings x, y 2 *.
Start with the class of the empty string: []RL.
Claim: []RL= [1]RL = [11]RL =…= [1n]RL =…
Note that both  and 1n must be concatenated with a string containing
01 (thus in L) in order to give rise to a string in L.
4/12/2020
FCS
20
Finite Automata
Minimum DFAs - the Index - Second Example
Problem 2.7.1a: find all equivalence classes of RL for the language
L = (0 + 1)*01(0 + 1)*.
Claim: []RL=…= [0n]RL =…= [1m0n]RL for m ≥ 1, n ≥ 1, i.e., w must
contain a 1 for the concatenation to be in L.
Claim: [1]RL = []Rl from the previous slide.
Claim: [01]RL = L.
All other strings in * belong to one of the classes just constructed.
Automaton for L:
1
0
0, 1
0
4/12/2020
1
FCS
21
Finite Automata
Minimum DFAs - the Index - Third Example
Problem 2.7.2a: show that for L = {0m1n | 0 ≤ m ≤ n}, Index(L) = 1.
Soln: first observe that  = {0, 1}. RL is defined over * (= all strings
over {0, 1} - we are partitioning the set of all strings over {0, 1}) and,
specifically,
x RL y , 8(w 2 *){xw 2 L , yw 2 L}
for any two strings x, y 2 *.
Start with the class of the empty string: []RL: for what y 2 * is it true
that w 2 L , yw 2 L? It is clear that w 2 L , w 2 L, so that w = 0m1n for
some 0 ≤ m ≤ n.
Question: what must y look like so that yw 2 L for all w of the form 0m1n,
0 ≤ m ≤ n, and only for those ws? Assume y = 0k for some k > 0. Then
0k0m1n  L 8 (0 ≤ m ≤ n < k + m). Similar arguments hold for any nonempty strings: []RL= {}.
4/12/2020
FCS
22
Finite Automata
Minimum DFAs - the Index - Third Example
Let's now try x = 0k, k > 0. Let y = 0j, j ≠ k. We must satisfy the
requirement 0kw 2 L , 0jw 2 L 8 (w 2 *). If we choose l = min{j, k},
then either 0k1l or 0k1l  L.
Since we have just shown that 0k and 0j, j ≠ k, belong to different
equivalence classes, we must conclude that RL has infinitely many
equivalence classes.
Notice that we do not need to identify all the distinct equivalence
classes - there may be others, after all we have identified only
[]RL, [0]RL , [02]RL, …, [0n]RL ,…
but this is enough to reach the desired conclusion.
4/12/2020
FCS
23
Finite Automata
Minimum Deterministic Finite Automata
Lemma. Let L be accepted by the DFA M = (Q, , , q0, F), and let  be
the extended transition function of M. Then, for any strings x, y  *,
(s, x) = (s, y)  x RL y.
Proof. If (s, x) = (s, y), then, for any w  *,
(s, xw) = ((s, x), w) = ((s, y), w) = (s, yw).
Thus, for any w  *, xw  L  yw  L.
Note. The lemma shows that, if L is accepted by a DFA M of n states,
all strings with the same ending state are in the same equivalence
class of RL. In particular Index(RL) ≤ n, and is thus finite. If we can find a
DFA accepting L and with exactly Index(RL) states, we have found the
desired minimum DFA.
4/12/2020
FCS
24
Finite Automata
Minimum Deterministic Finite Automata
Theorem 2.48 (Myhill-Nerode). For any regular language L, its
minimum DFA has exactly Index(RL) states.
Proof. Let L have alphabet . Define M = (Q, , , s, F) by:
1. Q = {[x]R | x  *}, (and |Q| <  if L is regular);
L
2. [x]R a) = [xa]R , for any a 2 ;
L
l
3. s = []R ;
L
4. F = {[x]R | x  L}.
L
The function  is well-defined since:
[x]RL = [y]RL  [xa]RL = [ya]RL
 [x]RLa) = [xa]RL = [ya]RL = [y]RLa).
By induction on |y| we extend this to []RLx) = [x]RL x  *proving
that L(M) = L: x  L [x]RL  F  []RLx)  F  M accepts x. Since
M has Index(RL) states, it is, by the previous Lemma, a min. DFA for L.
4/12/2020
FCS
25
Finite Automata
Minimum Deterministic Finite Automata
Corollary. A language L is regular  Index(RL) < .
Proof. No use of regularity (other than for the finiteness of Q) was
made in the Myhill-Nerode theorem. We can thus construct the
minimum DFA for any language as along as Index(RL) < . Such
languages L must be regular.
Note: the finiteness of DFAs allows us to obtain a "simplification" - we
don't need to look at all of * to characterize RL, but only to strings up
to a certain length.
4/12/2020
FCS
26
Finite Automata
Minimum Deterministic Finite Automata
Proposition. L is regular   k  N+ s.t. [x RL y  [z  * with |z|
≤ k, xz  L  yz  L]].
This simply means that regular languages are really determined by
finite sets of strings: you will have no surprises from "very long
strings".
This also means, in the language quotient case, that we don't need to
look at all the strings in L2.
4/12/2020
FCS
27
Finite Automata
Minimum Deterministic Finite Automata
Proposition. L is regular   k  N+ s.t. [x RL y  [z  * with |z|
≤ k, xz  L  yz  L]].
Proof.  Let M = (Q, , , s, F) be a DFA accepting L; let k = |Q|2 - 1.
 This is obvious, since x RL y  [z  * xz  L  yz  L], and therefore
for all those z with |z| ≤ k.
 Consider the product DFA M* = M M. Let w  * with |w| > k. Let x, y 2
*. The computation path of M* on w starting from q1* = [(s, x), (s, y)],
to q2* = [(s, xw), (s, yw)], contains at least |Q|2 + 1 states, while M* has
|Q|2 states, and therefore it contains some cycles in the transition
diagram of M*. Eliminate the cycles and keep only a simple path from
q1* to q2*, which corresponds to the computation path for a string z with
|z| ≤ k, so that q2* = [(s, xz), (s, yz)] = [(s, xw), (s, yw)]. By assumption,
xz  L  yz  L : the states (s, xz) and (s, yz) are both in F or not in F.
So xw  L  yw  L and the result follows.
4/12/2020
FCS
28
Finite Automata
Minimum Deterministic Finite Automata
 Assume  k  N+ s.t. [x RL y  [z  * with |z| ≤ k, xz  L  yz 
L]]. Each z can divide * in at most two parts: {x | xz  L} and {x | xz 
L}. The number of equivalence classes of RL is thus, at most, 21+||+...||k,
and so finite. Which implies regularity for L.
Note: we have developed some results and techniques which allow us
to do two things
a)
b)
we have a way of constructing a minimum DFA for a regular
language;
we have a way of determining (maybe) whether a language is regular
or not (being unable to construct a DFA is quite different from proving
that no DFA exists) by computing Index(RL) .
4/12/2020
FCS
29
Finite Automata
Minimum Deterministic Finite Automata - Example
Ex. 2.51.: find the minimum DFA for the language L = (0 + 1)*01.
Soln.: we compute the equivalence classes of RL (some "bit analysis"),
beginning from the shortest string in *:
[]RL= {x  {0, 1}* | (w  {0, 1}*)[xw  (0 + 1)*01  w  (0 + 1)*01]}. We
need to characterize x  []RL. What are the possible relevant endings of
x? : 0, 1, 00, 01, 10, 11. There is no point in looking at longer strings, since
L fixes the last two characters. x may not end with 0 (or 01): if it did x1 (or
x) would be in (0+1)*01, which would imply that w = 1 (or w = ) is in
(0 + 1)*01. Conversely, if x does not end with 0 or 01, then x  []RL. Thus
[]RL=  + 1 + (0 + 1)*11.
2. [0]R = {x  {0, 1}* | (w  {0, 1}*)[0w  (0 + 1)*01  xw  (0 + 1)*01]}.
L
What must x end with? Since, for w = 1, 0w  (0 + 1)*01]}, x must end with
0. Conversely, if x ends with 0, x  [0]RL. Thus [0]RL= (0 + 1)*0.
1.
4/12/2020
FCS
30
Finite Automata
Minimum Deterministic Finite Automata - Example
[1]RL. Using the definition of []RL we can see that 1  []RL and thus
the two classes must coincide (by RL being an equivalence relation).
4.
[00]RL. 00  [0]RL  [00]RL = [0]RL.
5.
[01]RL = {x  {0, 1}* | (w  {0, 1}*)[01w  (0 + 1)*01  xw  (0 +
1)*01]}. Either x ends in 01, or it cannot satisfy the condition. We must
conclude that [01]RL = (0+1)*01.
6.
[10]RL: since 10 2 [0]RL, we have [10]RL= [0]RL.
7.
[11]RL: since 11 2 []RL, we have [11]RL= []RL.
The classes are []R , [0]R and [01]RL. The minimum DFA has only 3 states:
3.
L
l
0
1

0
0
1
0
01
1
4/12/2020
FCS
31
Finite Automata
Minimum Deterministic Finite Automata - Example
Ex. 2.53. Find the minimum DFA equivalent to the DFA:
0
0
1
0
1
1
2
0
1
0
1
4
1
5
0
4/12/2020
3
0,1
FCS
32
Finite Automata
Minimum Deterministic Finite Automata - Example
Soln. 1: M = (Q, , , q0, F), Q = {q0, q1, q2, q3, q4, q5}, L = L(M).
Recall: for states p and q,
p R*L q , Sp = {x 2 * | (s, x) = p)} is in same equiv. class as
Sq = {x 2 * | (s, x) = q)} .
, (8 w)[(p, w) 2 F , (q, w) 2 F].
To find R*L between any two states, construct a graph G:
Each vertex is an unordered pair (qi, qj). Let U be the set of vertices (qi,
qj) with one vertex qi 2 F and the other vertex qj  F. For each vertex
(qi, qj)  U (either both vertices are in F or not in F), with i ≠ j, draw
edges (qi, qj) !a ((qi, a), (qj, a)) 8 a 2 .
Claim: qi R*L qj , there is no path in G from (qi, qj) to a vertex in U.
4/12/2020
FCS
33
Finite Automata
Minimum Deterministic Finite Automata - Example
How do we use this construction? Construct G.
U consists of the pairs (0, 2), (1, 3), (1, 2), (0, 3), (2, 4), (3, 4), (4, 5).
The complement of U consists of (0, 0), (0, 1), (1, 1), (0, 4) (1, 4), (2, 2),
(2, 3), (3, 3), (2, 5), (3, 5), (4, 4), (5, 5).
Note: there is no point in starting from a (qi, qi) node - why?
0
From (0, 1):
0
1
0
0
(0, 1)
0
1
(2, 3)
1
(4, 4)
0
1
(5, 5)
2
0
1
3
0, 1
0
1
4
4/12/2020
1
1
FCS
0
1
5
0,1
34
Finite Automata
Minimum Deterministic Finite Automata - Example
The next node in the list is (0, 4):
0
0
(0, 4)
1
0
(2, 5)
(5, 5)
0, 1
1
0
1
1
1
1
0
(1, 4)
1
2
0
(3, 5)
1
(4, 5)
0
0
1
0
1
4
0
3
1
5
0,1
Note that from the nodes (0, 4), (1, 4), (2, 5) and (3, 5) we can reach a
node in U. When we put together the two partial graphs (constructed
this way for convenience, we get:
4/12/2020
FCS
35
Finite Automata
Minimum Deterministic Finite Automata - Example
The minimal automaton is exactly the one corresponding to the graph
with only black nodes:
0
0
(0, 1)
1
1
(2, 3)
(4, 4)
0
(0, 4)
1
0
(2, 5)
1
(5, 5)
0, 1
1
1
0
(1, 4)
4/12/2020
1
0
(3, 5)
1
FCS
(4, 5)
0
36
Finite Automata
Minimum Deterministic Finite Automata - Example
We finish with just the minimal DFA, where we have highlighted it final
nodes:
0
(0, 1)
0
1
(2, 3)
1
(4, 4)
0
1
(5, 5)
4/12/2020
FCS
0, 1
37
Finite Automata
Minimum Deterministic Finite Automata - Example
Soln. 2: The critical step of soln. 1 is to determine, for a pair (qi, qj)
whether there is a path in G from it to a vertex of U. You need only
study pairs where i ≠ j, since you know the (qi, qi) belong to the same
class. Create a table of pairs, marking all pairs in U with a 0:
Of the unmarked pairs, mark with a 1 those
for which there is an a 2  taking them to a
pair marked with a 0.
q1,
q2,
0
0
q3,
0
0
q1,
q4,
0
q5
0 0
0
q0, q1, q2, q3, q4
4/12/2020
0
FCS
q2,
0
0
q3,
0
0
0
q4,
0
q5
0 0 1 1 0
q0, q1, q2, q3, q4
38
Finite Automata
Minimum Deterministic Finite Automata - Example
Of the unmarked pairs, mark with a 2 those for which there is an a 2 
taking them to a pair marked with a 1. Keep on until no more
markings. The pairs left unmarked must satisfy qi R*L qj. Add the (qi, qi)
needed to complete the graph
q1,
q1,
q2,
0
0
q2,
0
0
q3,
0
0
q3,
0
0
q4,
2
2
0
q4,
0
q5
0 0 1 1 0
q0, q1, q2, q3, q4
4/12/2020
q5
0
0
0 0 1 1 0
q0, q1, q2, q3, q4
FCS
39
Finite Automata
Minimum Deterministic Finite Automata - Example
Soln. 3: Split states into F and Q\F. Chase states from F: if any exit F,
break F into an appropriate number of sub-blocks; same for Q\F.
Keep on iterating until no new blocks appear.
0
0
1
1
2
0
1
0
4/12/2020
1
1
0
1
1
3
2
0
1
4
0
1
0
0
0
1
0
1
5
4
0,1
0
FCS
3
1
5
0,1
40
Finite Automata
Minimum Deterministic Finite Automata - Example
0
0
1
0
0
1
3
1
0
4/12/2020
1
1
2
0
1
1
5
4
0,1
0
1
FCS
0,1
1
0
0
1
4
0
1
1
2
0
1
3
2,3
0
1
5
4
0,1
0
0
1
5
0,1
41