Finite Automata

AUTOMATA THEORY AND FORMAL LANGUAGES
Finite Automata
Deterministic Finite Automata
(DFA)
OBJECTIVES
At the end of the module, the learner should be able to:
• Demonstrate understanding of the theory of Finite Automata
• Apply the concepts of Deterministic Finite Automata (DFA)
• Determine acceptability of a string using Extended
Transition of DFA
Introduction to Automata Theory
Automata Theory
➢ Is the study of abstract computing device, or “machines”.
➢ It deals with the logic of computation with respect to simple
machines, referred to as automata.
➢ It deals with the definitions and properties of mathematical
models of computation such as Finite Automaton and
Context-Free Grammar.
➢ Through automata, computer scientists are able to
understand how machines compute functions and solve
problems.
Brief History of Automata
• Conceived the first infinite model of computation in 1936

* Alan Turing
• First to present a description of finite automata in 1943:

* Warren McCulloch
* Walter Pitts
• Generalized automata theory to a much more powerful machine in

1955: * G. H. Mealy * E.F. Moore
Applications of Automata and Formal Languages
1. It serves as a preparation and introduction to circuit design.
2. Knowledge of automata is very important in designing compilers.
3. Regular expressions in automata provide a thousand and one uses for
professional programmers.
4. Searching for patterns in texts can be carried out efficiently using
automata.
5. Automata and its formal languages are useful in natural language
processing.
6. Algebraic theory of recognizable language can be developed using
automata theory and its languages.
Terminologies
Alphabet
o A finite, nonempty set of symbols. Denoted by , whose elements are called

symbols.
o  + denotes set of all nonempty strings on 
o * =  +  { λ }
Examples:
 = { 0, 1 } → the binary alphabet

 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } → 10 element set of decimal digits
 = { a, b, c, . . . , x, y, z } → 26 element set of lowercase characters
of the English language
Terminologies
String
o A list of symbols from an alphabet.
o An ordered n-tuple of elements of ∑ , written without punctuation.
Examples:
1101 → from  = { 0, 1 } of length 4
a, ab, aac, bbac → from  = {a, b, c} of length 1, 2, 3 and 4 respectively
* → set of all strings over  of any finite length.
→ there is a unique string of length zero over 
called the null string (empty string) and is
denoted by ε.
Terminologies
Concatenation of two strings u, v ∈ ∑*
o Is the string uv obtained by joining the strings end-to-end.
Example:
if u = ab, v=ra and w=cad

then vu=raab uu=abab and wv=cadra
This generalizes to the concatenation of three or more strings.
i.e. : uvwuv = abracadabra

Terminologies
Length of a String
o The number of positions for symbols in the string. Denoted by
| w |.
Let w = a1a2 . . . ak  *, where a1a2 . . . ak  .

Then k is called the length of the string:
w = a1a2 . . . ak, and this is expressed by writing
| w |.
Examples: | 011 | = 3 | λ | = 0
Terminologies
Empty String
o The string of zero length is called the empty string. This is denoted by
 or .
o The empty string plays the role of 0 in a number system.
Reverse String
o If w = w1 w2…wn where w1  ∑ the reverse of w is wn wn-1…w1 .
Substring
o z is a substring of w if z appears consecutively within w.
Example: deck is a substring of abcdeckabcjkl.
Terminologies
Suffix if w= xv for some x, then v is suffix of w
Prefix if w= vy for some y, then v is suffix of w
Lexicographic ordering of string is the same as the dictionary

ordering, except the shorter strings precede longer strings.
Example: Lexicographic ordering of all strings over the alphabet

