Introduction to Automata Theory

Introduction to Finite Automata: Structural Representations,

Automata and Complexity, the Central Concepts of Automata
Theory – Alphabets, Strings, Languages, Problems.
Nondeterministic Finite Automata: Formal Definition, an
application, Text Search, Finite Automata with Epsilon-Transitions.
Deterministic Finite Automata: Definition of DFA, How A DFA
Process Strings, The language of DFA, Conversion of NFA with €-
transitions to NFA without €-transitions. Conversion of NFA to
DFA, Moore and Melay machines
1
 What is Automata Theory?
• Theory of automata is a theoretical branch of
computer science and mathematical. It is the study
of abstract machines and the computation
problems that can be solved using these machines.
The abstract machine is called the automata. The
main motivation behind developing the automata
theory was to develop methods to describe and
analyse the dynamic behaviour of discrete
systems.

2
 Why Study Automata Theory?
Finite automata are a useful model for many important kinds of software and
hardware:
1. Software for designing and checking the behavior of digital
circuits
2. The lexical analyzer of a typical compiler, that is, the compiler component
that breaks the input text into logical units
3. Software for scanning large bodies of text, such as collections of Web
pages, to find occurrences of words, phrases or other patterns
4. Software for verifying systems of all types that have a finite number of
distinct states, such as communications protocols of protocols for secure
exchange information

3
(A pioneer of automata theory)
Alan Turing (1912-1954)
• Father of Modern Computer Science
• English mathematician
• Studied abstract machines called
Turing machines even before
computers existed
• Heard of the Turing test?

4
Theory of Computation: A
Historical Perspective
1930s • Alan Turing studies Turing machines
• Decidability
• Halting problem
1940-1950s • “Finite automata” machines studied
• Noam Chomsky proposes the
“Chomsky Hierarchy” for formal
languages
1969 Cook introduces “intractable” problems
or “NP-Hard” problems
1970- Modern computer science: compilers,
computational & complexity theory5evolve
 Languages & Grammars
• Languages: “A language is a
Or “words” collection of sentences of finite
length all constructed from a
finite alphabet of symbols”
• Grammars: “A grammar can be
regarded as a device that
enumerates the sentences of a
language” - nothing more,
nothing less

• N. Chomsky, Information and

Control, Vol 2, 1959

Image source: Nowak et al. Nature, vol 417, 2002

6
 Finite Automata
• Finite automata are used to recognize patterns.
• It takes the string of symbol as input and changes its state
accordingly. When the desired symbol is found, then the
transition occurs.
• At the time of transition, the automata can either move to
the next state or stay in the same state.
• Finite automata have two states, Accept state or Reject
state. When the input string is processed successfully, and
the automata reached its final state, then it will accept.

7
 Automata and Complexity,
• Automata theory:
Automata theory deals with the theory with which these machines work.. An
automaton can be in various states. One state is the state the automaton starts in and
the others are the final or exit states.

• Some of the models are:

i. Finite Automata: These are used in text processing, compilers, and
hardware design.
ii. Context-Free Grammars: There are used to define programming
languages and in Artificial Intelligence
iii. Turing machines: Abstract models of the simple PCs we have at
home.

8
 Finite Automata Model
Structural Representations
finite automata can be represented by input tape
and finite control.
•Input tape: It is a linear tape having some
number of cells. Each input symbol is placed in
each cell.
•Finite control: The finite control decides the
next state on receiving particular input from
input tape. The tape reader reads the cells one by
one from left to right, and at a time only one
input symbol is read.

9
 Automata and Complexity
Computational Complexity Theory:
•Computational Complexity Theory deals with the efficiency
with which a computer can solve a problem. Time and Space
are considered to be the two vectors responsible for a problems
efficiency.

•This theory mainly asks a general question about possible

algorithm to solve a problem, whereas analysis of algorithms
involves analyzing the amount of resources needed to solve a
problem.

10
The Central Concepts of
Automata Theory

11
 Alphabet:
An alphabet is a finite, non-empty set of symbols
• We use the symbol ∑ (sigma) to denote an
alphabet
• Examples:
– Binary: ∑ = {0,1}
– All lower case letters: ∑ = {a,b,c,..z}
– Alphanumeric: ∑ = {a-z, A-Z, 0-9}
– DNA molecule letters: ∑ = {a,c,g,t}

12
 Strings
