Construction of DFA

• Example #1:

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

q0 q1 q0
q1 q0 q1
• Revisit example #2:

a a a/b/c
Q = {q0, q1, q2}
Σ = {a, b, c} c 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.
• 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 q0.
• 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. 4

• 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

5
• Problem: Third symbol from last is 1

0/1

1 0/1 0/1
q0 q1 q2 q3

Click to add text

Is this a DFA?

No, but it is a Non-deterministic Finite Automaton

6
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

δ(q,s) is a function from Q x S to 2 Q (but not only to Q) 7

• 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

8
• 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 9
• 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

10
• Determining if a given NFA (example #2) accepts a given string (001) can be
done algorithmically:

0 0 1
q0 q0 q0 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
11
• Another example (010):

0 1 0
q0 q0 q0 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
12
• 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?

13
• Construction of a DFA for the set of string over {a, b} such that length of
the string |w|=2 i.e, length of the string is exactly 2.

The desired language will be like:

L = {aa, ab, ba, bb}

The state transition diagram of the language will be like:

Number of states: n+2 Where n is |w|=n

• Construction of a DFA for the set of string over {a, b} such that length of the string |w|>=2 i.e, length of
the string should be at least 2.

Explanation – The desired language will be like:

L = {aa, ab, ba, bb, aaa, aab, aba, abb........}

The state transition diagram of the language will be like:

Number of states: n+1 Where n is |w|>=n

Construction of a DFA for the set of string over {a, b} such that length of the string |w|<=2 i.e,
length of the string is atmost 2.
Explanation – The desired language will be like:
L = {?, aa, ab, ba, bb}

The state transition diagram of the language will be like:

Number of states: n+2 Where n is |w|<=n

Construction of a minimal DFA accepting set of strings over {a, b} in which every ‘a’ is followed
by a ‘b’.
Explanation: The desired language will be like:

L1 = {ε, ab, abab, abbbb, ababababab, ..............}

Here as we can see that each string of the language containing ‘a’ just followed by ‘b’ but the below
language is not accepted by this DFA because some of the string of the below language does not contain ‘a’
just followed by ‘b’.

L2 = {ba, baab, bbaba, ..............}

The state transition diagram of the language containing ‘a’ just followed by ‘b’ will be like:
Construction of a minimal DFA accepting set of strings over {a, b} in which every ‘a’ is never be
followed by ‘b’
Explanation:
L1 = {ε, a, aa, aaaa, b, bbaaa, aabbb,..............}
Here as we can see that each string of the language containing ‘a’ is never be followed by ‘b’ but the
below language is not accepted by this DFA because some of the string of the below language
containing ‘a’ is followed by ‘b’.
L2 = {ba, babab, bbaba, ..............}
The state transition diagram of the language containing ‘a’ never be followed by ‘b’ will be like:
The desired language will be like:
Construction of NFA
Construction of a minimal NFA accepting a set of strings over {a, b} in which each
string of the language starts with ‘ab’.
Explanation: The desired language will be like:
L1 = {ab, abba, abaa, ...........}
Here as we can see that each string of the above language starts with ‘ab’ and end
with any alphabet either ‘a’ or ‘b’.
But the below language is not accepted by this NFA because none of the string of
below language starts with ‘ab’.
L2 = {ba, ba, babaaa..............}
The state transition diagram of the desired language will be like below:
Construction of a minimal NFA accepting a set of strings over {a, b} in which each string of the
language contain ‘a’ as the substring.

Explanation: The desired language will be like:

L1 = {ab, abba, abaa, ...........}
Here as we can see that each string of the above language contains ‘a’ as the substring. But the
below language is not accepted by this NFA because some of the string of below language does not
contain ‘a’ as the substring.
L2 = {bb, b, bbbb, .............}
The state transition diagram of the desired language will be like below:
Construction of a minimal NFA accepting a set of strings over {a, b} in which each string of the
language is not containing ‘a’ as the substring.
Explanation: The desired language will be like:

L1 = {b, bb, bbbb, ...........}

Here as we can see that each string of the above language is not containing ‘a’ as the substring But
the below language is not accepted by this NFA because some of the string of below language is
containing ‘a’ as the substring.

L2 = {ab, aba, ababaab..............}

The state transition diagram of the desired language will be like below:
onstruction of a minimal NFA accepting a set of strings over {a, b} in which each string of the language sta
xplanation: The desired language will be like:
1 = {ab, abba, abaa, ...........}
ere as we can see that each string of the above language starts with ‘a’ and end with any alphabet either ‘
ut the below language is not accepted by this NFA because none of the string of below language starts with
2 = {ba, ba, babaaa..............}
he state transition diagram of the desired language will be like below:
Design an NFA with ∑ = {0, 1} accepts all string ending with 01.
Solution:

Hence, NFA would be:

Design an NFA with ∑ = {0, 1} in which double '1' is followed by double '0'.

Solution:
The FA with double 1 is as follows:

It should be immediately followed by double 0.

Then,

Now before double 1, there can be any string of 0 and 1. Similarly, after double 0, there can be any string of 0 and 1.
Hence the NFA becomes:

Now considering the string 01100011

1.q0 → q1 → q2 → q3 → q4 → q4 → q4 → q4
Design an NFA in which all the string contain a substring 1110.
Solution:
The language consists of all the string containing substring 1110. The partial transition diagram can be:

Now as 1010 could be the substring. Hence we will add the inputs 0's and 1's so that the substring 1010 of the language can be maintained. Hence the NFA becom
Consider a string 111010,

δ^(q1, 111010) = δ(q1, 1100)

= δ(q1, 100)
= δ(q2, 00)
Got stuck! As there is no path from q2 for input symbol 0. We can process string 111010 in another way.

δ^(q1, 111010) = δ(q2, 1100)

= δ(q3, 100)
= δ(q4, 00)
= δ(q5, 0)
= δ(q5, ε)
Eliminating ε Transitions

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:

1.Find out all the ε transitions from each state from Q. That will be called as ε-closure{q1} where qi ∈ Q.
2.Then δ' transitions can be obtained. The δ' transitions mean a ε-closure on δ moves.
3.Repeat Step-2 for each input symbol and each state of given NFA.
4.Using the resultant states, the transition table for equivalent NFA without ε can be built.
Example:
Convert the following NFA with ε to NFA without ε.
Solution:
We will first obtain ε-closures of q0, q1 and q2 as follows:

ε-closure(q0) = {q0}
ε-closure(q1) = {q1, q2}
ε-closure(q2) = {q2}
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))
=Ф
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}
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}
Now we will summarize all the computed δ' transitions:
δ'(q0, a) = {q1, q2}
δ'(q0, b) = Ф
δ'(q1, a) = Ф
δ'(q1, b) = {q2}
δ'(q2, a) = Ф
δ'(q2, b) = {q2}
The transition table can be:

States a b
→q0 {q1, q2} Ф
*q1 Ф {q2}
*q2 Ф {q2}
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:
Conversion from NFA to DFA
In this section, we will discuss the method of converting NFA to
its equivalent DFA. 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').

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)
 Example 1:
Convert the given NFA to DFA.

Solution: For the given transition diagram we will first construct the transition table.

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]
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. 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]

The Transition diagram will be:

State q2 can be eliminated since its

unreachable.
(Assignment)

Convert the given NFA to DFA.

Conversion from NFA with ε to DFA
Non-deterministic finite automata(NFA) is a finite automata where for
some cases when a specific input is given to the current state, the
machine goes to multiple states or more than 1 states. It can contain ε
move. It can be represented as M = { Q, ∑, δ, q0, F}.
Where
1.Q: finite set of states
2.∑: finite set of the input symbol
3.q0: initial state
4.F: final state
5.δ: Transition function
NFA with ∈ move: If any FA contains ε transaction or move, the finite
automata is called NFA with ∈ move.
ε-closure: ε-closure for a given state A means a set of states which can be reached from
the state A with only ε(null) move including the state A itself.
Steps for converting NFA with ε to DFA:
Step 1: We will take the ε-closure for the starting state of NFA as a starting state of DFA.
Step 2: Find the states for each input symbol that can be traversed from the present. That
means the union of transition value and their closures for each state of NFA present in the
current state of DFA.
Step 3: If we found a new state, take it as current state and repeat step 2.
Step 4: Repeat Step 2 and Step 3 until there is no new state present in the transition table of
DFA.
Step 5: Mark the states of DFA as a final state which contains the final state of NFA.
Convert the NFA with ε into its equivalent DFA.
Let us obtain ε-closure of each state.
1.ε-closure {q0} = {q0, q1, q2}
2.ε-closure {q1} = {q1}
3.ε-closure {q2} = {q2}
4.ε-closure {q3} = {q3}
5.ε-closure {q4} = {q4}

