UNIT 1 PDF Cis262sl1aut

Chapter 3
DFA’s, NFA’s, Regular Languages
The family of regular languages is the simplest, yet inter-

esting family of languages.
We give six definitions of the regular languages.

1. Using deterministic finite automata (DFAs).
2. Using nondeterministic finite automata (NFAs).
3. Using a closure definition involving, union, concate-
nation, and Kleene ∗.
4. Using regular expressions.
5. Using right-invariant equivalence relations of finite
index (the Myhill-Nerode characterization).
6. Using right-linear context-free grammars.
51
52 CHAPTER 3. DFA’S, NFA’S, REGULAR LANGUAGES
We prove the equivalence of these definitions, often by

providing an algorithm for converting one formulation
into another.
We find that the introduction of NFA’s is motivated by

the conversion of regular expressions into DFA’s.
To finish this conversion, we also show that every NFA can

be converted into a DFA (using the subset construction).
So, although NFA’s often allow for more concise descrip-

tions, they do not have more expressive power than DFA’s.
NFA’s operate according to the paradigm: guess a suc-

cessful path, and check it in polynomial time.
This is the essence of an important class of hard problems

known as N P, which will be investigated later.
We will also discuss methods for proving that certain lan-

guages are not regular (Myhill-Nerode, pumping lemma).
We present algorithms to convert a DFA to an equivalent

one with a minimal number of states.
3.1. DETERMINISTIC FINITE AUTOMATA (DFA’S) 53
3.1 Deterministic Finite Automata (DFA’s)
First we define what DFA’s are, and then we explain how

they are used to accept or reject strings. Roughly speak-
ing, a DFA is a finite transition graph whose edges are
labeled with letters from an alphabet Σ.
The graph also satisfies certain properties that make it

deterministic. Basically, this means that given any string
w, starting from any node, there is a unique path in the
graph “parsing” the string w.
Example 1. A DFA for the language

L1 = {ab}+ = {ab}∗{ab},
i.e.,
L1 = {ab, abab, ababab, . . . , (ab)n, . . .}.
Input alphabet: Σ = {a, b}.
State set Q1 = {0, 1, 2, 3}.
Start state: 0.
Set of accepting states: F1 = {2}.

Transition table (function) δ1:
a b
0 1 3
1 3 2
2 1 3
3 3 3
Note that state 3 is a trap state or dead state.
Here is a graph representation of the DFA specified by

the transition function shown above:
a b
0 1 2
a
a
b b
3
a, b
Figure 3.1: DFA for {ab}+


L2 = {ab}∗ = L1 ∪ {ϵ}
i.e.,
L2 = {ϵ, ab, abab, ababab, . . . , (ab)n, . . .}.
State set Q2 = {0, 1, 2}.
Start state: 0.

a b
0 1 2
1 2 0
2 2 2
State 2 is a trap state or dead state.

a
0 1
b
b a
2
a, b
Figure 3.2: DFA for {ab}∗


L3 = {a, b}∗{abb}.
Note that L3 consists of all strings of a’s and b’s ending

in abb.
State set Q3 = {0, 1, 2, 3}.
Start state: 0.
a b
0 1 0
1 1 2
2 1 3
3 1 0

b
b a
a b b
0 1 2 3
a
Figure 3.3: DFA for {a, b}∗ {abb}
Is this a minimal DFA?

Definition 3.1. A deterministic finite automaton (or

DFA) is a quintuple D = (Q, Σ, δ, q0, F ), where
• Σ is a finite input alphabet;
• Q is a finite set of states;
• F is a subset of Q of final (or accepting) states;
• q0 ∈ Q is the start state (or initial state);
• δ is the transition function, a function
δ : Q × Σ → Q.
For any state p ∈ Q and any input a ∈ Σ, the state

q = δ(p, a) is uniquely determined.
Thus, it is possible to define the state reached from a

given state p ∈ Q on input w ∈ Σ∗, following the path
specified by w.
Technically, this is done by defining the extended transi-

tion function δ ∗ : Q × Σ∗ → Q.
Definition 3.2. Given a DFA D = (Q, Σ, δ, q0, F ), the