A string or word is a finite sequence of symbols
chosen from ∑
• Empty string is  (or “epsilon”)
Length of a String:
• Length of a string w, denoted by “|w|”, is equal to
the number of (non- ) characters in the string
– E.g., x = 010100 |x| = 6
– x = 01  0  1  00  |x| = ?
– xy = concatentation of two strings x and y

13
 Powers of an alphabet
Kleene Star
Definition: The Kleene star, Σ * , is a unary operator
on a set of symbols or strings, Σ, that gives the
infinite set of all possible strings of all possible
lengths over Σ including λ.
Representation: Σ * = Σ0 U Σ1 U Σ2 U… Σp where
Σp is the set of all possible strings of length p.
Example: If Σ = {a, b}, Σ *= {λ, a, b, aa, ab, ba, bb,
………..}
14
 Powers of an alphabet
Kleene Closure / Plus
Definition: The set Σ + is the infinite set of all
possible strings of all possible lengths over Σ
excluding λ.
Representation: Σ + = Σ1 U Σ2 U Σ3
Σ + = Σ* − { λ }
Example: If Σ = { a, b } , Σ+ ={ a, b, aa, ab, ba, bb,
………..}
15
 Languages
L is a said to be a language over alphabet ∑, only if L  ∑*
 this is because ∑* is the set of all strings (of all possible length
including 0) over the given alphabet ∑
Examples:
1. Let L be the language of all strings consisting of n 0’s followed by n
1’s:
L = {, 01, 0011, 000111,…}
2. Let L be the language of all strings of with equal number of 0’s and 1’s:
L = {, 01, 10, 0011, 1100, 0101, 1010, 1001,…}

Definition: Ø denotes the Empty language

Canonical ordering of strings in the language
• Let L = {}; Is L=Ø?

NO 16
 The Membership Problem
Given a string w ∑*and a language L over
∑, decide whether or not w L.

Example:
Let w = 100011
Q) Is w  the language of strings with equal
number of 0s and 1s?
17
 Finite Automata : Examples
action
• On/Off switch state

• Modeling recognition of the word “then”

Start state Transition Intermediate Final state

state
18
 Types of Finite Automata
• Deterministic Finite Automaton (DFA)

• Nondeterministic Finite Automaton (NFA)

19
 Formal Definition of a DFA

• A DFA is a five-tuple:

M = (Q, Σ, δ, q0, F)

Q A finite set of states

Σ A finite input alphabet
q0 The initial/starting state, q0 is in Q
F A set of final/accepting states, which is a subset of Q
δ A transition function, which is a total function from Q x Σ to Q

δ: (Q x Σ) –> Q δ is defined for any q in Q and s in Σ, and

δ(q,s) = q’ is equal to some state q’ in Q, could be q’=q

Intuitively, δ(q,s) is the state entered by M after reading symbol s while in

state q.
20
• Revisit example #1:
1
Q = {q0, q1}
0
Σ = {0, 1}
q0 q1 1
Start state is q0
0
F = {q0}

δ:
0 1
q0 q1 q0

q1 q0 q1

21
• Revisit example #2:

a a a/b/c
Q = {q0, q1, q2}
c c
Σ = {a, b, c} q0 q1 q2
Start state is q0
F = {q2} b b

δ: a b c
q0 q0 q0 q1

q1 q1 q1 q2

q2 q2 q2 q2

• Since δ is a function, at each step M has exactly one option.

• It follows that for a given string, there is exactly one computation. 22
 Extension of δ to Strings

δ^ : (Q x Σ*) –> Q

δ^(q,w) – The state entered after reading string w having started in state q.

Formally:

1) δ^(q, ε) = q, and
2) For all w in Σ* and a in Σ
δ^(q,wa) = δ (δ^(q,w), a)

23
• Recall Example #1: 1

0
q0 q1 1
0
• What is δ^(q0, 011)? Informally, it is the state entered by M after processing
011 having started in state q 0.
• Formally:

δ^(q0, 011) = δ (δ^(q0,01), 1) by rule #2

= δ (δ ( δ^(q0,0), 1), 1) by rule #2
= δ (δ (δ (δ^(q0, λ), 0), 1), 1) by rule #2
= δ (δ (δ(q0,0), 1), 1) by rule #1
= δ (δ (q1, 1), 1) by definition of δ
= δ (q1, 1) by definition of δ
= q1 by definition of δ

• Is 011 accepted? No, since δ ^(q0, 011) = q1 is not a final state. 24

• Note that:

δ^ (q,a) = δ(δ^(q, ε), a) by definition of δ^, rule

