1
Regular Expression, DFA and
NFA
Prepared by:
Prof. J. S. Dhobi
Prof. M. D. Mehta
Regular Expressions 2
Regular expressions describe regular languages .
Notation to specify a language
In a regular expression, x* means zero or more occurrence of x. It can generate {e, x,
xx, xxx, xxxx, .....}
In a regular expression, x+ means one or more occurrence of x. It can generate {x, xx,
xxx, xxxx, .....}
Example: describes the language
(a b c) *
a, bc * , a, bc, aa, abc, bca,...
Definition of a Regular Expression 3
R is a regular expression if it is:
1. a for some a in the alphabet , standing for the language {a}
2. ε, standing for the language {ε}
3. Ø, standing for the empty language
4. R1+R2 where R1 and R2 are regular expressions, and + signifies union
(sometimes | is used)
5. R1R2 where R1 and R2 are regular expressions and this signifies
concatenation
6. R* where R is a regular expression and signifies closure
7. (R) where R is a regular expression, then a parenthesized R is also a
regular expression
Some RE Examples 4
Regular Expressions Regular Set
(0 + 10*) L = { 0, 1, 10, 100, 1000, 10000, … }
(0*10*) L = {1, 01, 10, 010, 0010, …}
(0 + ε)(1 + ε) L = {ε, 0, 1, 01}
(a+b)*abb Set of strings of a’s and b’s ending with the string
abb. So L = {abb, aabb, babb, aaabb, ababb,
…………..}
(aa + ab + ba + bb)* String of a’s and b’s of even length can be
obtained by concatenating any combination of the
strings aa, ab, ba and bb including null, so L = {aa,
ab, ba, bb, aaab, aaba, …………..}
Examples of Regular Expression 5
Example 1: Write the regular expression for the language accepting
all the string which are starting with 1 and ending with 0, over ∑ =
{0, 1}.
Solution : R.E. = 1 (0+1)* 0
Example 2: Write the regular expression for the language starting
and ending with a and having any having any combination of b's in
between.
Solution : R.E. = a b* b
Example 3: Write the regular expression for the language starting
with a but not having consecutive b's.
Solution: The regular expression has to be built for the language:
L = {a, aba, aab, aba, aaa, abab, .....}
So, R.E. = {a + ab}*
Deterministic Finite Automaton
6
(DFA)
Input Tape
String
Output
“Accept”
Finite
or
Automaton
“Reject”
Deterministic Finite State Automata (DFA)
7
……..
0 1 1 0 0
Finite
Control
One-way, infinite tape, broken into cells
One-way, read-only tape head.
Finite control, i.e.,
finite number of states, and
transition rules between them, i.e.,
a program, containing the position of the read head, current symbol being scanned, and
the current “state.”
Deterministic Finite State Automata 8
(DFA)
A string is placed on the tape, read head is positioned at the left
end, and the DFA will read the string one symbol at a time until all
symbols have been read. The DFA will then either accept or reject
the string
Finite Automaton (def.) 9
A deterministic finite automaton (DFA) M is defined by a 5-tuple
M=(Q,,,q0,F)
Q: finite set of states
: finite alphabet
: transition function :QQ
q0Q: start state
FQ: set of accepting states
Transition Graph 10
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
initial accepting
state state
transition
state
Alphabet {a , b } 11
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
For every state, there is a transition
for every symbol in the alphabet
head 12
Initial Configuration
Input Tape
a b b a
Input String
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
Initial state
Scanning the Input 13
a b b a
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
Scanning the Input 14
a b b a
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
Scanning the Input 15
a b b a
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
Input finished 16
a b b a
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
accept
A Rejection Case
17
a b a
Input String
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
Rejection case 18
a b a
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
Rejection case 19
a b a
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
Input finished 20
a b a
a, b
reject
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
Another Rejection Case
21
Tape is empty
( )
Input Finished
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
reject
Language Accepted: L abba 22
a, b
q5
a a, b
b a b
q0 a q1 b q2 b q3 a q4
To accept a string: 23
all the input string is scanned
and the last state is accepting
To reject a string:
all the input string is scanned
and the last state is non-accepting
Another Example 24
L , ab , abba
a, b
q5
b a a a, b
b
q0 a q1 b q2 b q3 a q4
Accept Accept Accept
state state state
25
Empty Tape
( )
Input Finished a, b
q5
b a a a, b
b
q0 a q1 b q2 b q3 a q4
accept
Another Example 26
a a,b
q0 b q1 a, b q2
Accept trap state
state
27
a a b
Input String
a a,b
q0 b q1 a, b q2
28
a a b
a a,b
q0 b q1 a, b q2
29
a a b
a a,b
q0 b q1 a, b q2
Input finished 30
a a b
a a,b
accept
q0 b q1 a, b q2
A rejection case 31
b a b
Input String
a a,b
q0 b q1 a, b q2
32
b a b
a a,b
q0 b q1 a, b q2
33
b a b
a a,b
q0 b q1 a, b q2
Input finished 34
b a b
a a,b
q0 b q1 a, b q2
reject
35
Language Accepted:
L {a b : n 0 }
n
a a,b
q0 b q1 a, b q2
Another Example 36
Alphabet: {1}
1
q0 q1
1
Language Accepted:
EVEN {x : x and x is even}
*
{ , 11, 1111, 111111, }
Transition Function 37
:Q Q
(q , x ) q
x
q q
Describes the result of a transition
from state q with symbol x
38
Example:
q0 , a q1
a, b
q5
b a a, b
a b
q0 a q1 b q2 b q3 a q4
39
q0 , b q5
a, b
q5
b a a, b
a b
q0 a q1 b q2 b q3 a q4
40
q2 , b q3
a, b
q5
b a a, b
a b
q0 a q1 b q2 b q3 a q4
Transition Table for
41
symbols
a b
q0
q1 q5
q1 q5 q2
states
q2 q5 q3
a,b
q3 q4 q5
q4 q5 q5 q5
q5 q5 q5 a,b
b a a b
q0 a q1 b q2 b q3 a q4
Extended Transition Function 42
:Q Q
* *
(q ,w ) q
*
Describes the resulting state
after scanning string w from state q
43
Example: q0 , ab q2
*
a, b
q5
b a a, b
a b
q0 a q1 b q2 b q3 a q4
44
q0 , abbbaa q5
*
a, b
q5
b a a, b
a b
q0 a q1 b q2 b q3 a q4
45
q1 , bba q4
*
a, b
q5
b a a, b
a b
q0 a q1 b q2 b q3 a q4
Language Accepted by DFA 46
Language of DFA M:
it is denoted as L M and contains
all the strings accepted by M
We say that a language L
is accepted (or recognized)
by DFA M if L M L
DFA Examples 47
Example 1:
Design a FA with ∑ = {0, 1} accepts those string which starts with 1
and ends with 0.
In state q1, if we read 1, we will be in state q1, but if we read 0 at
state q1, we will reach to state q2 which is the final state. In state q2,
if we read either 0 or 1, we will go to q2 state or q1 state
respectively. Note that if the input ends with 0, it will be in the final
state
DFA Examples 48
Example 2:
Design FA with ∑ = {0, 1} accepts even number of 0's and even
number of 1's.
DFA Examples 49
Here q0 is a start state and the final state also. Note carefully that a
symmetry of 0's and 1's is maintained. We can associate meanings to
each state as:
q0: state of even number of 0's and even number of 1's.
q1: state of odd number of 0's and even number of 1's.
q2: state of odd number of 0's and odd number of 1's.
q3: state of even number of 0's and odd number of 1's.
DFA Examples 50
Example 3: Design a DFA L(M) = {w | w ε {0, 1}*} and W is a string that
does not contain consecutive 1's.
Solution : When three consecutive 1's occur the DFA will be:
DFA Examples 51
Here two consecutive 1's or single 1 is acceptable, hence.
The stages q0, q1, q2 are the final states. The DFA will generate
the strings that do not contain consecutive 1's like 10, 110, 101,.....
etc.
More DFA Examples
52
{a , b }
a, b
a, b
q0 q0
L (M ) { } L (M ) *
Empty language All strings
53
{a , b }
a, b
q0 a, b q0
L (M ) { }
Language of the empty string
{a , b } 54
L M = { all strings with prefix ab }
a, b
q0 a q1 b q2
b a accept
q3 a, b
55
L M = { all binary strings containing
substring 001 }
0,1
1 0
1
0 0 00 1 001
0
56
L M = { all binary strings without
substring 001 }
1 0 0,1
1
0 1
0 00 001
0
57
L(M ) awa : w a , b
*
a
b
b
q0 a q2 q3
b a
q4
a, b
Regular Languages 58
M
Definition:
A language L
is regular if there is L (M ) L
a DFA that accepts it ( )
The languages accepted by all DFAs
form the family of regular languages
Example regular languages:
59
abba , ab, abba
{a b : n 0} awa : w a , b
n *
{ all strings in {a,b}* with prefix ab }
{ all binary strings without substring 001}
{x : x {1} and x is even}
*
{ } { } {a , b } *
There exist automata that accept these
languages (see previous slides).
60
There exist languages which are not Regular:
L {a nb n : n 0}
ADDITION {x y z : x 1 , y 1 , z 1 ,
n m k
nm k}
There is no DFA that accepts these languages
(we will prove this in a later class)
Non Deterministic Finite Automata 61
NFA stands for non-deterministic finite automata. It is easy to construct
an NFA than DFA for a given regular language.
The finite automata are called NFA when there exist many paths for
specific input from the current state to the next state.
Every NFA is not DFA, but each NFA can be translated into DFA.
NFA is defined in the same way as DFA but with the following two
exceptions, it contains multiple next states, and it contains ε transition.
Non Deterministic Finite Automata 62
In the following image, we can see that from state q0 for input a, there
are two next states q1 and q2, similarly, from q0 for input b, the next
states are q0 and q1. Thus it is not fixed or determined that with a
particular input where to go next. Hence this FA is called non-
deterministic finite automata.
Examples of NFA 63
Example 1: Design a NFA for the transition table as given below:
Examples of NFA 64
Examples of NFA 65
Example 2: Design an NFA with ∑ = {0, 1} accepts all string ending with 01.
Solution :
NFA to DFA Conversion 66
In NFA, when a specific input is given to the current state, the machine
goes to multiple states. It can have zero, one or more than one move on a
given input symbol. On the other hand, in DFA, when a specific input is
given to the current state, the machine goes to only one state. DFA has
only one move on a given input symbol.
Let, M = (Q, ∑, δ, q0, F) is an NFA which accepts the language L(M).
There should be equivalent DFA denoted by M' = (Q', ∑', q0', δ', F') such
that L(M) = L(M').
NFA to DFA Conversion 67
Steps for converting NFA to DFA:
Step 1: Initially Q' = ϕ
Step 2: Add q0 of NFA to Q'. Then find the transitions from this start
state.
Step 3: In Q', find the possible set of states for each input symbol. If this
set of states is not in Q', then add it to Q'.
Step 4: In DFA, the final state will be all the states which contain F(final
states of NFA)
NFA to DFA Conversion 68
Example 1: Convert the given NFA to DFA.
Solution: For the given transition diagram we will first construct the
transition table.
NFA to DFA Conversion 69
State 0 1
→ q0 q0 q1
q1 {q1, q2} q1
*q2 q2 {q1, q2}
Now we will obtain δ' transition for state q0.
δ'([q0], 0) = [q0]
δ'([q0], 1) = [q1]
The δ' transition for state q1 is obtained as:
δ'([q1], 0) = [q1, q2] (new state generated)
δ'([q1], 1) = [q1]
The δ' transition for state q2 is obtained as:
δ'([q2], 0) = [q2]
δ'([q2], 1) = [q1, q2]
NFA to DFA Conversion 70
Now we will obtain δ' transition on [q1, q2].
δ'([q1, q2], 0) = δ(q1, 0) ∪ δ(q2, 0)
= {q1, q2} ∪ {q2}
= [q1, q2]
δ'([q1, q2], 1) = δ(q1, 1) ∪ δ(q2, 1)
= {q1} ∪ {q1, q2}
= {q1, q2}
= [q1, q2]
The state [q1, q2] is the final state as well because it contains a
final state q2.
NFA to DFA Conversion 71
The transition table for the constructed DFA will be:
State 0 1
→[q0] [q0] [q1]
[q1] [q1, q2] [q1]
*[q2] [q2] [q1, q2]
*[q1, q2] [q1, q2] [q1, q2]
NFA to DFA Conversion 72
The transition graph for the constructed DFA will be:
NFA-^ To NFA 73
NFA with ε can be converted to NFA without ε, and this NFA without ε
can be converted to DFA. To do this, we will use a method, which can
remove all the ε transition from given NFA. The method will be:
Find out all the ε transitions from each state from Q. That will be called
as ε-closure{q1} where qi ∈ Q.
Then δ' transitions can be obtained. The δ' transitions mean a ε-closure
on δ moves.
Repeat Step-2 for each input symbol and each state of given NFA.
Using the resultant states, the transition table for equivalent NFA without
ε can be built.
NFA-^ To NFA 74
Example: Convert the following NFA with ε to NFA without ε.
Solutions: We will first obtain ε-closures of q0, q1 and q2 as follows:
ε-closure(q0) = {q0}
ε-closure(q1) = {q1, q2}
ε-closure(q2) = {q2}
NFA-^ To NFA 75
Now the δ' transition on each input symbol is obtained as:
δ'(q0, a) = ε-closure(δ(δ^(q0, ε),a))
= ε-closure(δ(ε-closure(q0),a))
= ε-closure(δ(q0, a))
= ε-closure(q1)
= {q1, q2}
δ'(q0, b) = ε-closure(δ(δ^(q0, ε),b))
= ε-closure(δ(ε-closure(q0),b))
= ε-closure(δ(q0, b))
= Ф
NFA-^ To NFA 76
Now the δ' transition on q1 is obtained as:
δ'(q1, a) = ε-closure(δ(δ^(q1, ε),a))
= ε-closure(δ(ε-closure(q1),a))
= ε-closure(δ(q1, q2), a)
= ε-closure(δ(q1, a) ∪ δ(q2, a))
= ε-closure(Ф ∪ Ф)
= Ф
δ'(q1, b) = ε-closure(δ(δ^(q1, ε),b))
= ε-closure(δ(ε-closure(q1),b))
= ε-closure(δ(q1, q2), b)
= ε-closure(δ(q1, b) ∪ δ(q2, b))
= ε-closure(Ф ∪ q2)
= {q2}
NFA-^ To NFA 77
The δ' transition on q2 is obtained as:
δ'(q2, a) = ε-closure(δ(δ^(q2, ε),a))
= ε-closure(δ(ε-closure(q2),a))
= ε-closure(δ(q2, a))
= ε-closure(Ф)
= Ф
δ'(q2, b) = ε-closure(δ(δ^(q2, ε),b))
= ε-closure(δ(ε-closure(q2),b))
= ε-closure(δ(q2, b))
= ε-closure(q2)
= {q2}
NFA-^ To NFA 78
Now we will summarize all the computed δ' transitions:
δ'(q0, a) = {q0, q1}
δ'(q0, b) = Ф
δ'(q1, a) = Ф
δ'(q1, b) = {q2}
δ'(q2, a) = Ф
δ'(q2, b) = {q2}
NFA-^ To NFA 79
The transition table can be:
States a b
→q0 {q1, q2} Ф
*q1 Ф {q2}
*q2 Ф {q2}
NFA-^ To NFA 80
The transition graph can be:
State q1 and q2 become the final state as ε-closure of q1 and q2
contain the final state q2. The NFA can be shown by the
following transition diagram.
RE To NFA Conversion 81
Common regular expression used in make ∈-NFA:
RE To NFA Conversion 82
Example: Create a ∈-NFA for regular expression: (a/b)*a
Solution :
