AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

-------------MODULE-1-------------
Introduction to Automata Theory: Central Concepts of Automata theory, Deterministic Finite
Automata (DFA), Non- Deterministic Finite Automata(NFA) ,Epsilon- NFA, NFA to DFA Conversion,
Minimization of DFA

Introduction to Compiler Design: Language Processors, Phases of Compilers

INTRODUCTION TO FINITE AUTOMATA

Introduction: Automata theory is the study of abstract computing devices, or machines. Automata are
essential for the study of the limits of computations. Finite Automata are a useful model for many
important parts of hardware and software.

Alphabets: A symbol is an abstract entity. Letters and digits are examples of frequently used symbol. An
alphabet is a finite, non-empty set of symbol and is denoted by ∑.

Example :∑= {0,1} , ∑={a,b,c}

Strings: is a finite set sequence of symbols chosen from alphabet.

Example: 011101 is a string from alphabet ∑= {0,1}.

Operations on string:

Concatenation: of two strings is formed by writing first string followed by second string with no
space.Ex. V=’a’, W=’cat’ then V.W=’acat’

Reverse: of the string W is obtained by writing the symbols of the string in reverse order and is denoted as W R. ex.
W=’the’ then WR =’eht’.

Length: of a string W, denoted |W| is the number of symbols composing the string. Ex.W=’the’ then
|W|=3

Empty String: Denoted by Ɛ is the string with zero symbol.

Power of Alphabets:if ∑ is alphabet, the set of all strings of certain length can be expressed from that
alphabet by using exponential notation. Ex. ∑={a,b} then

∑0 = { Ɛ}

∑1={a,b}

1
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

∑2={aa,ab,bb,ba}

∑3 ={aaa,aab,aba,abb,bbb,baa,bab,bba}

∑*=∑0Ս∑1Ս∑2Ս….∑ n

Language: set of strings, all are chosen from ∑*, where ∑ is a particular alphabet is called a language.
L ∑*.

Empty Language: represented as Ǿ whereǾ={ }, does not contain any element.

Introduction to Finite Automata and formal language

An automaton is a construct that possesses all the indispensable features of a digital computer. It
accepts input, produces output, may have some temporary storage and can make decisions in
transforming the input into the output.

A formal language is an abstraction of the general characteristics of programming languages. A formal

language consists of a set of symbols and some rules of by which these symbols can be combined into
entities called sentences.

Finite automata are computing devices that accept/recognize regular languages and are used to model
operations of many systems. Their operations can be simulated by a very simple computer program.

Automaton:
A finite automaton (FA, also called a finite-state automaton or a finite-state machine) is a mathematical
tool used to describe processes involving inputs and outputs. An FA can be in one of several states and
can switch between states depending on symbols that it inputs. Once it settles in a state, it reads the next
input symbol, performs some computational task associated with the new input, outputs a symbol, and
switches to a new state depending on the input. Notice that the new state may be identical to the current
state.
DFA: Deterministic Finite Automata
Definition: DFA is a finite automaton in which for each input symbol there is exactly one transition out
of each state

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.
δ is transition function, which is a mapping from Q X ∑ -> Q.
q0 ∈Q is the start state.
F⊆ Q is set of accepting or final states.
Note: For each input symbol a, from a given state there is exactly one transition (there can be no

2
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51
transitions from a state also) and it is 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 or Deterministic Finite Automaton or Finite State Machine (FSM).
The language accepted by DFA is
L(M) = { w | w ∈ ∑* and δ*(q0, w) ∈ F }

Designing a FA: The automaton can be described by

1. Transition diagram: is a graph

a. For each state in Q there is a node
b. For each state q in Q and each input symbol a in ∑ ,let δ(q,a) = p, then the transition diagram
has an arc from node p labeled a.
c. There is an arrow into the start state q0 labeled start
d. Nodes corresponding to accepting states are marked by double circle
2. Transition table : is a conventional tabular representation of a function like δ that take two
arguments and returns a value
a. Rows of the table corresponds to the states and the columns correspond to the input
Examples

3
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

4
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

5
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

6
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

7
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

8
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

9
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

10
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

11
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

12
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

Nondeterministic Finite Automaton: NFA

13
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