#2
= δ(q, a) by definition of δ^, rule
#1

• Therefore:

δ^ (q, a1a2…an) = δ(δ(…δ(δ(q, a1), a2)…), an)

• However, we will abuse notations, and use δ in place of δ ^:

δ^(q, a1a2…an) = δ(q, a1a2…an) 25

• Example #3:
1 1 1
0
0
q0 q1 q2
0
• What is δ(q0, 011)? Informally, it is the state entered by M after
processing 011 having started in state q 0.
• Formally:
δ(q0, 011) = δ (δ(q0,01), 1) by rule #2
= δ (δ (δ(q0,0), 1), 1) by rule #2
= δ (δ (q1, 1), 1) by definition of δ
= δ (q1, 1) by definition of δ
= q1 by definition of δ

• Is 011 accepted? No, since δ(q0, 011) = q1 is not a final state.

• Language?
• L ={ all strings over {0,1} that has 2 or more 0 symbols} 26
• Recall Example #3:
1 1 1
0
0
q0 q1 q2
0

• What is δ(q1, 10)?

δ(q1, 10) = δ (δ(q1,1), 0) by rule #2

= δ (q1, 0) by definition of
δ
= q2 by definition of
δ

• Is 10 accepted? No, since δ(q0, 10) = q1 is not a final state. The fact
that δ(q1, 10) = q2 is irrelevant, q1 is not the start state!

27
 Definitions related to DFAs
• Let M = (Q, Σ, δ,q0,F) be a DFA and let w be in Σ*. Then w is accepted by M
iff δ(q0,w) = p for some state p in F.

• Let M = (Q, Σ, δ,q0,F) be a DFA. Then the language accepted by M is the

set:

L(M) = {w | w is in Σ* and δ(q0,w) is in F}

• Another equivalent definition:

L(M) = {w | w is in Σ* and w is accepted by M}

• Let L be a language. Then L is a regular language iff there exists a DFA

M such that L = L(M).

• Let M1 = (Q1, Σ1, δ1, q0, F1) and M2 = (Q2, Σ2, δ2, p0, F2) be DFAs. Then M1
28
and M2 are equivalent iff L(M1) = L(M2).
• Notes:
– A DFA M = (Q, Σ, δ,q0,F) partitions the set Σ* into two sets: L(M) and
Σ* - L(M).

– If L = L(M) then L is a subset of L(M) and L(M) is a subset of L (def. of set

equality).

– Similarly, if L(M1) = L(M2) then L(M1) is a subset of L(M2) and L(M2) is a subset of
L(M1).

– Some languages are regular, others are not. For example, if