{0,1} is (, 0, 1, 00, 01, 11, 000, …).
Terminologies
Language
o A set of strings from the same alphabet. Denoted by L(M).
o The set of all strings, including the empty string over and alphabet ∑
is denoted as ∑*.
o Infinite language L are denoted as: L={w  ∑+: w has property P}
Example:
L(M) = {, 01, 10, 0011, 0101, 1001, . . . }
L1 = {w  {0,1}*: w has an equal number of 0’s and 1’s.
L2 = {w  ∑+: w = wR} where wR is the reverse string of w.
Terminologies
Concatenation of Language
If L1 and L2 are languages over ∑, their concatenation is L = L1• L2 or

simply L= L1L2 , where:
L={w ∈ ∑+ : w = x • y for some x ∈ L1 and y ∈ L2}

Example:
Given ∑={0,1}
L1 = {w ∈ ∑+ : w has an even number of 0’s}
L2 = {w: w starts with a 0 and the rest of the symbols are 1’s}
Terminologies
Powers of an Alphabet
o The set of all strings of a certain length from .
o Denoted by k
Examples: 0 = {  } 1 = { 0, 1 } 2 = { 00, 01, 10, 11 }
Note:
The set of all strings over an alphabet  is conventionally denoted by:
 * = 0  1  2  . . .
Examples: { 0, 1 }* = { , 0, 1, 00, 01, 10, 11, 000, . . . }
Terminologies
State
o Its purpose is to remember the relevant portion of the system’s
history.
Type Conventions for Symbols and Strings
1. states → q’s and p’s

2. q0 → initial state
3. 0, 1, a, b → input symbols
4. w, x, y, z → strings of input symbols
PROOF TECHNIQUES
The basic structure of a proof is easy: it is just a series of
statements, each one being either
✓ An assumption or
✓ A conclusion, clearly following from an assumption
or previously proved result.
▪ Direct Proof
▪ Proof by Contradiction
▪ Proof by Contrapositive
▪ If and only if
▪ Proof by Mathematical Induction
FINITE AUTOMATA
• Informally, a state diagram that comprehensively captures
all possible states and transitions that a machine can take
while responding to a stream or sequence of input symbols.
• It consists of a finite set of state and a set of transitions from
state to state that occur on input symbols chosen from an
alphabet
• Used in text processors, compilers and hardware design
• Recognizer for “Regular Languages”.
FINITE AUTOMATA
Examples of Finite Automata
1. Software for designing and checking the behavior of digital circuits.

2. The compiler component that breaks the input text into logical units,
such as identifiers, keywords and punctuation.
3. Software for scanning large bodies of text, such as collections of Web
pages, to find occurrences of words, phrases, or other patterns.
4. Software for verifying systems of all types that have a finite number of
distinct states, such as communications protocols or protocols for
secure exchange of information.
FINITE AUTOMATA
Examples of Finite Automata
A finite automaton A finite automaton modeling

modeling an on/off recognition of the word then
switch
FINITE AUTOMATA
Classes of Finite Automata
1. Deterministic Finite Automaton (DFA)
* The automaton cannot be in more than one state at any one time.
* For each input symbol in , there is exactly one transition of each
state (possibly back to the state itself).
* It does not accept empty strings.
2. Nondeterministic Finite Automaton (NFA)

* The automaton may be in several states at once.
* It allows zero, one or more transitions for every input symbol.
* It accepts empty strings.
WAYS OF PRESENTING FINITE AUTOMATA
1. State Diagram (or Transition Graph)
• A transition graph is a directed graph in that the vertices represent the internal
states of the automaton, and the edges represent the transitions.
• The labels on the vertices are the names of the internal states, while the labels on the
edges are the current values of the input symbols.
• The vertices of the graph correspond to the state of the FA.
• If there is a state q to p on input a, then there is an arc labeled "a" from state q to p.
• The FA accepts a string X if the sequence of transition corresponding to the symbols
of X from the start state leads to an accepting state.
2. State Table (or Transition Table)
3. Transition Function →  (set of states, set of input
alphabet)
DETERMINISTIC FINITE AUTOMATA (DFA)
Formal Definition of a DFA
DFA is defined by the 5-tuple: { Q, , , q0, F }
where:
Q → a finite set of states
∑ → a finite set of input symbols (alphabet)
q0 → a start state
F → set of final states
δ → a transition function, which is a mapping
between Q x ∑ → Q and takes as arguments a state and an
input symbol and returns a state.
(i.e., (q0, x) = q1)
What does a DFA do on reading an input string?
Input: a word w in ∑*
Question: Is w acceptable by the DFA?
Steps:
• Start at the “start state” q0
• For every input symbol in the sequence w do
Compute the next state from the current state,
given the current input symbol in w and the
transition function
• If after all symbols in w are consumed, the current state is one
of the final states (F) then accept w; Otherwise, reject w.
Dead State
Are those non final state which transits in itself for all
input symbol.
Example 1:
Build a DFA for the following language:
L = {w | w is a binary string that contains 01 as a substring}
Steps for building a DFA to recognize L:

∑ = {0,1}
Decide on the states: Q
Designate start state and final state(s)
δ: Decide on the transitions:
Solution on next slide
Final states == same as “accepting states”
Other states == same as “non-accepting states”
1 0,1
0
0 1
start
q0 q1 q2
Final
state
Example 2:
Design a DFA, M which accepts the language:
L(M) = {w  (a, b)* :w does not contain three consecutive b’s)}
Let M = (Q, ∑, δ, q0 , F ) δ is defined as follows:

δ a b
where: q0 q0 q1
Q = {q0, q1, q2, q3} q1 q0 q2
∑ = {a, b} q2 q0 q3
q0 is the initial state q3 q3 q3 Solution on next slide
F = {q0, q1 q2,}
State Diagram State Table Transition Function
a b δ(q0, a) = q0
→ q0 q0 q1 δ(q0, b) = q1
* q1 q0 q2 δ(q1, a) = q0
q2 q0 q3 δ(q1, b) = q2
q3 q3 q3 δ(q2, a) = q0
δ(q2, b) = q3
δ(q3, a) = q3
δ(q3, b) = q3
Example 3:
Determine the DFA schematic for : M = (Q, ∑, δ, q1 , F )
where: δ is defined as:

Q = {q1, q2, q3} δ 0 1
∑ = {0,1} q1 q1 q2
q2 q3 q2
q1 is the start state
q3 q2 q2
F = {q2}

L={w | w contains at least one 1 and an even

number of 0’s follow the last 1}
Example 4:
Sketch the DFA given:

M= ({q1, q2}, {0, 1}, δ ,q1, {q2}) and
δ is given by:
δ(q1, 0) = q1
δ(q1, 1) = q2
δ(q2, 0) = q1
δ(q2, 1) = q1
Example 5:
Design a DFA, the language recognized by the Automaton being
L= {a b:
n n≥0}
Extended Transition of DFA
Let M = ( Q, , q0, , F ) be a DFA and w  *.
To describe the behavior of M on w, we extend the transition function 
to apply to a state and a string rather than a state and an input symbol.
The extended transition function for M, written as * is the function:
defined recursively as follows:

(i) *(q, λ) = q for all q  Q
(ii) *(q, wa) = (*(q, w),a) for all w  *, a   and q  Q
Note that for any a  :
Thus, * extends  from a single letter to a string.

Let w = abba  *, determine if the

string abba is accepted or rejected by the
DFA.
Nondeterministic Finite Automata
(NFA)
OBJECTIVE
■At the end of the module, the learner should be able to:
- Apply the concepts of Nondeterministic Finite Automata
(NFA)
- Determine acceptability of a string using Extended
Transition of NFA
- Convert NFA to DFA
- Apply the concepts of NFA with e-transitions
- Convert eNFA to NFA
NONDETERMINISTIC FINITE AUTOMATA (NFA)
Question: Is a real computer a DFA or a NFA?
Answer: It is a DFA because it has a definite or unique state that
it goes through after receiving an input.
Question: Why learn NFA?

Answer: In order to write a program on DFA, all possible
scenarios for the alphabet and all possible transitions should be
considered. Hence knowledge of NFA is needed in order
to write a program on DFA.
What is a NFA?
It is a FA where there exist a nondeterminism for a given input
symbol, which may lead to more than one state or may not go to
any state, meaning, empty transition.
What is the difference with NFA?

It is a 5-tuple where the only difference from a DFA is the
concept of transition. The NDFA transition function is the
mapping of sets of states and the alphabet set to the power set.
The NDFA transition operates over a set of strings.
Formal definition:
It is a FA where L(M) = {Q, ∑ , δ , q0, F }

where:
Q → a finite set of states
∑ → a finite set of input symbols (alphabet)
q0 → a start state
F → set of final states
δ → Q x ∑ → 2Q (a transition function, which is a mapping
of states and alphabet set to its power set)
Examples:
How to use an NFA?
Input: a word w in ∑*
Question: Is w acceptable by the NFA?
Steps:
• Start at the “start state” q0
• For every input symbol in the sequence w do
Determine all possible next states from all current states,
given the current input symbol in w and the transition
function.
• If after all symbols in w are consumed and if at least one of the current
states is a final state then accept w; otherwise, reject w.
Example 1: NFA for strings containing 01
Why is this non-deterministic? • Q = {q0,q1,q2}

•  = {0,1}
0,1 0,1
• start state = q0
start 0 1 • F = {q2}
q0 q1 q2
•
Final
state symbols
0 1
What will happen if at state q1 q0 {q0,q1} {q0}
states
an input of 0 is received? q1 Φ {q2}
q2 {q2} {q2}
Example 1: NFA for strings containing 01
Example 2:
Solution next slide