extended transition function δ ∗ : Q×Σ∗ → Q is defined
as follows:
δ ∗(p, ϵ) = p,
δ ∗(p, ua) = δ(δ ∗(p, u), a),
where a ∈ Σ and u ∈ Σ∗.
It is immediate that δ ∗(p, a) = δ(p, a) for a ∈ Σ.
The meaning of δ ∗(p, w) is that it is the state reached

from state p following the path from p specified by w.
We can show (by induction on the length of v) that

δ ∗(p, uv) = δ ∗(δ ∗ (p, u), v) for all p ∈ Q and all u, v ∈ Σ∗
For the induction step, for u ∈ Σ∗, and all v = ya with

y ∈ Σ∗ and a ∈ Σ,
δ ∗(p, uya) = δ(δ ∗(p, uy), a) by definition of δ ∗

= δ(δ ∗(δ ∗(p, u), y), a) by induction
= δ ∗(δ ∗(p, u), ya) by definition of δ ∗.
We can now define how a DFA accepts or rejects a string.
Definition 3.3. Given a DFA D = (Q, Σ, δ, q0, F ), the

language L(D) accepted (or recognized) by D is the
language
L(D) = {w ∈ Σ∗ | δ ∗(q0, w) ∈ F }.
Thus, a string w ∈ Σ∗ is accepted iff the path from q0 on

input w ends in a final state.
The definition of a DFA does not prevent the possibility

that a DFA may have states that are not reachable from
the start state q0, which means that there is no path
from q0 to such states.
For example, in the DFA D1 defined by the transition

table below and the set of final states F = {1, 2, 3}, the
states in the set {0, 1} are reachable from the start state
0, but the states in the set {2, 3, 4} are not (even though
there are transitions from 2, 3, 4 to 0, but they go in the
wrong direction).
a b
0 1 0
1 0 1
2 3 0
3 4 0
4 2 0
Since there is no path from the start state 0 to any of the

states in {2, 3, 4}, the states 2, 3, 4 are useless as far as
acceptance of strings, so they should be deleted as well
as the transitions from them.
Given a DFA D = (Q, Σ, δ, q0, F ), the above suggests

defining the set Qr of reachable (or accessible) states as
Qr = {p ∈ Q | (∃u ∈ Σ∗)(p = δ ∗(q0, u))}.
The set Qr consists of those states p ∈ Q such that there

is some path from q0 to p (along some string u).
Computing the set Qr is a reachability problem in a

directed graph. There are various algorithms to solve
this problem, including breadth-first search or depth-first
search.
Once the set Qr has been computed, we can clean up the

DFA D by deleting all redundant states in Q − Qr and
all transitions from these states.
More precisely, we form the DFA

Dr = (Qr , Σ, δr , q0, Qr ∩ F ), where δr : Qr × Σ → Qr is
the restriction of δ : Q × Σ → Q to Qr .
If D1 is the DFA of the previous example, then the DFA

(D1)r is obtained by deleting the states 2, 3, 4:
a b
0 1 0
1 0 1
It can be shown that L(Dr ) = L(D) (see the homework

problems).
A DFA D such that Q = Qr is said to be trim (or re-

duced).
Observe that the DFA Dr is trim. A minimal DFA must

be trim.
Computing Qr gives us a method to test whether a DFA

D accepts a nonempty language. Indeed
L(D) ̸= ∅ iff Qr ∩ F ̸= ∅. (∗emptyness)
We now come to the first of several equivalent definitions

of the regular languages.
Regular Languages, Version 1

Definition 3.4. A language L is a regular language if
it is accepted by some DFA.
Note that a regular language may be accepted by many

different DFAs. Later on, we will investigate how to find
minimal DFA’s.
For a given regular language L, a minimal DFA for L

is a DFA with the smallest number of states among
all DFA’s accepting L .
A minimal DFA for L must exist since every nonempty

subset of natural numbers has a smallest element.
In order to understand how complex the regular languages

are, we will investigate the closure properties of the reg-
ular languages under union, intersection, complementa-
tion, concatenation, and Kleene ∗.
It turns out that the family of regular languages is closed

under all these operations. For union, intersection, and
complementation, we can use the cross-product construc-
tion which preserves determinism.
However, for concatenation and Kleene ∗, there does not