Regular: L1 = {x | x is a string of 0's and 1's containing an even

number of 1's} and

Not-regular: L2 = {x | x = 0n1n for some n >= 0}

• Can you write a program to “simulate” a given DFA, or any arbitrary input DFA?

• Question we will address later:

– How do we determine whether or not a given language is regular?
29
• Give a DFA M such that:

L(M) = {x | x is a string of 0’s and 1’s and |x| >= 2}

0/1

0/1 0/1
q0 q1 q2

Prove this by induction

30
• Give a DFA M such that:

L(M) = {x | x is a string of (zero or more) a’s, b’s and c’s such

that x does not contain the substring aa}

b/c a/b/c
a
a
q0 q1 q2
b/c

Logic:
In Start state (q0): b’s and c’s: ignore – stay in same state
q0 is also “accept” state
First ‘a’ appears: get ready (q1) to reject
But followed by a ‘b’ or ‘c’: go back to start state q0
When second ‘a’ appears after the “ready” state: go to reject state q2
Ignore everything after getting to the “reject” state q2 31
• Give a DFA M such that:

L(M) = {x | x is a string of a’s, b’s and c’s such that

x
contains the substring aba}

b/c a a/b/c
a a
b
q0 q1 q2 q3
c

b/c

Logic: acceptance is straight forward, progressing on each expected

symbol
However, rejection needs special care, in each state (for DFA, we will see
this becomes easier in NFA, non-deterministic machine)

32
• Give a DFA M such that:

L(M) = {x | x is a string of a’s and b’s such that x

contains both aa and bb}
First do, for a language where ‘aa’ comes before ‘bb’
Then do its reverse; and then parallelize them.
a
b
a
q1 q2 q3
b a/b
a a

q0 a b q7
b
b a
b a
q4 q5 q6
b

Remember, you may have multiple “final” states, but only one “start”
state 33
• Let Σ = {0, 1}. Give DFAs for {}, {ε}, Σ*, and Σ+.

For {}: For {ε}:

0/1
0/1
0/1
q0 q0 q1

For Σ*: For Σ+:

0/1 0/1

0/1
q0 q0 q1

34
• Problem: Third symbol from last is 1

0/1

1 0/1 0/1
q0 q1 q2 q3

Is this a DFA?

No, but it is a Non-deterministic Finite Automaton

35
 Nondeterministic Finite State
Automata (NFA)

• An NFA is a five-tuple:

M = (Q, Σ, δ, q0, F)

Q A finite set of states

Σ A finite input alphabet
q0 The initial/starting state, q0 is in Q
F A set of final/accepting states, which is a subset of Q
δ A transition function, which is a total function from Q x Σ to 2 Q

δ: (Q x Σ) –> 2Q :2Q is the power set of Q, the set of all subsets of

Q δ(q,s) :The set of all states p such that there is a
transition
labeled s from q to p

36
δ(q,s) is a function from Q x S to 2Q (but not only to Q)
• Example #1: one or more 0’s followed by one or more 1’s

0 1 0/1
Q = {q0, q1, q2}
0 1
Σ = {0, 1} q0 q1 q2
Start state is q0
F = {q2}

δ: 0 1
q0 {q0, q1} {}

{} {q1, q2}
q1
{q2} {q2}
q2

37
• Example #2: pair of 0’s or pair of 1’s as substring

0/1 0/1
Q = {q0, q1, q2 , q3 , q4}
Σ = {0, 1} 0 0
q0 q3 q4
Start state is q0
1 0/1
F = {q2, q4}
1
δ: 0 1 q1 q2
q0 {q0, q3} {q0, q1}

{} {q2}
q1
{q2} {q2}
q2
{q4} {}
q3
{q4} {q4}
q4 38
• Notes:
– δ(q,s) may not be defined for some q and s (what does that mean?)
– δ(q,s) may map to multiple q’s
– A string is said to be accepted if there exists a path from q0 to some state
in F
– A string is rejected if there exist NO path to any state in F
– The language accepted by an NFA is the set of all accepted strings

• Question: How does an NFA find the correct/accepting path for a

given string?
– NFAs are a non-intuitive computing model
– You may use backtracking to find if there exists a path to a final state
(following slide)
• Why NFA?
– We are primarily interested in NFAs as language defining capability, i.e.,
do NFAs accept languages that DFAs do not?
– Other secondary questions include practical ones such as whether or not
NFA is easier to develop, or how does one implement NFA 39
• Determining if a given NFA (example #2) accepts a given string (001) can
be done algorithmically:

q0 0 q0 0 q0 1 q0

q3 q3 q1

q4 q4 accepted

• Each level will have at most n states:

Complexity: O(|x|*n), for running over a string x
0/1 0/1

0 0
q0 q3 q4
1 0/1

1
q1 q2
40
• Another example (010):

q0 0 q0 1 q0 0 q0

q3 q1 q3

not accepted

• All paths have been explored, and none lead to an accepting state.

0/1

0 0
q0 q3 q4
1

1
q1 q2
41
• Question: Why non-determinism is useful?
–Non-determinism = Backtracking
–Compressed information
–Non-determinism hides backtracking
–Programming languages, e.g., Prolog, hides backtracking => Easy to
program at a higher level: what we want to do, rather than how to do it
–Useful in algorithm complexity study

–Is NDA more “powerful” than DFA, i.e., accepts type of languages that any
DFA cannot?

42
• Let Σ = {a, b, c}. Give an NFA M that accepts:

L = {x | x is in Σ* and x contains ab}

a/b/c a/b/c

a b
q0 q1 q2

Is L a subset of L(M)? Or, does M accepts all string in L?

Is L(M) a subset of L? Or, does M rejects all strings not in L?

• Is an NFA necessary? Can you draw a DFA for this L?

• Designing NFAs is not as trivial as it seems: easy to create bug
accepting string outside language
43
• Let Σ = {a, b}. Give an NFA M that accepts:

L = {x | x is in Σ* and the third to the last symbol in x is b}

a/b

b a/b a/b q3
q0 q1 q2

Is L a subset of L(M)?
Is L(M) a subset of L?

• Give an equivalent DFA as an exercise.

44
 Extension of δ to Strings and Sets of States
• What we currently have: δ : (Q x Σ) –> 2Q

• What we want (why?): δ : (2Q x Σ*) –> 2Q

• We will do this in two steps, which will be slightly different from the
book, and we will make use of the following NFA.
0
0 1
q0 q1 q2

0 1 0
0

q3 q4
1
0 45
 Extension of δ to Strings and Sets of States

• Step #1:

Given δ: (Q x Σ) –> 2Q define δ#: (2Q x Σ) –> 2Q as follows:

1) δ#(R, a) = δ(q, a) for all subsets R of Q, and symbols a in Σ

qR

• Note that:

δ#({p},a)=
q{ p }
δ(q, a) by definition of δ#, rule #1 above
= δ(p, a)

• Hence, we can use δ for δ#

δ({q0, q2}, 0) These now make sense, but previously

δ({q0, q1, q2}, 0) they did not.
46
• Example:

δ({q0, q2}, 0) = δ(q0, 0) U δ(q2, 0)

= {q1, q3} U {q3, q4}
= {q1, q3, q4}

δ({q0, q1, q2}, 1) = δ(q0, 1) U δ(q1, 1) U δ(q2, 1)

= {} U {q2, q3} U {}
= {q2, q3}

47
• Step #2:

Given δ: (2Q x Σ) –> 2Q define δ^: (2Q x Σ*) –> 2Q as follows:

δ^(R,w) – The set of states M could be in after processing string w, having

started from any state in R.

Formally:

2) δ^(R, ε) = R for any subset R of Q