a) Write the transition table.
b) Find a directed walk with the label bbabbaa from q0 to q4.
c) Is baa in L(M)?
Solution:
Transition Function of NFA
Example 3: L = {string that starts with ‘a’}
Example 4: Create an NFA with an
L(M) = {x ∈ {a,b,c}* | x contains the patterns abac}
Extended Transition Function of NFA
Extended Transition Function of NFA
Example:
Determine if the string

abba is accepted or not.
ADVANTAGES AND CAVEATS FOR NFA
• Great for modeling regular expressions
• String processing - e.g., grep, lexical analyzer
• Could a non-deterministic state machine be implemented in
practice?
• A parallel computer could exist in multiple “states” at the
same time
• Probabilistic models could be viewed as extensions of non-
deterministic state machines.
(e.g., toss of a coin, a roll of dice)
NFA vs DFA
NFA DFA
1. Some transitions could be non- 1. All transitions are deterministic.
deterministic. A transition could lead to Each transition leads to exactly
a subset of states. one state.
2. Not all symbol transitions need to be 2. For each state, transition on all
defined explicitly (if undefined will go possible symbols (alphabet)
to a dead state – this is just a design should be defined.
convenience, not to be confused with
“non-determinism”).
3. Accepts input if one of the last states is 3. Accepts input if the last state is in
in F. F.
4. Generally easier than a DFA to 4. Sometimes harder to construct
construct. because of the number of states.
5. Practical implementation has to be 5. Practical implementation is
deterministic (convert to DFA) or in the feasible.
form of parallelism.
But, DFAs and NFAs are equivalent in their power to capture languages !!
DFA EQUIVALENT OF NFA
Theorem:
A language L is accepted by a DFA if and only if it is accepted by an
NFA.
Proof:
1. If part:
Prove by showing every NFA can be converted to an equivalent DFA.
2. Only-if part is trivial:

Every DFA is a special case of an NFA where each state has exactly
one transition for every input symbol. Therefore, if L is accepted by a
DFA, it is accepted by a corresponding NFA.
NFA to DFA by Subset Construction
Let N = ( QN, ∑, δN, q0, FN ) be the NFA
Goal: Build D={ QD, ∑, δD, {q0}, FD } s.t. L(D) = L(N)
Construction:
QD= all subsets of QN (i.e., power set)
FD=set of subsets S of QN s.t. S ∩ FN ≠ Φ
δD: for each subset S of QN and for each input symbol a in ∑:
δD(S,a) = U δN(p,a)
Note that:  DFA =  NFA and q0 DFA = q0 NFA
In equivalent DFA, all states bearing the final state of the NFA shall also
be designated as the DFA's final states.
Procedure:
1. Determine the number of states for the DFA: Q' = 2Q NFA. This will be the names of
the states for the DFA.
2. Draw the initial state diagram of the DFA with Q' as states, including the initial
state and the designated final states.
3. Construct the edges of the DFA states through the use of NFA transition function.
For each state, create a new state on the DFA state table. When no more states can
be added, process terminates.
The states that cannot be reached from the initial state are not included in Q. Hence,
Q' is not necessarily equal to 2Q.
Given the NFA State Diagram:
Convert it to DFA.
Solution next slides
Convert an NFA to DFA, easier technique
2. Convert the NFA transition table to DFA transition table
0 1
-->q0 q0, q1 q1
q0,q1 q0,q1 q0,q1
q1 {} q0,q1
{} {} {}
1. Create the transition table of NFA 3. Draw the DFA transition graph
0 1
-->q0 q0, q1 q1
*q1 {} q0,q1
NFA to DFA using Lazy Creation
Idea: To avoid enumerating all of power set, do “lazy creation of states”
L = {w | w ends in 01} DFA: 1 0
0,1 0 1
NFA: {q0} {q0,q1}
0
{q0,q2}
0 1 1
q0 q1 q2
A few subtle properties of DFAs and NFAs
The machine never really terminates. It is always
waiting for the next input symbol or making transitions.
The machine decides when to consume the next symbol
from the input and when to ignore it. (but the machine
can never skip a symbol).
A transition can happen even without really consuming
an input symbol (think of consuming  as a free token).
A single transition cannot consume more than one
symbol.
NFA with Epsilon Transition
Allow explicit -transitions in finite automata i.e., a transition
from one state to another state without consuming any
additional input symbol.
Makes it easier sometimes to construct NFAs.
Definition:  -NFAs are those NFAs with at least one
explicit -transition defined.
 -NFAs have one more column in their transition table.
