SRIVENKATESWARA COLLEGE OF ENGINEERING

(AUTONOMOUS)
B.Tech – II-II Sem LTPC
3003

IT20APC505 FORMAL LANGUAGES AND AUTOMATA THEORY

Course Objectives:
This course is designed to:
1. Introduce languages, grammars, and computational models
2. Explain the Context Free Grammars
3. Enable the students to use Turing machines
4. Demonstrate decidability and un-decidability for NP Hard problems

UNIT – I: Finite Automata

Why Study Automata Theory? The Central Concepts of Automata Theory, Automation, Finite
Automation, Transition Systems, Acceptance of a String by a Finite Automation, DFA, Design of
DFAs, NFA, Design of NFA, Equivalence of DFA and NFA, Conversion of NFA into DFA,
Finite Automata with E-Transition, Minimization of Finite Automata, Mealy and Moore
Machines, Applications and Limitation of Finite Automata.

Learning Outcomes:
At the end of the unit, students will be able to:
Distinguish DFA and NFA.
Construct DFA for an input string.
Perform minimization of Automata.
Compare Moore and Mealy Machines.

Why Study Automata Theory

1.1 Why Study Automata Theory:

1.1.2. Structural Representations
There are two important notations to the study of automata and their applications
1. Grammars are useful models when designing software that processes data with a recursive
structure. The best known example is a parser component of a compiler that deals with the
recursively nested features of the typical programming language conditional states that an
expression can be formed by taking any two expressions and connecting them by a plus sign this
rule is typical of how expressions of real programming languages are formed We introduce context
free grammars.

2. Regular Expressions also denote the structure of data strings are exactly the same as what can be
described by finite automata. The style of these expressions significantly from that of grammars we
shall content ourselves with a simple example here The UNIX style regular expression words
followed by a space and two capital letters This expression rep resents patterns in text that could be a
city and state. It misses multiword city names captured by the more complex expression
1.1.3 Automata and Complexity
Automata are essential for the study of the limits of computation. What can a computer do at all? This
study is called decidability and the problems that can be solved by computer are called decidable.
What can a computer do eficiently? This study is called intractability and the problems that can be
solved by a computer using no more time than some slowly growing function of the size of the input
are called tractable.
II. The Central Concepts of Automata Theory
III. Automation

What is Automation?

Automation is a technique that is used to complete the tasks with minimal or no human
intervention. This technique is used to make devices, systems, or processes to operate
automatically. The primary aim of automation is to boost the efficiency of business processes
and reduce/replace the human workforce.

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. An automaton with a finite number of
states is called a Finite automaton. The main motivation behind developing the automata
theory was to develop methods to describe and analyse the dynamic behaviour of discrete
systems.

This automaton consists of states and transitions. The State is represented by circles, and
the Transitions is represented by arrows.

Automata is the kind of machine which takes some string as input and this input goes through
a finite number of states and may enter in the final state.

Study of abstract computing devices, or “machines”

• Automaton = an abstract computing device

• Note: A “device” need not even be a physical hardware.

• The term "Automata" is derived from the Greek word "αὐτόματα" which means
"selfacting".

• Automaton is singular and Automata is plural.

• Finite automata are used in text processing, compilers, and hardware design.

• Context-free grammar (CFGs) are used in programming languages and artificial

intelligence. Originally, CFGs were used in the study of the human languages

Finite Automata

o Finite automata are used to recognize patterns.

o It takes the string of symbol as input and changes its state accordingly. When the
desired symbol is found, then the transition occurs.
o At the time of transition, the automata can either move to the next state or stay in the
same state.
 o 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.