3) δ^(R,wa) = δ (δ^(R,w), a) for any w in Σ*, a in Σ, and
subset R of Q
• Note that:

δ^(R, a) = δ(δ^(R, ε), a) by definition of δ^, rule #3 above

= δ(R, a) by definition of δ^, rule #2 above

• Hence, we can use δ for δ^

δ({q0, q2}, 0110) These now make sense, but previously

δ({q0, q1, q2}, 101101) they did not. 48
• Example:

1 0
0 q1 1 q2
q0

0 1
1

q3

What is δ({q0}, 10)?

Informally: The set of states the NFA could be in after processing 10,
having started in state q0, i.e., {q1, q2, q3}.

Formally: δ({q0}, 10) = δ(δ({q0}, 1), 0)

= δ({q0}, 0)
= {q1, q2, q3}
Is 10 accepted? Yes! 49
• Example:

What is δ({q0, q1}, 1)?

δ({q0 , q1}, 1) = δ({q0}, 1)  δ({q1}, 1)

= {q0}  {q2, q3}
= {q0, q2, q3}

What is δ({q0, q2}, 10)?

δ({q0 , q2}, 10) = δ(δ({q0 , q2}, 1), 0)

= δ(δ({q0}, 1) U δ({q2}, 1), 0)
= δ({q0}  {q3}, 0)
= δ({q0,q3}, 0)
= δ({q0}, 0)  δ({q3}, 0)
= {q1, q2, q3}  {}
50
= {q1, q2, q3}
• Example:

δ({q0}, 101) = δ(δ({q0}, 10), 1)

= δ(δ(δ({q0}, 1), 0), 1)
= δ(δ({q0}, 0), 1)
= δ({q1 , q2, q3}, 1)
= δ({q1}, 1) U δ({q2}, 1) U δ({q3}, 1)
= {q2, q3} U {q3} U {}
= {q2, q3}

Is 101 accepted? Yes! q3 is a final state.

51
 Definitions for NFAs

• Let M = (Q, Σ, δ,q0,F) be an NFA and let w be in Σ*. Then w is

accepted by M iff δ({q0}, w) contains at least one state in F.

• Let M = (Q, Σ, δ,q0,F) be an NFA. Then the language accepted by M

is the set:

L(M) = {w | w is in Σ* and δ({q0},w) contains at least one state in F}

• Another equivalent definition:

L(M) = {w | w is in Σ* and w is accepted by M}

52
 Equivalence of DFAs and NFAs
• Do DFAs and NFAs accept the same class of languages?
– Is there a language L that is accepted by a DFA, but not by any NFA?
– Is there a language L that is accepted by an NFA, but not by any DFA?

• Observation: Every DFA is an NFA, DFA is only restricted NFA.

• Therefore, if L is a regular language then there exists an NFA M such

that L = L(M).

• It follows that NFAs accept all regular languages.

• But do NFAs accept more?

53
• Consider the following DFA: 2 or more c’s

a a a/b/c
Q = {q0, q1, q2}
c c
Σ = {a, b, c} q0 q1 q2
Start state is q0
F = {q2} b b

