Fundamentals of Theory of Computer Science

Unit 6

Unit 6

Deterministic Finite Automata

Structure
6.1

Introduction
Objectives

6.2

Basic Terms

6.3

Deterministic Finite Automaton (DFA)

6.4

Transition System (Transition graph)

6.5

Language accepted by a DFA

Self Assessment Questions.

6.6

Summary

6.7

Terminal Questions

6.8

Answers

6.1 Introduction
A study of finite automaton is their applicability to the design of several
common types of computer algorithms and programs. For example, the
lexical analysis phase of a compiler (in which program units such as begin
and + are identified) is often based on the simulation of a finite automaton.
Also, the problem of finding an occurrence of a string within another, for
example, whether any of the strings air, water, earth, and fire occur in the
text of Elements of the Theory of Computation, can also be solved efficiently
by methods originating from the theory of finite automata.

Sikkim Manipal University

Page No.: 115

Fundamentals of Theory of Computer Science

Unit 6

Let us now describe the operation of a finite automaton in more detail.

Strings are fed into the device by means of an input tape, which is divided
into squares, with one symbol inscribed in each tape square (see figure).
The main part of the machine itself is a black box with innards that can be,
at any specified moment, in one of a finite number of distinct internal states.
This black box - called the finite control - can sense what symbol is written
at any position on the input tape by means of a movable reading head.
Initially, the reading head is placed at the leftmost square of the tape and
the finite control is set in a designated initial state.
At regular intervals the automaton reads one symbol from the input tape and
then enters a new state that depends only on the current state and the
symbol just read. This is why we shall call this device a deterministic finite
automaton. After reading an input symbol, the reading head moves one
square to the right on the input tape so that on the next move it will read the
symbol in the next tape square. This process is repeated continuously; a
symbol is read, the reading head moves to the right, and the state of the
finite control changes. Eventually the reading head reaches the end of the
input string. The automaton then indicates its approval or disapproval of
what it has read by the state it is in at the end: if it winds up in one of a set of
final states the input string is considered to be accepted. The language
accepted by the machine is the set of strings it accepts.
Objectives:
At the end of the unit the student must be able to:

Understand the idea of DFA.

Draw transition diagram.

Find the language accepted by a DFA.

Apply the techniques to various finite automata problems.

Know applications of DFA.

Sikkim Manipal University

Page No.: 116

Fundamentals of Theory of Computer Science

Unit 6

6.2 Basic Terms

Input: The various inputs i1, i2, , ip applied at the input side of the model
are the elements of an input set, , also called the input alphabet.
Output: The various outputs o1, o2, , oq generated at the output side of
the model are the elements of an output set O, also called the output
alphabet.
States: The entire automaton system, at any given instant of time, is in any
one of the states q1, q2, , qn. (These are labeled with circles)
State relation: State relation helps determine the next state that the
automaton system is going to attain. State relation takes into consideration
the present input and the present state of the system in determining its next
state.
Output relation: It helps to determine the next output of the automaton
system. The output relation may take into consideration only the current
input or both the current input and the current state for determining the next
output.
6.2.1 Definition
An automaton system in which the output depends only on the present input
is called a Moore machine. Alternatively, an automaton system in which the
output depends both on the present input and the present state is called
Mealy machine.

6.3 Deterministic Finite Automaton (DFA)

6.3.1 Definition
A DFA is 5-tuple or quintuple M = (Q, , , q0, F) where
Q is non-empty, finite set of states.
is non-empty, finite set of input alphabets.
Sikkim Manipal University

Page No.: 117

Fundamentals of Theory of Computer Science

Unit 6

is transition function, which is a mapping from Q to Q. For this

transition function the parameters to be passed are state and input symbol.
Based on the current state and input symbol, the machine may enter into
another state.
q0 Q is the start state.
F Q is set of accepting or final states.
6.3.2 Note
For each input symbol a, from a given state there is exactly one transition
(there can be no transitions from a state also) and we are sure (or can
determine) to which state the machine enters. So, the machine is called
Deterministic machine. Since it has finite number of states the machine is
called Deterministic finite machine (automaton).
6.3.3 Illustration
Let us take the pictorial representation of DFA shown in figure and
understand the various components of DFA.

It is clear from this diagram that, the DFA is represented using circles,
arrows and arcs labeled with some digits, concentric circles etc. The circles
are nothing but the states of DFA. In the DFA shown in figure, there are
three states viz., q0, q1 and q2. An arrow enters into state q0 and is not
originating from any state and so it is quite different from other states and is
called the start state or initial state. The state q2 has two concentric circles
and is also a special state called the final state or accepting state. In this
DFA, there is, only one final state. Based on the language accepted by DFA,
there can be more than one final state also.
The states other than start state and final states are called intermediate
Sikkim Manipal University