appear to be any method involving DFA’s only. The way
to do it is to introduce nondeterministic finite automata
(NFA’s), which we do a little later.
3.2 The “Cross-product” Construction
Let Σ = {a1, . . . , am} be an alphabet.
Given any two DFA’s D1 = (Q1, Σ, δ1, q0,1, F1) and

D2 = (Q2, Σ, δ2, q0,2, F2), there is a very useful construc-
tion for showing that the union, the intersection, or the
relative complement of regular languages, is a regular lan-
guage.
Given any two languages L1, L2 over Σ, recall that

L1 ∪ L2 = {w ∈ Σ∗ | w ∈ L1 or w ∈ L2},
L1 ∩ L2 = {w ∈ Σ∗ | w ∈ L1 and w ∈ L2},
L1 − L2 = {w ∈ Σ∗ | w ∈ L1 and w ∈
/ L2}.
3.2. THE “CROSS-PRODUCT” CONSTRUCTION 69
Let us first explain how to constuct a DFA accepting the

intersection L1 ∩ L2. Let D1 and D2 be DFA’s such that
L1 = L(D1) and L2 = L(D2).
The idea is to construct a DFA simulating D1 and D2

in parallel. This can be done by using states which are
pairs (p1, p2) ∈ Q1 × Q2.
Thus, we define the DFA D as follows:

D = (Q1 × Q2, Σ, δ, (q0,1, q0,2), F1 × F2),
where the transition function δ : (Q1 ×Q2)×Σ → Q1 ×Q2
is defined as follows:
δ((p1, p2), a) = (δ1(p1, a), δ2(p2, a)),
for all p1 ∈ Q1, p2 ∈ Q2, and a ∈ Σ.

Clearly, D is a DFA, since D1 and D2 are. Also, by the

definition of δ, we have
δ ∗ ((p1, p2), w) = (δ1∗(p1, w), δ2∗(p2, w)),
for all p1 ∈ Q1, p2 ∈ Q2, and w ∈ Σ∗.
Now, we have w ∈ L(D1) ∩ L(D2)

iff w ∈ L(D1) and w ∈ L(D2),
iff δ1∗(q0,1, w) ∈ F1 and δ2∗(q0,2, w) ∈ F2,
iff (δ1∗(q0,1, w), δ2∗(q0,2, w)) ∈ F1 × F2,
iff δ ∗((q0,1, q0,2), w) ∈ F1 × F2,
iff w ∈ L(D).
Thus, L(D) = L(D1) ∩ L(D2).
We can now modify D very easily to accept

L(D1) ∪ L(D2).
We change the set of final states so that it becomes

(F1 × Q2) ∪ (Q1 × F2).
Indeed, w ∈ L(D1) ∪ L(D2)

iff w ∈ L(D1) or w ∈ L(D2),
iff δ1∗(q0,1, w) ∈ F1 or δ2∗(q0,2, w) ∈ F2,
iff (δ1∗(q0,1, w), δ2∗(q0,2, w)) ∈ (F1 × Q2) ∪ (Q1 × F2),
iff δ ∗((q0,1, q0,2), w) ∈ (F1 × Q2) ∪ (Q1 × F2),
iff w ∈ L(D).
Thus, L(D) = L(D1) ∪ L(D2).
We can also modify D very easily to accept

L(D1) − L(D2).
We change the set of final states so that it becomes

F1 × (Q2 − F2).
Indeed, w ∈ L(D1) − L(D2)

iff w ∈ L(D1) and w ∈ / L(D2),
iff δ1∗(q0,1, w) ∈ F1 and δ2∗(q0,2, w) ∈ / F2 ,
iff (δ1∗(q0,1, w), δ2∗ (q0,2, w)) ∈ F1 × (Q2 − F2),
iff δ ∗((q0,1, q0,2), w) ∈ F1 × (Q2 − F2),
iff w ∈ L(D).
Thus, L(D) = L(D1) − L(D2).
In all cases, if D1 has n1 states and D2 has n2 states, the

DFA D has n1n2 states.
Definition 3.5. The equivalence problem for DFA’s

is the following problem: given some alphabet Σ, is there
an algorithm which takes as input any two DFA’s D1 and
D2 and decides whether L(D1) = L(D2).
The cross-product construction yields an algorithm for