δ: a b c
q0 q0 q0 q1

q1 q1 q1 q2

q2 q2 q2 q2

54
• An Equivalent NFA:

a a a/b/c
Q = {q0, q1, q2}
c c
Σ = {a, b, c} q0 q1 q2
Start state is q0
F = {q2} b b

δ: a b c
q0 {q0} {q0} {q1}

q1 {q1} {q1} {q2}

q2 {q2} {q2} {q2}

55
• Lemma 1: Let M be an DFA. Then there exists a NFA M’ such that
L(M) = L(M’).

• Proof: Every DFA is an NFA. Hence, if we let M’ = M, then it

follows that L(M’) = L(M).

The above is just a formal statement of the observation from the

previous slide.

56
• Lemma 2: Let M be an NFA. Then there exists a DFA M’ such that L(M) =
L(M’).

• Proof: (sketch)

Let M = (Q, Σ, δ,q0,F).

Define a DFA M’ = (Q’, Σ, δ’,q’0,F’) as:

Q’ = 2Q Each state in M’ corresponds to a

= {Q0, Q1,…,} subset of states from M

where Qu = [qi0, qi1,…qij]

F’ = {Qu | Qu contains at least one state in F}

q’0 = [q0]

δ’(Qu, a) = Qv iff δ(Qu, a) = Qv 57

• Example: empty string or start and end with 0
0/1
Q = {q0, q1} 0
Σ = {0, 1} q0 q1
Start state is q0 0
F = {q0}

δ: 0 1
q0 {q1} {}

{q0, q1} {q1}

q1

58
• Example of creating a DFA out of an NFA (as per the constructive
proof): 0/1
0
q0 q1
0
-->q0

δ for DFA: 0 1 q1
->q{q0 1} {}
write as
write as
[q1] []

[q1]
[]

59
• Example of creating a DFA out of an NFA (as per the constructive
proof): 0/1
0
q0 q1
0