Page No.: 118

Fundamentals of Theory of Computer Science

Unit 6

states. Always the machine initially will be in the start state. It is clear from
the figure that, the machine in state q0, after accepting the symbol 0, stays in
state q0 and after accepting the symbol 1, the machine enters into state q 1.
Whenever the machine enters from one state to another state, we say that
there is a transition from one state to another state. Here we can say that
there is a transition from state q0 to q1 on input symbol 1.
In state q1, on input symbol 0, the machine will stay in q1 and on symbol 1,
there is a transition to state q2. In state q2, on input symbol 0 or 1, the
machine stays in state q2 only. This DFA has three states q0, q1 and q2 and
can be represented as Q = {q0, q1, q2}, the possible input symbols set = {0,
1}, which is set of input symbols (alphabets) for the machine.
There will be a transition from one state to another based on the input
alphabets. If there is a transition from vi, to vj on an input symbol a, it can be
represented as (vi, a) = vj.
The transitions from each state of the machine shown in figure based on the
input alphabets {0, 1} are shown in table.
State
q0
q0
q1
q1
q2
q2

input
0
1
0
1
0
1

Output
q0
q1
q1
q2
q2
q2

Transition Representation
(q0, 0) = q0
(q0, 1) = q1
(q1, 0) = q1
(q1, 1) = q2
(q2, 0) = q2
(q2, 1) = q2

6.4 Transition System (Transition graph)

A finite directed labeled graph in which each node or vertex of the graph
represents a state and the directed edges from one node to another
represent transition of a state. All the edges of the transition graph are
labeled as input/output. For example, an edge labeled 1/0 specifies that for
a certain initial state if the input is 1, then the output is 0.
Sikkim Manipal University

Page No.: 119

Fundamentals of Theory of Computer Science

Unit 6

Consider the following diagram:

In the transition graph as shown in the figure,

The initial state, q0, of the system is represented by a circle with an

arrow pointing towards it.

The final state, q1, is represented by two concentric circles.

The directed edges from the initial state to the final state are labeled as
input/output.

6.4.1 Example
The graph represents the DFA,

Representation of DFA using Transition table:

In this method, the DFA is represented in the tabular form. This table is
called transitional table. There is one row for each state, and one column for
each input. Since, in the transition diagram shown in the fig., there are three
Sikkim Manipal University

Page No.: 120

Fundamentals of Theory of Computer Science

Unit 6

states, there are three rows for each state. The input symbols are only 0
and 1 so, there are two columns for the input symbols. The transitional
table for the diagram is given below.

6.5 Language accepted by a DFA

Consider the transition diagram or DFA shown in figure. The start state is q 0
and the final state is q2. To start with the machine will be in start state q0.

Verification of acceptance of the string 1011:

Let us assume that the string 1011 is the input. On first input symbol 1, the
machine enters into state q1. In state q1, on input symbol 0, the machine
stays in state q only. In state q1, on input symbol 1, the machine enters into
state q2. In state q2, on the input symbol 1, the machine stays in state q 2.
Now we encounter end of the input and note that we are in the accepting
state q2. The moves made by the DFA for the string 1011. Therefore after
scanning the input string 1011, the machine finally stays in state q2.
Verification of non-acceptance of the string 1011:
Take the string 0100: The moves made by the machine for the string 0100
are clear from the following figure. Note that after scanning the string 0100
Sikkim Manipal University

Page No.: 121

Fundamentals of Theory of Computer Science

Unit 6

the machine stays in state q1 which is not a final state. Therefore the string
0100 is rejected by the machine.
6.5.1 Definition
Let M = (Q, , , q0, F) be a DFA where
Q is non-empty, finite set of states.
is a non-empty, finite set of input alphabets.
is a transition function, which is a mapping from Q to Q. For this
transition function the parameters to be passed are state and input symbol.
Based on the current state and input symbol, the machine may enter into
another state.
q0 Q is the start (or initial) state.
F Q is set of accepting or final states.
The string (also called language) w accepted by a DFA can be defined as
follows.

L(M) = {w w * and (q0, w) F}.

Non-acceptance means that after the string is processed, the DFA will not
be in the final state and so the string is rejected. The non-acceptance of the
string w by a DFA can be defined in notation as:

L ( M ) = {w w * and (q0, w) F}, where : Q * Q, is an extended

transition function. The second argument of is a string, rather than a

single symbol, and its value gives the state the automaton will be in after
reading that string.

(For example, in the above figure, (q0, 1) = q1 and (q1, 1) = q2. So, (q0,
11) = q2).