deciding the equivalence problem for DFA’s; see the course
notes.
3.3 Nondeteterministic Finite Automata (NFA’s)
NFA’s are obtained from DFA’s by allowing multiple tran-

sitions from a given state on a given input.
This can be done by defining δ(p, a) as a subset of Q

rather than a single state. It will also be convenient to
allow transitions on input ϵ.
We let 2Q denote the set of all subsets of Q, including the

empty set. The set 2Q is the power set of Q.
3.3. NONDETETERMINISTIC FINITE AUTOMATA (NFA’S) 75
Example 4. A NFA for the language

L3 = {a, b}∗{abb}.
State set Q4 = {0, 1, 2, 3}.
Start state: 0.
Transition table δ4:
a b
0 {0, 1} {0}
1 ∅ {2}
2 ∅ {3}
3 ∅ ∅
a, b
a b b
0 1 2 3
Figure 3.4: NFA for {a, b}∗ {abb}

Example 5. Let Σ = {a1, . . . , an}, with n ≥ 2, let

Lin = {w ∈ Σ∗ | w contains an odd number of ai’s},
and let
Ln = L1n ∪ L2n ∪ · · · ∪ Lnn.
The language Ln consists of those strings in Σ∗ that con-

tain an odd number of some letter ai ∈ Σ.
Equivalently Σ∗ − Ln consists of those strings in Σ∗ with

an even number of every letter ai ∈ Σ.
It can be shown that every DFA accepting Ln has at least

2n states.
However, there is an NFA with 2n + 1 states accepting

Ln .
We define NFA’s as follows.

Definition 3.6. A nondeterministic finite automaton

(or NFA) is a quintuple N = (Q, Σ, δ, q0, F ), where
• Σ is a finite input alphabet;
• Q is a finite set of states;
• F is a subset of Q of final (or accepting) states;
• q0 ∈ Q is the start state (or initial state);
• δ is the transition function, a function
δ : Q × (Σ ∪ {ϵ}) → 2Q.
For any state p ∈ Q and any input a ∈ Σ ∪ {ϵ}, the

set of states δ(p, a) is uniquely determined. We write
q ∈ δ(p, a).
Given an NFA N = (Q, Σ, δ, q0, F ), we would like to

define the language accepted by N .
However, given an NFA N , unlike the situation for DFA’s,

given a state p ∈ Q and some input w ∈ Σ∗, in general
there is no unique path from p on input w, but instead
a tree of computation paths.
For example, given the NFA shown below,

a, b
a b b
0 1 2 3
from state 0 on input w = ababb we obtain the following

tree of computation paths:
0
a a
0 1
b
b
0 2
a a
0 1
b b
0 2
b b
0 3
Figure 3.6: A tree of computation paths on input ababb

Observe that there are three kinds of computation paths:

1. A path on input w ending in a rejecting state (for
example, the lefmost path).
2. A path on some proper prefix of w, along which the
computation gets stuck (for example, the rightmost
path).
3. A path on input w ending in an accepting state (such
as the path ending in state 3).
The acceptance criterion for NFA is very lenient: a string

w is accepted iff the tree of computation paths contains
some accepting path (of type (3)).
Thus, all failed paths of type (1) and (2) are ignored.
Furthermore, there is no charge for failed paths.
A string w is rejected iff all computation paths are failed

paths of type (1) or (2).
The “philosophy” of nondeterminism is that an NFA

“guesses” an accepting path and then checks it in poly-
nomial time by following this path. We are only charged
for one accepting path (even if there are several accepting
paths).
A way to capture this acceptance policy if to extend the

transition function δ : Q × (Σ ∪ {ϵ}) → 2Q to a function
δ ∗ : Q × Σ∗ → 2Q .
The presence of ϵ-transitions (i.e., when q ∈ δ(p, ϵ))

causes technical problems, and to overcome these prob-
lems, we introduce the notion of ϵ-closure.
3.4. ϵ-CLOSURE 81
3.4 ϵ-Closure
Definition 3.7. Given an NFA N = (Q, Σ, δ, q0, F )

(with ϵ-transitions) for every state p ∈ Q, the ϵ-closure
of p is set ϵ-closure(p) consisting of all states q such that
there is a path from p to q whose spelling is ϵ (an ϵ-path).
This means that either q = p, or that all the edges on