Now, let ε-closure {q0} = {q0, q1, q2} be state A.

Hence
δ'(A, 0) = ε-closure {δ((q0, q1, q2), 0) }
= ε-closure {δ(q0, 0) ∪ δ(q1, 0) ∪ δ(q2, 0) }
= ε-closure {q3}
= {q3}

call it as state B.
δ'(A, 1) = ε-closure {δ((q0, q1, q2), 1) }
= ε-closure {δ((q0, 1) ∪ δ(q1, 1) ∪ δ(q2, 1) }
= ε-closure {q3}
= {q3}
= B.

The partial DFA will be

Now,

δ'(B, 0) = ε-closure {δ(q3, 0) }

=ϕ

δ'(B, 1) = ε-closure {δ(q3, 1) }

= ε-closure {q4}
= {q4} i.e. state C
For state C:
δ'(C, 0) = ε-closure {δ(q4, 0) }
=ϕ
δ'(C, 1) = ε-closure {δ(q4, 1) }
=ϕ
The DFA will be,
Convert the given NFA into its equivalent DFA.
• Let us obtain the ε-closure of each state.
• ε-closure(q0) = {q0, q1, q2}
• ε-closure(q1) = {q1, q2}
• ε-closure(q2) = {q2}
Now we will obtain δ' transition. Let ε-closure(q0) = {q0, q1, q2} call it
as state A.

δ'(A, 0) = ε-closure{δ((q0, q1, q2), 0)}

= ε-closure{δ(q0, 0) ∪ δ(q1, 0) ∪ δ(q2, 0)}
= ε-closure{q0}
= {q0, q1, q2}
δ'(A, 1) = ε-closure{δ((q0, q1, q2), 1)}
= ε-closure{δ(q0, 1) ∪ δ(q1, 1) ∪ δ(q2, 1)}
= ε-closure{q1}
= {q1, q2} call it as state B

δ'(A, 2) = ε-closure{δ((q0, q1, q2), 2)}

= ε-closure{δ(q0, 2) ∪ δ(q1, 2) ∪ δ(q2, 2)}
= ε-closure{q2}
= {q2} call it state C
Thus we have obtained
δ'(A, 0) = A
δ'(A, 1) = B
δ'(A, 2) = C
The partial DFA will be:
Now we will find the transitions on states B and C for each input.

Hence

δ'(B, 0) = ε-closure{δ((q1, q2), 0)}

= ε-closure{δ(q1, 0) ∪ δ(q2, 0)}
= ε-closure{ϕ}
=ϕ

δ'(B, 1) = ε-closure{δ((q1, q2), 1)}

= ε-closure{δ(q1, 1) ∪ δ(q2, 1)}
= ε-closure{q1}
= {q1, q2} i.e. state B itself

δ'(B, 2) = ε-closure{δ((q1, q2), 2)}

= ε-closure{δ(q1, 2) ∪ δ(q2, 2)}
= ε-closure{q2}
= {q2} i.e. state C itself
Thus we have obtained
δ'(B, 0) = ϕ
δ'(B, 1) = B
δ'(B, 2) = C
The partial transition diagram will be

Now we will obtain transitions for C:

δ'(C, 0) = ε-closure{δ(q2, 0)}
= ε-closure{ϕ}
= ϕ δ'(C, 1)
= ε-closure{δ(q2, 1)}
= ε-closure{ϕ}
=ϕ
δ'(C, 2) = ε-closure{δ(q2, 2)}
= {q2}
Hence the DFA is

As A = {q0, q1, q2} in which final state q2 lies hence A is final state. B =
{q1, q2} in which the state q2 lies hence B is also final state. C = {q2},
the state q2 lies hence C is also a final state.
Minimization of DFA
Minimization of DFA means reducing the number of states from given FA. Thus, we get the FSM(finite state
machine) with redundant states after minimizing the FSM.
We have to follow the various steps to minimize the DFA. These are as follows:
Step 1: Remove all the states that are unreachable from the initial state via any set of the transition of DFA.
Step 2: Draw the transition table for all pair of states.
Step 3: Now split the transition table into two tables T1 and T2. T1 contains all final states, and T2 contains non-final
states.
Step 4: Find similar rows from T1 such that:
δ (q, a) = p
δ (r, a) = p
That means, find the two states which have the same value of a and b and remove one of them.
Step 5: Repeat step 3 until we find no similar rows available in the transition table T1.
Step 6: Repeat step 3 and step 4 for table T2 also.
Step 7: Now combine the reduced T1 and T2 tables. The combined transition table is the transition table of minimized
DFA.
Example
Solution:
Step 1: In the given DFA, q2 and q4 are the unreachable states so remove them.
Step 2: Draw the transition table for the rest of the states.

State 0 1
→q0 q1 q3
q1 q0 q3
*q3 q5 q5
*q5 q5 q5

Step 3: Now divide rows of transition table into two sets as:
• 1. One set contains those rows, which start from non-final states:
 State 0 1
q0 q1 q3
q1 q0 q3

2. Another set contains those rows, which starts from final states.

State 0 1

q3 q5 q5
q5 q5 q5

Step 4: Set 1 has no similar rows so set 1 will be the same.

Step 5: In set 2, row 1 and row 2 are similar since q3 and q5 transit to the same state on 0 and 1. So skip q5 and
then replace q5 by q3 in the rest.
 State 0 1
q3 q3 q3

Step 6: Now combine set 1 and set 2 as:

State 0 1

→q0 q1 q3
q1 q0 q3
*q3 q3 q3

Now it is the transition table of minimized DFA.

Examples of Regular Expression

• Write the regular expression for the language accepting all the string
which are starting with 1 and ending with 0, over ∑ = {0, 1}.

Solution:

In a regular expression, the first symbol should be 1, and the last

symbol should be 0. The r.e. is as follows:
R = 1 (0+1)* 0
Examples of Regular Expression

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, .....}