Sikkim Manipal University

Page No.: 122

Fundamentals of Theory of Computer Science

Unit 6

6.5.2 Properties

6.5.3 Example

Solution:
Property 1: This means that when the current state of the machine is q and
when there is no input ( means no input), the machine will not move to any
new state, instead, it stays in the same state q.

6.5.4 Example
Obtain a DFA to accept strings of as and bs starting with the string ab.
Solution: It is clear that the string should start with ab and so, the minimum
Sikkim Manipal University

Page No.: 123

Fundamentals of Theory of Computer Science

Unit 6

string that can be accepted by the machine is ab.

To accept the string ab, we need three states and the machine can be
written as

where q2 is the final or accepting state. In state q0, if the input symbol is b,
the machine should reject b (note that the string should start with a). So, in
state q0, on input b, we enter into the rejecting state q3. The machine for this
can be of the form

The machine will be in state q1, if the first input symbol is a. If this a is
followed by another a, the string aa should be rejected by the machine. So,
in state q1, if the input symbol is a, we reject it and enter into q3 which is the
rejecting state. The machine for this can be of the form

Sikkim Manipal University

Page No.: 124

Fundamentals of Theory of Computer Science

Unit 6

Whenever the string is not starting with ab, the machine will be in state q3
which is the rejecting state. So, in state q 3, if the input string consists of as
and bs of any length, the entire string can be rejected and can stay in state
q3 only.
The resulting machine can be of the form

The machine will be in state q2, if the input string starts with ab. After the
string ab, the string containing any combination of as and bs, can be
accepted and so remain in state q2 only. The complete machine to accept
the strings of as and bs starting with the string ab is shown in figure.
The state q3 is called trap state or rejecting state.

Sikkim Manipal University

Page No.: 125

Fundamentals of Theory of Computer Science

Unit 6

In the set notation, the language accepted by DFA can be represented as

L = {ab(a + b)n n 0}
Or
L = {ab(a + b)*}
Therefore the DFA which accepts strings of as and bs starting with the
string ab is given by M = (Q, , , q0, F), where
Q = {q0, q1, q2, q3}, = {a, b}, q0: initial state, F = {q2}, and the transition
function is defined as

To accept the string abab: The string is accepted by the machine.

Sikkim Manipal University

Page No.: 126

Fundamentals of Theory of Computer Science

Unit 6

To reject the string aabb:

Therefore the string aabb is not accepted by the machine.

6.5.5 Note

Sometimes we ignore the extended notion and we use only (assuming

that the reader is well acquainted with it).
6.5.6 Example
Consider a finite automation that will accept the set of natural numbers
which are divisible by 3,

Sikkim Manipal University

Page No.: 127

Fundamentals of Theory of Computer Science

Unit 6

6.5.7 Example
Obtain a DFA to accept even number of as, and odd number of as.
Sikkim Manipal University

Page No.: 128

Fundamentals of Theory of Computer Science

Unit 6

Solution: Observe the following transition diagrams.

Consider the string aa: (q0, aa) = ((q0, a), a) = (q1, a) = q0, which is a
final state (acceptable state).

Consider the string aaa: (q0, aaa) = ( (q0, aa), a) = ( ( (q0, a), a),
a) = ( (q1, a), a) = (q0, a) = q1, which is an acceptable state.

6.5.8 Problem
Obtain DFA to accept strings of as and bs having exactly one a, at least
one a, not more than three as.
Solution:
To accept exactly one a:
To accept exactly one a, we need two states q0 and q1 and make q1 as the
final state. The machine to accept one a is shown below.

In q0, on input symbol b, remain q0 only so that any number of bs can end
Sikkim Manipal University

Page No.: 129

Fundamentals of Theory of Computer Science

Unit 6

with one a. The machine for this can be of the form

In q1, on input symbol b, remains q1 then machine can take the form

But, in state q1, if the input symbol is a, the string has to be rejected as the
machine can have any number of bs but exactly one a. So, the string has to
be rejected and we enter into a trap state q2. Once the machine enters into
trap state, there is no way to come out of the state and the string is rejected
by the machine. The complete machine is shown in the figure.

In the set notation, the language accepted by DFA can be represented as

L = {bmabn m, n 0}.
The machine M = (Q, , , q0, F), where
Q = {q0, q1, q2}, = {a, b}, q0: initial state, F = {q1}, and the transition function
is defined as

Sikkim Manipal University

Page No.: 130

Fundamentals of Theory of Computer Science

Unit 6

The machine to accept at least one a: The minimum string that can be
accepted by the machine is a. For this, we need two states q0 and q1 where
q1 is the final state. The machine for this is shown below.