δ: 0 1
->q{q0 1} {}
write as
[q1]
{q ,q } {q1}
] 0 1as
[q1write
[q01]

[]
[q01]

60
• Example of creating a DFA out of an NFA (as per the constructive
proof): 0/1
0
q0 q1
0

δ: 0 1
->q{q0 1} {}
write as
[q1]
{q ,q } {q1}
] 0 1as
[q1write
[q01]
[] []
[]
[q01]

61
• Example of creating a DFA out of an NFA (as per the constructive
proof): 0/1
0
q0 q1
0

δ: 0 1
->q{q0 1} {}
write as
[q1]
{q ,q } {q1}
] 0 1as
[q1write
[q01]
[] []
[ ] [q ] [q1]
01

[q01]

62
• Construct DFA M’ as follows:
1
0/1
1 [q0]
0 [q1]
[]

1
[q0q1]

0
δ({q0}, 0) = {q1} => δ’([q0], 0) = [q1]
δ({q0}, 1) = {} => δ’([q0], 1) = [ ]
δ({q1}, 0) = {q0, q1} => δ’([q1], 0) = [q0q1]
δ({q1}, 1) = {q1} => δ’([q1], 1) = [q1]
δ({q0, q1}, 0) = {q0, q1} => δ’([q0q1], 0) = [q0q1]
δ({q0, q1}, 1) = {q1} => δ’([q0q1], 1) = [q1]
δ({}, 0) = {} => δ’([ ], 0) = [ ]
δ({}, 1) = {} => δ’([ ], 1) = [ ] 63
• Theorem: Let L be a language. Then there exists an DFA M such
that L = L(M) iff there exists an NFA M’ such that L = L(M’).

• Proof:
(if) Suppose there exists an NFA M’ such that L = L(M’). Then by
Lemma 2 there exists an DFA M such that L = L(M).

(only if) Suppose there exists an DFA M such that L = L(M). Then by
Lemma 1 there exists an NFA M’ such that L = L(M’).

• Corollary: The NFAs define the regular languages.

64
• Note: Suppose R = {}

δ(R, 0) = δ(δ(R, ε), 0)

= δ(R, 0)

= δ(q, 0)
qR

= {} Since R = {}

• Exercise - Convert the following NFA to a DFA:

Q = {q0, q1, q2} δ: 0 1

Σ = {0, 1}
Start state is q0 q0 {q0, q1} {}
F = {q0}
{q1} {q2}
q1

q2 {q2} {q2}

65
• Problem: Third symbol from last is 1

0/1

1 0/1 0/1
q0 q1 q2 q3

Now, can you convert this NFA to a DFA?

66
 NFAs with ε Moves

• An NFA-ε is a five-tuple:

M = (Q, Σ, δ, q0, F)

Q A finite set of states

Σ A finite input alphabet
q0 The initial/starting state, q 0 is in Q
F A set of final/accepting states, which is a subset of Q
δ A transition function, which is a total function from Q x Σ U {ε} to 2 Q

δ: (Q x (Σ U {ε})) –> 2Q
δ(q,s) -The set of all states p such that there is a
transition labeled a from q to p, where a
is in Σ U {ε}
• Sometimes referred to as an NFA-ε other times, simply as an NFA.
67
• Example: q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0

δ: 0 1 ε
q0 {q0} {} {q1} - A string w = w1w2…wn is
processed
{q1, q2} {q0, q3} {q2} as w = ε*w1ε*w2ε* … ε*wnε*
q1 - Example: all computations on 00:
{q2} {q2} {} 0
ε 0
q2 q0 q0 q1 q2
{} {} {}
:
q3 68
 Informal Definitions

• Let M = (Q, Σ, δ,q0,F) be an NFA-ε.

• A String w in Σ* is accepted by M iff there exists a path in M from q0 to a state

in F labeled by w and zero or more ε transitions.

• The language accepted by M is the set of all strings from Σ * that are accepted
by M.

69
 ε-closure
• Define ε-closure(q) to denote the set of all states reachable from q by zero or
more ε transitions.

• Examples: (for the previous NFA)

ε-closure(q0) = {q0, q1, q2} ε-closure(q2) = {q2}

ε-closure(q1) = {q1, q2} ε-closure(q3) = {q3}

• ε-closure(q) can be extended to sets of states by defining:

ε-closure(P)=
qP ε-closure(q) q3
1
• Examples: 0 0 0/1
ε ε
q0 q1 q2
ε-closure({q1, q2}) = {q1, q2} 1 0
ε-closure({q0, q3}) = {q0, q1, q2, q3} 70
 Extension of δ to Strings and Sets of States
• What we currently have: δ : (Q x (Σ U {ε})) –> 2Q

• What we want (why?): δ : (2Q x Σ*) –> 2Q

• As before, we will do this in two steps, which will be slightly different

from the book, and we will make use of the following NFA.

q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0
71
• Step #1:

Given δ: (Q x (Σ U {ε})) –> 2Q define δ#: (2Q x (Σ U {ε})) –> 2Q as

follows:

1) δ#(R, a) = δ(q, a) for all subsets R of Q, and symbols a in Σ U {ε}

qR

• Note that:

δ#({p},a)= δ(q, a) by definition of δ #, rule #1 above

q{ p }

= δ(p, a)

• Hence, we can use δ for δ#

δ({q0, q2}, 0) These now make sense, but

previously
δ({q0, q1, q2}, 0) they did not.
72
• Examples:

What is δ({q0 , q1, q2}, 1)?

δ({q0 , q1, q2}, 1) = δ(q0, 1) U δ(q1, 1) U δ(q2, 1)

= { } U {q0, q3} U {q2}
= {q0, q2, q3}

What is δ({q0, q1}, 0)?

δ({q0 , q1}, 0) = δ(q0, 0) U δ(q1, 0)

= {q0} U {q1, q2}
= {q0, q1, q2}
73
• Step #2:

Given δ: (2Q x (Σ U {ε})) –> 2Q define δ^: (2Q x Σ*) –> 2Q as follows:

δ^(R,w) – The set of states M could be in after processing string w,

having starting from any state in R.

Formally:

2) δ^(R, ε) = ε-closure(R) - for any subset R of Q

3) δ^(R,wa) = ε-closure(δ(δ^(R,w), a)) - for any w in Σ*, a in Σ,
and
subset R of Q

• Can we use δ for δ^?

74
• Consider the following example:

δ({q0}, 0) = {q0}

δ^({q0}, 0) = ε-closure(δ(δ^({q0}, ε), 0)) By rule #3

= ε-closure(δ(ε-closure({q0}), 0)) By rule #2
= ε-closure(δ({q0, q1, q2}, 0)) By ε-closure
= ε-closure(δ(q0, 0) U δ(q1, 0) U δ(q2, 0)) By rule #1
= ε-closure({q0} U {q1, q2} U {q2})
= ε-closure({q0, q1, q2})
= ε-closure({q0}) U ε-closure({q1}) U ε-closure({q2})
= {q0, q1, q2} U {q1, q2} U {q2}
= {q0, q1, q2}