The regular expression for the above language is:

R = {a + ab}*
Examples of Regular Expression

• Write the regular expression for the language over ∑ = {0} having even
length of the string.
Solution:
The regular expression has to be built for the language:
L = {ε, 00, 0000, 000000, ......}
The regular expression for the above language is:
R = (00)*
Examples of Regular Expression

• Write the regular expression for the language L over ∑ = {0, 1} such
that all the string do not contain the substring 01.
Solution:
The Language is as follows:
L = {ε, 0, 1, 00, 11, 10, 100, .....}
The regular expression for the above language is as follows:
R = (1* 0*)
Examples of Regular Expression

Write the regular expression for the language having a string which
should have atleast one 0 and alteast one 1.

Solution:

The regular expression will be:

R = [(0 + 1)* 0 (0 + 1)* 1 (0 + 1)*] + [(0 + 1)* 1 (0 + 1)* 0 (0 + 1)*]

Examples of Regular Expression

• Write the regular expression for the language containing the string in
which every 0 is immediately followed by 11.
Solution:
The regular expectation will be:
R = (011 + 1)*
Conversion of RE to FA

To convert the RE to FA, we are going to use a method called the

subset method. This method is used to obtain FA from the given regular
expression. This method is given below:

Step 1: Design a transition diagram for given regular expression, using

NFA with ε moves.
Step 2: Convert this NFA with ε to NFA without ε.
Step 3: Convert the obtained NFA to equivalent DFA.
Design a FA from given regular expression 10 + (0 + 11)0* 1.
Solution: First we will construct the transition diagram for a given
regular expression.

• Step 1:
Step 2: Step 4:

Step 3:
Step 5:
• Now we have got NFA without ε. Now we will convert it into required DFA
for that, we will first write a transition table for this NFA.
State 0 1
→q0 q3 {q1, q2}
q1 qf ϕ
q2 ϕ q3
q3 q3 qf
*qf ϕ ϕ
The equivalent DFA will be:

State 0 1
→[q0] [q3] [q1, q2]
[q1] [qf] ϕ
[q2] ϕ [q3]
[q3] [q3] [qf]
[q1, q2] [qf] [qf]
*[qf] ϕ ϕ
• Design a NFA from given regular expression 1 (1* 01* 01*)*.
Solution: The NFA for the given regular expression is as follows:

Step 1: Step 3:

Step 2:
• Design a NFA from given regular expression 1 (1* 01* 01*)*.

(Assignment)