Example:
• Unlike NFA, NFA with empty transitions can switch from one state to another
without consuming an input symbol.
• Anything that can be represented with an ϵNFA can be represented with a DFA that
has no ϵ-transitions.
Formal Definition: It is a 5-tuple: M = ( Q, , , q0, F )
where:  → Q x (   { ϵ } ) → 2Q
(q, a) = { P | (q, a) → P and a =  or a  

The intention is that (q, a) will consist of all states P, where 'a' is either a
symbol in  or it is .
Example 1: Machine to accept decimal numbers

Example 2:
State Table:
eNFA 0 1 2 
→ q0 {q0} {} {} {q1}
q1 {} {q1} {} {q2}
* q2 {} {} {q2} {}
ε-Closure
NFA with Epsilon Transition -closure of a state q, ECLOSE(q)
• Is the set of all states (including
itself) that can be reached from q
Example: by repeatedly making an
arbitrary number of -
transitions.
ECLOSE(q0) = { q0, q1, q2 }
ECLOSE(q1) = { q1, q2 }
ECLOSE( {q0, q1 } ) = ECLOSE(q0)  ECLOSE(q1)

= {q0, q1, q2}  {q1, q2}
= {q0, q1, q2}
ECLOSE( {q1, q2 } ) = ECLOSE(q1)  ECLOSE(q2)

= {q1,q2}  {q2}
= {q1, q2}
Example of another -NFA
0,1
δE 0 1
*
*q’0 Ø Ø {q’0,q0,q3}
0 1
q0 q1 q2 q0 {q0,q1} {q0} {q0,q3}
  1
q1 Ø {q2} {q1}
start q3 *q2 Ø Ø {q2}
q’0
q3 Ø {q2} {q3}
To simulate any transition:

Step 1) Go to all immediate destination states.
Step 2) From there go to all their -closure states as well.
Equivalent Given the NFA, convert to NFA:
E/Δ a b 
NFA of →q0 q0 Ø q1
q1 Ø Ø q2
eNFA *q2 Ø q2 Ø
NFA Transition Table

E/Δ a b
→q0
q1
*q2

Finite Automata

Uploaded by

Finite Automata

Uploaded by

AUTOMATA THEORY AND FORMAL LANGUAGES

• Conceived the first infinite model of computation in 1936

• First to present a description of finite automata in 1943:

• Generalized automata theory to a much more powerful machine in

o A finite, nonempty set of symbols. Denoted by , whose elements are called

 = { 0, 1 } → the binary alphabet

if u = ab, v=ra and w=cad

This generalizes to the concatenation of three or more strings.

i.e. : uvwuv = abracadabra

Let w = a1a2 . . . ak  *, where a1a2 . . . ak  .

Lexicographic ordering of string is the same as the dictionary

Example: Lexicographic ordering of all strings over the alphabet

If L1 and L2 are languages over ∑, their concatenation is L = L1• L2 or

L={w ∈ ∑+ : w = x • y for some x ∈ L1 and y ∈ L2}

Examples: 0 = {  } 1 = { 0, 1 } 2 = { 00, 01, 10, 11 }

1. states → q’s and p’s

1. Software for designing and checking the behavior of digital circuits.

A finite automaton A finite automaton modeling

2. Nondeterministic Finite Automaton (NFA)

Steps for building a DFA to recognize L:

Let M = (Q, ∑, δ, q0 , F ) δ is defined as follows:

where: δ is defined as:

Solution on next slide

L={w | w contains at least one 1 and an even

Sketch the DFA given:

Design a DFA, the language recognized by the Automaton being

The extended transition function for M, written as * is the function:

defined recursively as follows:

Thus, * extends  from a single letter to a string.

Let w = abba  *, determine if the

Question: Why learn NFA?

What is the difference with NFA?

It is a FA where L(M) = {Q, ∑ , δ , q0, F }

Why is this non-deterministic? • Q = {q0,q1,q2}

Solution next slide

Determine if the string

2. Only-if part is trivial:

L = {w | w ends in 01} DFA: 1 0

(q, a) = { P | (q, a) → P and a =  or a  

Example 1: Machine to accept decimal numbers

ECLOSE(q0) = { q0, q1, q2 }

ECLOSE( {q0, q1 } ) = ECLOSE(q0)  ECLOSE(q1)

ECLOSE( {q1, q2 } ) = ECLOSE(q1)  ECLOSE(q2)

To simulate any transition:

NFA Transition Table

You might also like