NFA is defined as follows: at some point in processing a string on a machine, the machine has a choice of
moves; when this happens, it selects a move in an unspecified way. In other words, there can be zero, one
or more than one transition out of a state with the same label. So the machine must choose which path to
take. This leads us to the observation that a string may have more than one path through the machine that
is each entry in the table for NFA is a set. This represents a relaxation of the rules for defining FA's.

Definition: An NFA is a 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.
δ is transition function which is a mapping from Q X ∑ to subsets of 2Q. This function
shows the change of state from one state to a set of states based on the input symbol.
q0∈ Q is the start state.
F ⊆ Q is set of accepting or final states
Language Accepted by NFA:

Definition: Let M = (Q, ∑, δ, q0, A) be a DFA where Q is set of finite states, ∑ is set of input alphabets
(from which a string can be formed), δ is transition function from Q x {∑U ε} to 2Q, q0 is the start state
and A is the final or accepting state. The string (also called language) w accepted by an NFA can be
defined in formal notation as:

L(M) = { w | w ∈ ∑*and δ*(q0, w) = Q with at least one Component of Q in A}

Examples

14
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

15
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

16
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

17
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

Extended Transition δ*: Describes what happens when we start in any state and follow sequence of
inputs.
Definition:
Let M = (Q, ∑, δ, q0, F) where
Q is non-empty, finite set of states.
∑ is non-empty, finite set of input alphabets.
q0 ∈Q is the start state.
F ⊆ Q is set of accepting or final states.
δ* is extended transition function, which is a mapping from Q X ∑ -> Q. as follows:
i. For any q ∈ Q , δ*(q, ∈)=q
ii. For any q∈Q, y ∈ ∑ *, a ∈ ∑
δ*(q, ya)= δ(δ*(q,y),a)

18
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

FINITE AUTOMATA WITH Ɛ TRANSITIONS

Ɛ-NFA Epsilon NFA
Is an NFA with Epsilon transitions. The NFA which includes transitions on the empty input Ɛ is called Ɛ-
NFA

Definition: AnƐ-NFA is a 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.
δ is transition function which is a mapping from Q X{∑UƐ} to subsets of 2Q.
This function shows the change of state from one state to a set of states based on the input symbol.

19
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51
q0∈ Q is the start state.
F ⊆ Q is set of accepting or final states
Ɛ-Closure of a state
Definition:
Ɛ-closure is a set of all vertices p such that there is a path from q to p labelled Ɛ.

Let M = (Q, ∑, δ, q0 , F) be an NFA with M = (Q, ∑, δ, q 0, F) transitions and let S be any subset of Q. The
Ɛ-closure of S denoted as Ɛ(S) is defined by
1. Every element of S is an element of Ɛ(S).
2. For any q Є Ɛ(S) every element of δ(q, Ɛ) is in Ɛ(S)
3. No other element are in Ɛ(S)
0

1 ε
Start q r s

0 ε
1
• ε-closure(q) = { q }
• ε-closure(r) = { r, s}
Examples

20
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

Conversion from NFA-DFA (Subset Construction)

21
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

With an NFA, at any point in a scanning of the input string we may be faced with a choice of any number
of paths to be followed to reach a final state. With a DFA there is never a choice of paths. So, when we
construct a DFA which accepts the same language as a particular NFA, the conversion process effectively
involves merging all possible states which can be reached on a particular input character, from a particular
state, into a single, composite, state which represents all those paths.
Let MN = (QN, ∑, δN, q0 , FN) be an NFA and accepts the language L(MN). There should be an equivalent
DFA MD = (QD , ∑D, δD , q0, FD) such that L(MD) = L(MN). The procedure to convert an NFA to its
equivalent DFA is shown below
Step1: The start state of NFA MN is the start state of DFA MD. So, add q0(which is the start state of NFA)
to QD and find the transitions from this state.

Step2: For each state [qi, qj,….qk] in QD, the transitions for each input symbol in ∑ can be obtained as
shown below:

 δD([qi, qj,….qk], a) = δN(qi, a) U δN(qj, a) U ……δN(qk, a)

 a =[ql,qm,….qn]say.

 Add the state [ql, qm,….qn] to QD , if it is not already in QD.

 Add the transition from [qi, qj,….qk] to [q l, qm,….qn] on the input symbol α iff the state [ql,
qm,….qn] is added to QD in the previous step.