• So what is the difference?

δ(q0, 0) - Processes 0 as a single symbol, without ε transitions.

75
δ^(q0 , 0) - Processes 0 using as many ε transitions as are possible.
• Example:

δ^({q0}, 01) = ε-closure(δ(δ^({q0}, 0), 1)) By rule #3

= ε-closure(δ({q0, q1, q2}), 1) Previous
slide
= ε-closure(δ(q0, 1) U δ(q1, 1) U δ(q2, 1)) By rule #1
= ε-closure({ } U {q0, q3} U {q2})
= ε-closure({q0, q2, q3})
= ε-closure({q0}) U ε-closure({q2}) U ε-closure({q3})
= {q0, q1, q2} U {q2} U {q3}
= {q0, q1, q2, q3}

76
 Definitions for NFA-ε Machines

• Let M = (Q, Σ, δ,q0,F) be an NFA-ε and let w be in Σ*. Then w is

accepted by M iff δ^({q0}, w) contains at least one state in F.

• Let M = (Q, Σ, δ,q0,F) be an NFA-ε. Then the language accepted by

M is the set:

L(M) = {w | w is in Σ* and δ^({q0},w) contains at least one state in F}

• Another equivalent definition:

L(M) = {w | w is in Σ* and w is accepted by M}

77
 Equivalence of NFAs and NFA-εs
• Do NFAs and NFA-ε machines accept the same class of languages?
– Is there a language L that is accepted by a NFA, but not by any NFA -ε?
– Is there a language L that is accepted by an NFA -ε, but not by any DFA?

• Observation: Every NFA is an NFA-ε.

• Therefore, if L is a regular language then there exists an NFA-ε M

such that L = L(M).

• It follows that NFA-ε machines accept all regular languages.

• But do NFA-ε machines accept more?

78
• Lemma 1: Let M be an NFA. Then there exists a NFA-ε M’ such
that L(M) = L(M’).

• Proof: Every NFA is an NFA-ε. Hence, if we let M’ = M, then it

follows that L(M’) = L(M).

The above is just a formal statement of the observation from the

previous slide.

79
• Lemma 2: Let M be an NFA-ε. Then there exists a NFA M’ such
that L(M) = L(M’).

• Proof: (sketch)

Let M = (Q, Σ, δ,q0,F) be an NFA-ε.

Define an NFA M’ = (Q, Σ, δ’,q0,F’) as:

F’ = F U {q} if ε-closure(q) contains at least one state from F

F’ = F otherwise

δ’(q, a) = δ^(q, a) - for all q in Q and a in Σ

• Notes:
– δ’: (Q x Σ) –> 2Q is a function
– M’ has the same state set, the same alphabet, and the same start state as M
80
– M’ has no ε transitions
• Example:
q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0

• Step #1:
– Same state set as M
– q0 is the starting state q3

q0 q1 q2

81
• Example:
q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0

• Step #2:
– q0 becomes a final state q3

q0 q1 q2

82
• Example:
q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0

• Step #3:
q3

0
0
q0 q1 q2

83
• Example:
q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0

• Step #4:
q3

1
0/1

0/1
q0 q1 q2

0/1

84
• Example:
q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0

• Step #5:
q3

1
0/1
0
0/1 0
q0 q1 q2

0/1

85
• Example:
q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0

• Step #6:
q3

1
0/1 1
0/1
0/1 0/1
q0 q1 q2
1
0/1

86
• Example:
q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0

• Step #7:
q3

1
0/1 1 0
0/1
0/1 0/1
q0 q1 q2
1
0/1

87
• Example:
q3
1
0 0 0/1
ε ε
q0 q1 q2
1 0

• Step #8: [use table of e-closure]

– Done! q3

1
0/1 1 0/1
0/1
0/1 0/1
q0 q1 q2
1
0/1

88
• Theorem: Let L be a language. Then there exists an NFA M such
that L= L(M) iff there exists an NFA-ε M’ such that L = L(M’).

• Proof:
(if) Suppose there exists an NFA-ε M’ such that L = L(M’). Then by
Lemma 2 there exists an NFA M such that L = L(M).

(only if) Suppose there exists an NFA M such that L = L(M). Then by
Lemma 1 there exists an NFA-ε M’ such that L = L(M’).

• Corollary: The NFA-ε machines define the regular languages.

89