the path from p to q have the label ϵ.
We can compute ϵ-closure(p) using a sequence of approx-

imations as follows. Define the sequence of sets of states
(ϵ-cloi(p))i≥0 as follows:
ϵ-clo0(p) = {p},
ϵ-cloi+1(p) = ϵ-cloi(p) ∪
{q ∈ Q | ∃s ∈ ϵ-cloi(p), q ∈ δ(s, ϵ)}.
Since ϵ-cloi(p) ⊆ ϵ-cloi+1(p), ϵ-cloi(p) ⊆ Q, for all i ≥ 0,

and Q is finite, it can be shown that there is a smallest i,
say i0, such that
ϵ-cloi0 (p) = ϵ-cloi0+1(p).
It suffices to show that there is some i ≥ 0 such that

ϵ-cloi(p) = ϵ-cloi+1(p), because then there is a smallest
such i (since every nonempty subset of N has a smallest
element).
Assume by contradiction that
ϵ-cloi(p) ⊂ ϵ-cloi+1(p) for all i ≥ 0.
Then, I claim that |ϵ-cloi(p)| ≥ i + 1 for all i ≥ 0.
This is true for i = 0 since ϵ-clo0(p) = {p}.

3.4. ϵ-CLOSURE 83
Since ϵ-cloi(p) ⊂ ϵ-cloi+1(p), there is some q ∈ ϵ-cloi+1(p)

that does not belong to ϵ-cloi(p), and since by induction
|ϵ-cloi(p)| ≥ i + 1, we get
|ϵ-cloi+1(p)| ≥ |ϵ-cloi(p)| + 1 ≥ i + 1 + 1 = i + 2,
establishing the induction hypothesis.
If n = |Q|, then |ϵ-clon(p)| ≥ n + 1, a contradiction.
Therefore, there is indeed some i ≥ 0 such that

ϵ-cloi(p) = ϵ-cloi+1(p), and for the least such i = i0, we
have i0 ≤ n − 1.
It can also be shown that
ϵ-closure(p) = ϵ-cloi0 (p),
by proving that
1. ϵ-cloi(p) ⊆ ϵ-closure(p), for all i ≥ 0.
2. ϵ-closure(p)i ⊆ ϵ-cloi0 (p), for all i ≥ 0.
where ϵ-closure(p)i is the set of states reachable from p
by an ϵ-path of length ≤ i.
3.4. ϵ-CLOSURE 85
When N has no ϵ-transitions, i.e., when δ(p, ϵ) = ∅ for all

p ∈ Q (which means that δ can be viewed as a function
δ : Q × Σ → 2Q), we have
ϵ-closure(p) = {p}.
It should be noted that there are more efficient ways of

computing ϵ-closure(p), for example, using a stack (basi-
cally, a kind of depth-first search).
We present such an algorithm below. It is assumed that

the types NFA and stack are defined. If n is the number
of states of an NFA N , we let
eclotype = array[1..n] of boolean

function eclosure[N : NFA, p : integer] : eclotype;

begin
var eclo : eclotype, q, s : integer, st : stack;
for each q ∈ setstates(N ) do
eclo[q] := f alse;
endfor
eclo[p] := true; st := empty;
trans := deltatable(N );
st := push(st, p);
while st ̸= emptystack do
q = pop(st);
for each s ∈ trans(q, ϵ) do
if eclo[s] = f alse then
eclo[s] := true; st := push(st, s)
endif
endfor
endwhile;
eclosure := eclo
end
This algorithm can be easily adapted to compute the set

of states reachable from a given state p (in a DFA or an
NFA).
3.4. ϵ-CLOSURE 87
Given a subset S of Q, we define ϵ-closure(S) as

!
ϵ-closure(S) = ϵ-closure(s),
s∈S
with
ϵ-closure(∅) = ∅.
When N has no ϵ-transitions, we have
ϵ-closure(S) = S.
We are now ready to define the extension

δ ∗ : Q × Σ∗ → 2Q of the transition function
δ : Q × (Σ ∪ {ϵ}) → 2Q.
3.5 Converting an NFA into a DFA
The intuition behind the definition of the extended tran-