In state q0, if the input symbol is b, remain in q0. Once the final state q1is
reached, whether the input symbol is a or b, the entire string has to be
accepted. The machine to accept at least one a is shown in fig.

In set notation, the language accepted DFA can be represented as

L = {bma(a + b)n m, n 0}.
The machine M = (Q, , , q0, F), where
Q = {q0, q1}, = {a, b}, q0 : initial state, F = {q1}, and the transition function
is defined as

Sikkim Manipal University

Page No.: 131

Fundamentals of Theory of Computer Science

Unit 6

The machine to accept not more than three as: The machine should accept
not more than three as means,
It can accept zero as
It can accept one a
It can accept two as
It can accept 3 as
But, it cannot accept more than three as.
In this machine maximum of three as can be accepted (that is, the machine
can accept zero as, one a, two as). So, we need maximum four states q 0,
q1, q2 and q3 where all these states are final states and q0 is the start state.

In state q3, if the input symbol is a, the string has to be rejected and we
enter into a trap state q4. Once this trap state is reached, whether the input
symbol is a or b, the entire string has to be rejected and remain in state q 4.
Now, the machine can take the form as shown below.

Sikkim Manipal University

Page No.: 132

Fundamentals of Theory of Computer Science

Unit 6

In state q0, q1, q2 and q3, if the input symbol is b, stay in their respective
states and the final transition diagram is shown below.

In set notation, the language accepted DFA can be represented as

L = {biabjabkabl i, j, k, l 0}
The DFA is M = (Q, , , q0, F) where Q = {q0, q1, q2, q3, q4}, = {a, b}, q0 is
the start state, F = {q0, q1, q2, q3}, and is the transition function.

Sikkim Manipal University

Page No.: 133

Fundamentals of Theory of Computer Science

Unit 6

6.5.9 Problem

Solution: The number of symbols in a string consisting of as and bs should

not have multiples of 5. The machine to accept the corresponding language
is shown below.

Self Assessment Questions

1. The symbol is used for _______
2. The symbol O is used for ________
3. In an automaton system, the states are represented by _________
4. State relation helps to determine _________
5. An automaton system in which the output depends only on the present
Sikkim Manipal University

Page No.: 134

Fundamentals of Theory of Computer Science

Unit 6

input is called a ________

An automaton system in which the output depends both on the present
input and the present state is called ________
6. Consider the example 6.3.3.
Write the states, input alphabet, final states, starting state.
7. Construct the state table for the following DFA.

8. Draw a DFA to accept strings of as and bs with even number of as and

even number of bs. Also find the language accepted by DFA.
9. Consider the example 6.5.8,
(i)

The set of states ___________

(ii)

The set of final states _________

(iii)

Starting state ____________

(iv)

S(q2, b) = _________, S(q0, b) = _______

6.6 Summary
The concept of finite automata is used in wide applications. Large natural
vocabularies can be described using finite automaton which includes the
applications such as spelling checkers and advisers, multi-language
dictionaries, to indent and documents, in calculators to evaluate complex
expressions based on the priority of an operator etc. In this unit we gave a
comprehensive idea about the DFA and a graphical representation of DFA.
Further we discuss the language accepted by DFA with certain examples.

6.7 Terminal Questions

Sikkim Manipal University

Page No.: 135

Fundamentals of Theory of Computer Science

Unit 6

1. What is DFA ? Explain with example.

2. When do we say that a language is accepted by the machine? Illustrate
with example.
3. Obtain a DFA to accept strings of 0s and 1s starting with at least two
0s and ending with at least two 1s. Also find the language accepted by
this.
(Hint:

The language accepted by DFA can be represented as

L = {w w 00(0+1)*11}
4. Obtain a DFA to accept strings of as and bs with at most two
consecutive bs.

6.8 Answers
Sikkim Manipal University

Page No.: 136

Fundamentals of Theory of Computer Science

Unit 6

Self Assessment Questions

1. Input alphabet.
2. Output alphabet.
3. These are labeled with circles.
4. The next state that the automaton system is going to attain.
5. Moore machine; Mealy machine.
6. States: {q0, q1, q2}, Input alphabet: {0, 1}, final state: {q2}, starting state
{q0}.
7.

8. The language accepted by DFA is

L = {w w (a + b)* and total number of strings in both a and b are
even}.

Sikkim Manipal University

Page No.: 137

Fundamentals of Theory of Computer Science

Unit 6

9. (i) Set of states {q0, q1, q2, q3, q4}

(ii) Set of final states {q0,q1, q2, q3}
(iii) Starting state {q0}
(iv) S(q2, b) = q2, S(q0, b) = q0

Sikkim Manipal University

Page No.: 138