Step3: The state [qa , qb,….qc] ∈ QD is the final state, if at least one of the state in qa, qb, ….. qc∈ AN i.e., at
least one of the component in [qa , qb,….qc] should be the final state of NFA.

22
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

23
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

24
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

25
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

Conversion from Ɛ-NFA-DFA (Subset Construction)

To eliminate ε-transitions, use the following to convert to a DFA

1. Compute ε-closure for the current state, resulting in a set of states S.

2. δD(S,a) is computed for all a in  by
a. Let S = {p1, p2, … pk}
k
b. Compute   ( p , a) and call this set {r1, r2, r3 … rm}
i 1
i This set is achieved

by following input a, not by following any ε-transitions

m
c. Add the ε-transitions in by computing  ( S , a)     closure(ri )
i 1
3. Make a state an accepting state if it includes any final states in the ε-NFA.

26
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51
0

1 ε
Start q r s

0 ε
1

Converts to

0,1
Start q sr

0,1

27
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

28
AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

29
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51

If MD = (QD, ∑D , δD , q0, FD) is the DFA constructed from NFA MN = (QN , ∑, δ N, q0, FN) by the subset
construction, then L(MD) = L(MN).
Proof: Let |w| =0, that is w= ε. By the basis definitions of δ* for DFA’s and NFA’s both δ*({ q0 }, ε )
and δ*( q0, ε) are {q0}
Let w be of length n+1, and assume the statement for length n. break w as w=xa, where a is the final
symbol of w. by the inductive hypothesis δ*({ q0 }, x )= δ*( q0, x). let both these sets of N’s states be
{p1,p2,…. pk}

The inductive part of the definition of δ*for NFA’s tells that:

δ*( q0, w) = δN( pi,a) ------------------------1

The subset construction, on the other hand, tells that :

δD( {p1, p2,…….. pk,},a)= δN( pi,a)------------2

Using eqn 2 and the fact that δ*({ q0 }, x )={p1,p2,…. pk}in the inductive part of the definition of δ* for
DFA’s

δ*({ q0 }, x )= δD (δD*({ q0 }, x ),a)= δD( {p1, p2,…….. pk,},a)= δN( pi,a)---------3

Thus equation 2 and 3 demonstrate that δ*({ q0 }, w)= δN* ( { q0 }, w)
Hence proved that L(MD) = L(MN).

Difference between DFA, NFA, Ɛ-NFA

DFA NFA Ɛ-NFA

DFA is a 5-tuple M = (Q, ∑, δ, q0 , F) where M = (Q, ∑, δ, q0 , F) where
M = (Q, ∑, δ, q0, F) where
 Q is non empty, finite
 Q is non-empty, finite set of states.  Q is non empty, finite
set of states.  ∑ is non empty, finite set of states.
 ∑ is non-empty, finite set of input alphabets.  ∑ is non empty, finite
set of input alphabets.  δ : Q X ∑ to 2Q. set of input alphabets
 δ : Q X ∑ -> Q.  q0∈ Q is the start state.  δ : from Q X{∑UƐ} to
 q0 ∈Q is the start state.  F ⊆ Q is set of 2 Q.
accepting or final  q0∈ Q is the start state.
 F⊆ Q is set of accepting
states  F ⊆ Q is set of accepting
or final states. or final states.

30
 AUTOMATA THEORY AND COMPILER DESIGN- 21CS51
There can be zero or one There can be zero, one or There can be zero, one or
transition from a state on an more number of more number of transitions
input symbol; transitions from a state on from a state with or without
an input symbol an input symbol
Difficult to design The NFA are easier to Easy to construct using
design regular expression
More number of transitions Less number of More number of transitions
transitions compared to NFA
Less powerful since at any More powerful; than DFA More powerful than NFA
point of time it will be in only since it can be in more since at any point of time it
one state than one state will be in more than one
state with or without giving
any input.

INTRODUCTION TO COMPILER DESIGN

OVERVIEW OF LANGUAGE PROCESSING SYSTEM

Preprocessor
A preprocessor produce input to compilers. They may perform the following functions.
1. Macro processing: A preprocessor may allow a user to define macros that are short hands
for longer constructs.
2. File inclusion: A preprocessor may include header files into the program text.
3. Rational preprocessor: these preprocessors augment older languages with more modern
flow-of-control and data structuring facilities.
4. Language Extensions: These preprocessor attempts to add capabilities to the language by
certain amounts to build-in macro

31