sition function is that δ ∗(p, w) is the set of all states
reachable from p by a path whose spelling is w.
Definition 3.8. Given an NFA N = (Q, Σ, δ, q0, F )

(with ϵ-transitions), the extended transition function
δ ∗ : Q × Σ∗ → 2Q is defined as follows: for every p ∈ Q,
every u ∈ Σ∗, and every a ∈ Σ,
δ ∗(p, ϵ) = ϵ-closure({p}),
" ! #
δ ∗(p, ua) = ϵ-closure δ(s, a) .
s∈δ ∗ (p,u)
In the second equation, if δ ∗(p, u) = ∅ then

δ ∗(p, ua) = ∅.
The language L(N ) accepted by an NFA N is the set
L(N ) = {w ∈ Σ∗ | δ ∗(q0, w) ∩ F ̸= ∅}.

3.5. CONVERTING AN NFA INTO A DFA 89
Observe that the definition of L(N ) conforms to the le-

nient acceptance policy: a string w is accepted iff δ ∗(q0, w)
contains some final state.
In order to convert an NFA into a DFA we also extend

δ ∗ : Q × Σ∗ → 2Q to a function
δ$: 2Q × Σ∗ → 2Q
defined as follows: for every subset S of Q, for every

w ∈ Σ∗ ,
!
$ w) =
δ(S, δ ∗(s, w),
s∈S
with
$ w) = ∅.
δ(∅,
Let Q be the subset of 2Q consisting of those subsets S

of Q that are ϵ-closed, i.e., such that
S = ϵ-closure(S).
If we consider the restriction
∆: Q × Σ → Q
of δ$: 2Q × Σ∗ → 2Q to Q and Σ, we observe that ∆ is

the transition function of a DFA.
Indeed, this is the transition function of a DFA accepting

L(N ). It is easy to show that ∆ is defined directly as
follows (on subsets S in Q):
"! #
∆(S, a) = ϵ-closure δ(s, a) ,
s∈S
with
∆(∅, a) = ∅.
Then, the DFA D is defined as follows:
D = (Q, Σ, ∆, ϵ-closure({q0}), F),
where F = {S ∈ Q | S ∩ F ̸= ∅}.
It is not difficult to show that L(D) = L(N ), that is, D

is a DFA accepting L(N ). For this, we show that
$ w).
∆∗(S, w) = δ(S,
Thus, we have converted the NFA N into a DFA D
(and gotten rid of ϵ-transitions).
Since DFA’s are special NFA’s, the subset construction

shows that DFA’s and NFA’s accept the same family of
languages, the regular languages, version 1 (although
not with the same complexity).
The states of the DFA D equivalent to N are ϵ-closed

subsets of Q. For this reason, the above construction is
often called the subset construction. This construction
is due to Rabin and Scott.
Michael Rabin and Dana Scott were awarded the presti-

gious Turing Award in 1976 for this important contribu-
tion and many others.
Although theoretically fine, the method may construct

useless sets S that are not reachable from the start state
ϵ-closure({q0}). A more economical construction is given
next.
An Algorithm to convert an NFA into a DFA:

The “subset construction”
Given an input NFA N = (Q, Σ, δ, q0, F ), a DFA D =
(K, Σ, ∆, S0, F) is constructed. It is assumed that K is
a linear array of sets of states S ⊆ Q, and ∆ is a 2-
dimensional array, where ∆[i, a] is the index of the target
state of the transition from K[i] = S on input a, with
S ∈ K, and a ∈ Σ.
S0 := ϵ-closure({q0}); total := 1; K[1] := S0;
marked := 0;
while marked < total do;
marked := marked + 1; S := K[marked];
for each a ∈ Σ do
%
U := s∈S δ(s, a); T := ϵ-closure(U );
if T ∈/ K then
total := total + 1; K[total] := T
endif;
∆[marked, a] := index(T )
endfor
endwhile;
F := {S ∈ K | S ∩ F ̸= ∅}
Let us illustrate the subset construction on the NFA of

Example 4.
A NFA for the language

L3 = {a, b}∗{abb}.
Transition table δ4:
a b
0 {0, 1} {0}
1 ∅ {2}
2 ∅ {3}
3 ∅ ∅
a, b
a b b
0 1 2 3

The pointer ⇒ corresponds to marked and the pointer

→ to total.
Initial transition table ∆.
⇒ index states a b
→ A {0}
Just after entering the while loop
index states a b
⇒→ A {0}
After the first round through the while loop.
index states a b
⇒ A {0} B A
→ B {0, 1}
After just reentering the while loop.
index states a b
A {0} B A
⇒→ B {0, 1}
After the second round through the while loop.
index states a b
A {0} B A
⇒ B {0, 1} B C
→ C {0, 2}
After the third round through the while loop.
index states a b
A {0} B A
B {0, 1} B C
⇒ C {0, 2} B D
→ D {0, 3}
After the fourth round through the while loop.
index states a b
A {0} B A
B {0, 1} B C
C {0, 2} B D
⇒→ D {0, 3} B A
This is the DFA of Figure 3.3, except that in that example

A, B, C, D are renamed 0, 1, 2, 3.
b
b a
a b b
0 1 2 3
a
Figure 3.8: DFA for {a, b}∗ {abb}

UNIT 1 PDF Cis262sl1aut

Uploaded by

Copyright:

Available Formats

UNIT 1 PDF Cis262sl1aut

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

UNIT 1 PDF Cis262sl1aut

Uploaded by

Copyright:

Available Formats

Chapter 3

DFA’s, NFA’s, Regular Languages

The family of regular languages is the simplest, yet inter-

We give six definitions of the regular languages.

We prove the equivalence of these definitions, often by

We find that the introduction of NFA’s is motivated by

To finish this conversion, we also show that every NFA can

So, although NFA’s often allow for more concise descrip-

NFA’s operate according to the paradigm: guess a suc-

This is the essence of an important class of hard problems

We will also discuss methods for proving that certain lan-

We present algorithms to convert a DFA to an equivalent

3.1 Deterministic Finite Automata (DFA’s)

First we define what DFA’s are, and then we explain how

The graph also satisfies certain properties that make it

Example 1. A DFA for the language

Input alphabet: Σ = {a, b}.

State set Q1 = {0, 1, 2, 3}.

Set of accepting states: F1 = {2}.

Transition table (function) δ1:

Note that state 3 is a trap state or dead state.

Here is a graph representation of the DFA specified by

Figure 3.1: DFA for {ab}+

Example 2. A DFA for the language

Input alphabet: Σ = {a, b}.

State set Q2 = {0, 1, 2}.

Set of accepting states: F2 = {0}.

Transition table (function) δ2:

State 2 is a trap state or dead state.

Here is a graph representation of the DFA specified by

Figure 3.2: DFA for {ab}∗

Example 3. A DFA for the language

Note that L3 consists of all strings of a’s and b’s ending

Input alphabet: Σ = {a, b}.

State set Q3 = {0, 1, 2, 3}.

Set of accepting states: F3 = {3}.

Transition table (function) δ3:

Here is a graph representation of the DFA specified by

Figure 3.3: DFA for {a, b}∗ {abb}

Is this a minimal DFA?

Definition 3.1. A deterministic finite automaton (or

For any state p ∈ Q and any input a ∈ Σ, the state

Thus, it is possible to define the state reached from a

Technically, this is done by defining the extended transi-

Definition 3.2. Given a DFA D = (Q, Σ, δ, q0, F ), the

where a ∈ Σ and u ∈ Σ∗.

It is immediate that δ ∗(p, a) = δ(p, a) for a ∈ Σ.

The meaning of δ ∗(p, w) is that it is the state reached

We can show (by induction on the length of v) that

For the induction step, for u ∈ Σ∗, and all v = ya with

δ ∗(p, uya) = δ(δ ∗(p, uy), a) by definition of δ ∗

We can now define how a DFA accepts or rejects a string.

Definition 3.3. Given a DFA D = (Q, Σ, δ, q0, F ), the

Thus, a string w ∈ Σ∗ is accepted iﬀ the path from q0 on

The definition of a DFA does not prevent the possibility

For example, in the DFA D1 defined by the transition

Since there is no path from the start state 0 to any of the

Given a DFA D = (Q, Σ, δ, q0, F ), the above suggests

Qr = {p ∈ Q | (∃u ∈ Σ∗)(p = δ ∗(q0, u))}.

The set Qr consists of those states p ∈ Q such that there