A finite automaton is a collection of 5-tuple (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

Types of Automata:

There are two types of finite automata:

 1. DFA(deterministic finite automata)
2. NFA(non-deterministic finite automata)

DFA: It refers to deterministic finite automata. Deterministic refers to the uniqueness of the
computation. In the DFA, the machine goes to one state only for a particular input character.
DFA does not accept the null move.
NFA: It is used to transmit any number of states for a particular input. It can accept the null
move.
• Some important points about DFA and NFA:
• Every DFA is NFA, but the converse need not be true i.e., every NFA need not be DFA.
• There can be multiple final states in both NFA and DFA.
• DFA is used in Lexical Analysis in Compiler.
• Construction of NFA is easier than the construction of DFA
• To test string is Accepted or not easier in DFA than in NFA

Non-Deterministic Finite Automata (NFA):

• 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
TRANSITION SYSTEMS
 Example 1:

1. Q = {q0, q1, q2}

2. ∑ = {0, 1}
3. q0 = {q0}
4. F = {q2}

Solution:

Transition Diagram:
Transition Table:

Present State Next state for Input 0 Next State of Input 1

→q0 q0 q1

q1 q2 q1
*q2 q2 q2

Example 2:

DFA with ∑ = {0, 1} accepts all starting with 0.

Solution:

Explanation:

o In the above diagram, we can see that on given 0 as input to DFA in state q0 the DFA
changes state to q1 and always go to final state q1 on starting input 0. It can accept 00,
01, 000, 001....etc. It can't accept any string which starts with 1, because it will never
go to final state on a string starting with 1.

Example 3:

DFA with ∑ = {0, 1} accepts all ending with 0.

Solution:

Explanation:

In the above diagram, we can see that on given 0 as input to DFA in state q0, the DFA
changes state to q1. It can accept any string which ends with 0 like 00, 10, 110, 100....etc. It
can't accept any string which ends with 1, because it will never go to the final state q1 on 1
input, so the string ending with 1, will not be accepted or will be rejected.
Examples of DFA

Example 1:

Design a FA with ∑ = {0, 1} accepts those string which starts with 1 and ends with 0.

Solution:

The FA will have a start state q0 from which only the edge with input 1 will go to the next
state.

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.

Example 2:

Design a FA with ∑ = {0, 1} accepts the only input 101.

Solution:

In the given solution, we can see that only input 101 will be accepted. Hence, for input 101,
there is no other path shown for other input.

Example 3:

Design FA with ∑ = {0, 1} accepts even number of 0's and even number of 1's.

Solution:

This FA will consider four different stages for input 0 and input 1. The stages could be:
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.

Example 4:

Design FA with ∑ = {0, 1} accepts the set of all strings with three consecutive 0's.

Solution:

The strings that will be generated for this particular languages are 000, 0001, 1000, 10001, ....
in which 0 always appears in a clump of 3. The transition graph is as follows:

Note that the sequence of triple zeros is maintained to reach the final state.

Example 5:

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:

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.

Example 6:

Design a FA with ∑ = {0, 1} accepts the strings with an even number of 0's followed by
single 1.

Solution:

The DFA can be shown by a transition diagram as:

Example 2:

NFA with ∑ = {0, 1} accepts all strings with 01.

Solution:

Transition Table:

Present State Next state for Input 0 Next State of Input 1

→q0 q1 ε
q1 ε q2

*q2 q2 q2

Example 3:

NFA with ∑ = {0, 1} and accept all string of length atleast 2.

Solution:

Transition Table:

Present State Next state for Input 0 Next State of Input 1

→q0 q1 q1
q1 q2 q2

*q2 ε ε

Examples of NFA

Example 1:

Design a NFA for the transition table as given below:

Present State 0 1

→q0 q0, q1 q0, q2

q1 q3 ε
q2 q2, q3 q3

→q3 q3 q3

Solution:

The transition diagram can be drawn by using the mapping function as given in the table.
 Here,K

Apple Watch & watchOS 7 Made Us Wash Our Hands Longer! ????

1. δ(q0, 0) = {q0, q1}

2. δ(q0, 1) = {q0, q2}
3. Then, δ(q1, 0) = {q3}
4. Then, δ(q2, 0) = {q2, q3}
5. δ(q2, 1) = {q3}
6. Then, δ(q3, 0) = {q3}
7. δ(q3, 1) = {q3}

Example 2:

Design an NFA with ∑ = {0, 1} accepts all string ending with 01.

Solution:

Hence, NFA would be:

Example 3:
 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

Example 4:

Design an NFA in which all the string contain a substring 1110.

Solution:

The language consists of all the string containing substring 1010. 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 becomes:
 Transition table for the above transition diagram can be given below:

Present State 0 1

→q1 q1 q1, q2

q2 q3
q3 q4

q4 q5
*q5 q5 q5

Consider a string 111010,

1. δ(q1, 111010) = δ(q1, 1100)

2. = δ(q1, 100)
3. = δ(q2, 00)

Got stuck! As there is no path from q2 for input symbol 0. We can process string 111010 in
another way.

1. δ(q1, 111010) = δ(q2, 1100)

2. = δ(q3, 100)
3. = δ(q4, 00)
4. = δ(q5, 0)
5. = δ(q5, ε)

As state q5 is the accept state. We get the complete scanned, and we reached to the final state.

Example 5:

Design an NFA with ∑ = {0, 1} accepts all string in which the third symbol from the right
end is always 0.

Solution:
Thus we get the third symbol from the right end as '0' always. The NFA can be:

The above image is an NFA because in state q0 with input 0, we can either go to state q0 or
q1.
 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.

1. δ'([q0], 0) = [q0]
2. δ'([q0], 1) = [q1]
 The δ' transition for state q1 is obtained as:

1. δ'([q1], 0) = [q1, q2] (new state generated)

2. δ'([q1], 1) = [q1]

The δ' transition for state q2 is obtained as:

1. δ'([q2], 0) = [q2]
2. δ'([q2], 1) = [q1, q2]

Now we will obtain δ' transition on [q1, q2].

1. δ'([q1, q2], 0) = δ(q1, 0) ∪ δ(q2, 0)

2. = {q1, q2} ∪ {q2}
3. = [q1, q2]
4. δ'([q1, q2], 1) = δ(q1, 1) ∪ δ(q2, 1)
5. = {q1} ∪ {q1, q2}
6. = {q1, q2}
7. = [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:

The state q2 can be eliminated because q2 is an unreachable state.

 Example 2:

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 ϕ {q0, q1}

Now we will obtain δ' transition for state q0.

1. δ'([q0], 0) = {q0, q1}

2. = [q0, q1] (new state generated)
3. δ'([q0], 1) = {q1} = [q1]

The δ' transition for state q1 is obtained as:

1. δ'([q1], 0) = ϕ
2. δ'([q1], 1) = [q0, q1]

Now we will obtain δ' transition on [q0, q1]

1. δ'([q0, q1], 0) = δ(q0, 0) ∪ δ(q1, 0)

2. = {q0, q1} ∪ ϕ
3. = {q0, q1}
4. = [q0, q1]

Similarly,

1. δ'([q0, q1], 1) = δ(q0, 1) ∪ δ(q1, 1)

2. = {q1} ∪ {q0, q1}
3. = {q0, q1}
4. = [q0, q1]
 As in the given NFA, q1 is a final state, then in DFA wherever, q1 exists that state becomes a
final state. Hence in the DFA, final states are [q1] and [q0, q1]. Therefore set of final states F
= {[q1], [q0, q1]}.

The transition table for the constructed DFA will be:

State 0 1

→[q0] [q0, q1] [q1]

*[q1] ϕ [q0, q1]

*[q0, q1] [q0, q1] [q0, q1]

The Transition diagram will be:

Even we can change the name of the states of DFA.

Suppose

1. A = [q0]
2. B = [q1]
3. C = [q0, q1]

With these new names the DFA will be as follows:

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:

1. 1. δ (q, a) = p
2. 2. δ (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.

FINITE AUTOMATA WITH OUTPUTS: MOORE & MEALY M/C
• Finite automata may have outputs corresponding to state or transition. There are
two types of finite state machines that generate output: (i) Moore Machine (ii)
Mealy Machine
• If the output associated with state then such a machine is called Moore machine,
and if the output is associated with transition then it is called mealy machine.

Moore Machine Mealy Machine

MOORE MACHINE:
• Moore machine is a finite state machine in which the next state is decided by the current
state and current input symbol. The output symbol at a given time depends only on the
present state of the machine. Def: Moore machine can be described by 6-tuple M=(Q, ∑ , Δ,
δ,q0, λ) where Q: finite set of states .
∑: finite set of input symbols
• Δ : output alphabet
• q0: initial state of machine
• δ: Q × ∑ → Q is a transition function
• λ: Q → Δ output function
Ex: Design a Moore machine to generate 1's complement of a given binary
number.
Solution: To generate 1's complement of a given binary number the simple logic is that if the
input is 0 then the output will be 1 and if the input is 1 then the output wil be 0. That means
there are three states. One state is start state. The second state is for taking 0's as input and
produces output as 1. The third state is for taking 1's as input and producing output as 0.
Ex: Design a Moore machine for a binary input sequence such that if it has a substring
101, the machine output A, if the input has substring 110, it outputs B otherwise it
outputs C.
Solution: For designing such a machine, we will check two conditions, and those are 101
and 110. If we get 101, the output will be A, and if we recognize 110, the output will be B.
For other strings, the output will be C.
The partial diagram will be:
Now we will insert the possibilities of 0's and 1's for each state. Thus the Moore
machine becomes:

CONVERSION FROM MOORE MACHINE TO MEALY MACHINE

• In the Moore machine, the output is associated with every state, and in the mealy machine,
the output is given along the edge with input symbol. The equivalence of the Moore machine
and Mealy machine means both the machines generate the same output string for same input
string.
• We cannot directly convert Moore machine to its equivalent Mealy machine because the
length of the Moore machine is one longer than the Mealy machine for the given input. To
convert Moore machine to Mealy machine, state output symbols are distributed into input
symbol paths. We are going to use the following method to convert the Moore machine to
Mealy machine.
Method for conversion of Moore machine to Mealy machine
Let M = (Q, ∑, δ, λ, q0) be a Moore machine. The equivalent Mealy machine can be
represented by M' = (Q, ∑, δ, λ', q0). The output function λ' can be obtained as: λ' (q, a) =
λ(δ(q, a))
Ex:Convert the following Moore machine into its equivalent Mealy machine.

Solution:
The transition table of given Moore machine is as follow.

The equivalent Mealy machine can be obtained as follows:

λ' (q0, a) = λ(δ(q0, a)) = λ(q0) = 0
λ' (q0, b) = λ(δ(q0, b)) = λ(q1) = 1
The λ for state q1 is as follows:
λ' (q1, a) = λ(δ(q1, a)) = λ(q0) = 0
λ' (q1, b) = λ(δ(q1, b)) = λ(q1) = 1
Hence the transition table for the Mealy machine can be drawn as follows:
The equivalent Mealy machine will be
Note: The length of output sequence is 'n+1' in Moore machine and is 'n'

in the Mealy machine

Applications of different Automata

The applications of the different automata in Toc are explained below −

Finite Automata (FA)
The applications of Finite Automata are as follows −
• Design of the lexical analysis of a compiler.
• Recognize the pattern by using regular expressions.
• Use of the Mealy and Moore Machines for designing the combination and sequential
circuits.
• Helpful in text editors.
• Used for spell checkers.