0% found this document useful (0 votes)
23 views51 pages

Unit-1 ATCD

The document provides an introduction to automata theory, covering key concepts such as strings, alphabets, languages, and finite automata models. It explains the acceptance of strings and languages, the Chomsky hierarchy of languages, and distinguishes between deterministic and non-deterministic finite automata. Additionally, it includes formal definitions, examples, and operations related to finite automata, emphasizing their applications in recognizing patterns in input sequences.

Uploaded by

cprtv101
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
23 views51 pages

Unit-1 ATCD

The document provides an introduction to automata theory, covering key concepts such as strings, alphabets, languages, and finite automata models. It explains the acceptance of strings and languages, the Chomsky hierarchy of languages, and distinguishes between deterministic and non-deterministic finite automata. Additionally, it includes formal definitions, examples, and operations related to finite automata, emphasizing their applications in recognizing patterns in input sequences.

Uploaded by

cprtv101
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 51

UNIT- I

Introduction
Syllabus
 String
 Alphabet

 Language

 Operations

 Finite Automaton model

 Acceptance of Strings & Languages

 Chomsky hierarchy of languages

 Deterministic finite automaton

 Non deterministic finite automaton

 NFA to DFA conversion

 equivalence of DFA ‘s
Introduction
• Automata: it is a mathematical model or
abstract model.
• It is helpful for check whether the given string
belongs to language or not.
• Finite automata : it is a model (or) machine
which runs in a finite state is called finite
automata.
Representation & Notations used in
Automata
Symbols: Symbols are an entity or individual objects, which can be any letter, alphabet or
any picture.
• Example: 1, a, b, #
Alphabets: Alphabets are a finite set of symbols. It is denoted by ∑.
• Examples: ∑ = {a, b} , ∑ = {A, B, C, D} , ∑ = {0, 1, 2} , ∑ = {0, 1, ....., 5] ,
∑ = {#, β, Δ}
String: it is a collection of symbols over alphabet. The string is denoted by w.
Example 1:
• If ∑ = {a, b}, various string that can be generated from ∑ are {ab, aa, aaa, bb, bbb, ba,
aba.....}.
• A string with zero occurrences of symbols is known as an empty string. It is
represented by ε.
• The number of symbols in a string w is called the length of a string. It is denoted by |w|.
Example 2: w = 010
• Number of Sting |w| = 3
Language
• It is a collection or set of all strings over alphabet.
• It is represented as ‘L’
• A language which is formed over Σ can be Finite or Infinite.
• Given an alphabet I, a language L is a set of strings, that is a subset of
the universal language I.

Example: 1
• L1 = {Set of string of length 2} = {aa, bb, ba, bb} Finite Language
Example: 2
• L2 = {Set of all strings starts with 'a'} = {a, aa, aaa, abb, abbb,
ababb…} Infinite Language
Operations
• On languages we can define the usual set operations that are.
 union
 intersection
 Complement

• Let L1 = {10} and L2 = {011, 11}.

 Union: L1 𝖴 L2 = {10, 011, 11}

 Concatenation: L1 L2 = {10011, 1011}

 Kleene Star: L1 * = {e, 10, 1010, 101010, … }


Power of ‘∑’
• Ex:-∑ = {a,b}
0
• ∑ = set of all strings with length ‘0’. Sol: ε
1
• ∑ 2 = set of all strings with length ‘1’. Sol: {a,b}
• ∑ = set of all strings with length ‘2’.
• Sol:
3
∑. ∑={a,b} {a,b}={aa,ab,ba,bb}
• ∑ = set of all strings with length ‘3’.
• ∑. ∑. ∑ ={a,b} {a,b} {a,b}
• = {aa.ab,ba,bb}{a,b}= {aaa,,aab,aba,abb,baa,bab,bba,bbb}
• .
• . *
• ∑ (Kleene Closure): it is set of all strings of all length possible on {a,b} is called
kleene closure.
• It is+ a infinite language
* + 0
• ∑ (Positive Closure): all strings possible but ε is not available.
Formula: ∑* = ∑ + ∑ +

∑-ε=∑
Finite Automata
• Finite automata are used to recognize patterns.
• It takes the string of symbol as input and changes its state accordingly. When the
desired symbol is found, then the transition occurs.
• At the time of transition, the automata can either move to the next state or stay in the
same state.
• 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.
Formal Definition of FA
• A finite automaton is a collection of 5-tuple (Q, ∑, δ, q0, F), where:
• Q: finite set of states
• ∑: finite set of the input symbol
• q0: initial state
• F: final state
• δ: Transition function
Transition Diagram:- Transition Table:-
A transition diagram or state transition The transition table is basically a tabular
diagram is a directed graph which can representation of the transition function. It
be constructed as follows: takes two arguments (a state and a symbol)
• There is a node for each state in Q, and returns a state (the "next state").
which is represented by the circle. A transition table is represented by the
• There is a directed edge from node following things:
q0 to node q1 labeled a if δ(q0, a) = q1. • Columns correspond to input symbols.
• In the start state, there is an arrow • Rows correspond to states.
with no source. • Entries correspond to the next state.
• Accepting states or final states are • The start state is denoted by an arrow
indicating by a double circle. with no source.
• The accept state is denoted by a star.
Example
0 Symbol
Stat
es
0 1
0

1 q0 q0 q1
q0 q1
1 *q1 q1 q0
Finite automata
• Finite automata are abstract machines used to recognize patterns in input sequences, forming the
basis for understanding regular languages in computer science.
 They consist of states, transitions, and input symbols, processing each symbol step-by-step.
 If the machine ends in an accepting state after processing the input, it is accepted; otherwise, it is
rejected.
Automata can be construct with help of
• States: it represent as circle with state name.
• Transitions: directed edge between two states.
• Initial state: state with an edge from no source.
• Final state: represented as double circle with state name.
Features of Finite Automata
• Input: Set of symbols or characters provided to the machine.
• Output: Accept or reject based on the input pattern.
• States of Automata: The conditions or configurations of the machine.
• State Relation: The transitions between states.
• Output Relation: Based on the final state, the output decision is made.
Finite Automata Model
• Finite automata can be represented by input tape and finite control.
• Input tape: It is a linear tape having some number of cells. Each input symbol is
placed in each cell.
• Finite control: The finite control decides the next state on receiving particular
input from input tape. The tape reader reads the cells one by one from left to right,
and at a time only one input symbol is read.
Acceptance of String& Language :
• A String is said to be accepted by a FA M=(Q,∑,δ,q0,F) if δ(q0,x)=p for some p in F.
⚫ A language is accepted if all the strings generated from the language is accepted.
⚫ A language is said to be regular if it is the set accepted by a FA M(Finite Automata Machine).
•Ex: δ(q0,111)= δ(δ(δ(q0,1),11)
• = δ(δ(q0,1),1)
• = δ(q1,1)
• = q2 ϵ F String is accepted.
• Acceptance of Strings:
• Scan the entire String, if the input string reaches to the final state from initial state in a given
Finite Automata(either DFA or NFA) then it is said to be string is accepted.

• Acceptance of language:
• A language is said to be accepted, if all the strings in the language are accepted and some
strings not in the language are rejected in Finite Automata(FA).
Chomsky hierarchy of languages
According to Noam Chomsky, there are four types of grammars −
Type 0, Type 1, Type 2, and Type 3. The following table shows how
they differ from each other −
Grammar Type Grammar Language Automaton
Accepted Accepted

Type 0 Unrestricted Recursively Turing Machine


grammar enumerable
language

Type 1 Context-sensitive Context-sensitive Linear-bounded


grammar language automaton

Type 2 Context-free Context-free Pushdown


grammar language automaton

Type 3 Regular grammar Regular language Finite state


automaton
Chomsky hierarchy of languages
Take a look at the following illustration. It shows the scope of
each type of grammar −
Chomsky hierarchy of languages
Type 3: Regular Grammar:Type-3 grammars generate regular languages.
• These languages are exactly all languages that can be accepted by a finite-
state automaton. Type 3 is the most restricted form of grammar.
• Type 3 should be in the given form only :
• V --> VT / T (left-regular grammar)
(or)
V --> TV /T (right-regular grammar)
For example:
• S --> a
The above form is called strictly regular grammar.
• There is another form of regular grammar called extended regular grammar.
In this form:
• V --> VT* / T*. (extended left-regular grammar)
(or)
V --> T*V /T* (extended right-regular grammar)
For example :
• S --> ab.
Chomsky hierarchy of languages
Type 2: Context-Free Grammar:
• Type-2 grammars generate context-free languages.
• The language generated by the grammar is recognized by a
Pushdown automata
• In Type 2:
• First of all, it should be Type 1.
• The left-hand side of production can have only one variable
and there is no restriction on β
• ∣α∣=1.
• For example:
• S --> AB
A --> a
B --> b
Chomsky hierarchy of languages
Type 1: Context-Sensitive Grammar:
• Type-1 grammars generate context-sensitive languages.
• The language generated by the grammar is recognized by the
Linear Bound Automata
• In Type 1
• First of all Type 1 grammar should be Type 0.
• The no.of symbols on the left side of the production cannot more than
no.of symbols on the right side of the production.
• Grammar Production in the form of
• α→β
∣α∣<=∣β∣
• For Example:
• S --> AB
AB --> abc
B --> b
Chomsky hierarchy of languages
Type 0: Unrestricted Grammar:
• Type-0 grammars include all formal grammar. Type 0 grammar
languages are recognized by Turing machine. These languages are also
known as the Recursively Enumerable languages.
• Grammar Production in the form of α→β where
• α is ( V + T)* V ( V + T)*
V : Variables
T : Terminals.
• β is ( V + T )*.
• In type 0 there must be at least one variable on the Left side of
production.
• For example:
• Sab --> ba
A --> S
• Here, Variables are S, A, and Terminals a, b.
Finite Automata Types
•There are two types of finite automata
1. Deterministic Finite Automata
2. Non Deterministic Finite Automata
• Deterministic Finite Automata(DFA)
• In DFA, for each input symbol, one can determine
the state to which the machine will move. Hence, it
is called Deterministic Automaton.
• As it has a finite number of states, the machine is
called Deterministic Finite Machine or Deterministic
Finite Automaton.
Deterministic Finite Automaton (DFA)
• In DFA, there is only one path input from the current state to the next state.
• It does not accept the null move, i.e. it cannot change state without any
input.
• It can contain multiple final states. It is used in Lexical Analysis in compilers.
Formal Definition of a DFA
• A Deterministic Finite automata (DFA) is a collection of defined as a 5-tuples
and is as follows −
• M=(Q,Σ,δ,q0,F)
• Where,
• Q is a finite set of states.
• ∑ is a finite set of symbols called the alphabet.
• δ is the transition function where δ: Q × ∑ → Q
• q0 is the initial state from where any input is processed (q 0 ∈ Q).
• F is a set of final state/states of Q (F ⊆ Q).
Example:
Let a deterministic finite automaton be →
Construct a DFA that accepts all strings ending with ‘a’.
Given:
a. Σ = {a, b},
b. Q = {q0, q1},
c. F = {q1}
Transition function δ as shown by the following transition diagram and
transition table

State \ Symbol
a b
q0 q1 q0

q1 q1 q0

If the string ends in ‘a’, the machine reaches state q1, which is an accepting state.
Non Deterministic Finite Automata
In NDFA, for a particular input symbol, the machine can move to any
combination of the states in the machine. (The machine have multiple
paths on one input symbol)
In other words, the exact state to which the machine moves cannot be
determined. Hence, it is called Non-deterministic Automaton.
As it has finite number of states, the machine is called Non-deterministic
Finite Machine or Non-deterministic Finite Automaton.
Formal Definition of an NDFA:
An NDFA can be represented by a 5-tuple (Q, ∑, δ, q0, F) where
 Q is a finite set of states.
 ∑ is a finite set of symbols called the alphabets.
 δ is the transition function where δ: Q × ∑ → 2Q
(Here the power set of Q (2Q) has been taken because in case of NDFA,
from a state, transition can occur to any combination of Q states)
 q0 is the initial state from where any input is processed (q0 ∈ Q).
 F is a set of final state/states of Q (F ⊆ Q).
Non Deterministic Finite Automata
NFA is similar to DFA but includes the following features:
It can transition to multiple states for the same input.
It allows null (ϵ) moves, where the machine can change states without
consuming any input.
Example
Let a non-deterministic finite automaton be →
Construct an NFA that accepts strings ending in ‘a’.
Given:
Σ = {a, b}, Q = {q0, q1}, F = {q1}
The transition function δ as shown below by the transition diagram and
transition table −
State\
Symbol
a b

q0 {q0,q1} q0

q1 φ φ

if any transition leads to an accepting state, the string is accepted.


DFA vs. NDFA
Examples of FA
Example 1:
• Design a FA with ∑ = {0, 1} accepts those string which starts
with 1 and ends with 0.
• Solution:
1) The FA will have a start state q0 from which only the edge with
input 1 will go to the next state q1.
2) 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.
3) In state q2, if we read either 0 or 1, we will go to q2 state or q1
state respectively.
4) 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 string 101.

Solution:
In the given solution, we can see that only input string 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:
DFA- Practice Problems
1) Design a FA that accepts set of strings such that every string ends in
00,over alphabet ∑={0,1}.
2) Construct a FA that accept set of strings where the number of 0’s in every
string is multiple of three over alphabet ∑={0,1}.
3) Design a FA which accepts set of strings containing exactly four 1’s in
every string over alphabet ∑={0,1}.
4) Design a FA that accept strings containing exactly one 1 over alphabet
∑={0,1}.
5) Give a DFA for Σ = {0, 1} and strings that have an odd number of 1’s
and any number of 0’s.
6) Give a DFA for Σ = {a, b, c} that accepts any string with "aab" as a
substring.
7) Give a DFA for Σ = {a, b} that accepts any string with
"aababb" as a substring.
DFA- Practice Problems

9. For the given FA write the language and also give the transition
table.

10. For the given FA write the language and also give the transition
table.
DFA- Practice Problems
11. Design a FA over alphabet ∑={0,1},which accept the set of
strings either start with 01 or end with 01.
12. Give the DFA accepting the set of strings over alphabet
∑={0,1},such that in each string number of 0’s is divisible by
five and number of 1’s is divisible by 3.
13. Construct DFA which accept a language ∑={a,b} of all strings
containing ‘a’
14. Construct DFA which accepts all the strings over an alphabet
∑={a,b} where length of a string =2.
NFA-Practice Problems
1. Design a NFA for the language L=all string over
{0,1} that have at least two consecutive 0’s or 1’s.

2. Draw the state diagram for NFA accepting language


L=(ab)*(ba)* U aa*.

3. Draw the state diagram for NFA accepting language


L=(aba)*
U aa*.

4. Draw the state diagram for NFA accepting language


L={(an:n>=0) U (bna:n>=1)}.

5. Draw the state diagram for NFA accepting language


L=
={(an:n>=0) U (bn:n>=0)}.
Epsilon(ε) closure
• A set of states that are reached from the state ‘q’ on ε-transitions.

• ε-closure (P) = P, where P ∈ Q


• If there exists ε-closure (P) = {q} and 𝛿(q, ε) =r then, ε-closure (P) = {q, r}

• Here,
• ε-closure (q0)= {q0,q1,q2}
• self state+ ε-reachable states.
• ε-closure (q1)= { q1,q2}
• q1 is self-state and q2 is a state obtained from q1 with epsilon input.
• ε-closure (q2)= {q2}
Conversion Of E-NFA To NFA
The Process Of Conversion Of ε-NFA To NFA Is Called As Thomson Construction.
Note:-
⚫ No Change In Initial State
⚫ No Change In The Total No. Of States
⚫ May Be Change In Final States
Algorithm
Let M=(Q,Σ,δ,q0,F) – ε-NFA
M1= (Q1,Σ,δ1,q01,F1) – NFA
1) Initial State
q01=q0
2) Construction Of δ1
δ1

(q,x)=ε-Closure(δ(ε-Closure(q),x)
3) Final State
Every State Who’s ε-Closure Contain Final State Of ε-NFA Is Final State In NFA
Conversion Of E-NFA To NFA -example

⚫ ε-Closure(q0)-{q0,q1}
⚫ ε-Closure(q1)-{q1}
1. Initial State : q0
2. Construction Of δ1
δ1=(q0,0)=ε-Closure(δ(ε-Closure(q0,0)
=ε-Closure(δ({q0,q1},0))
=ε-Closure(q0)
={q0,q1}
Conversion Of E-NFA To NFA -example

δ1=(q0,1)=ε-Closure(δ(ε-Closure(q0,1)
=ε-Closure(δ({q0,q1},1))
=ε-Closure(q1)
={q1}

δ1=(q1,0)=ε-Closure(δ(ε-Closure(q1,0)
=ε-Closure(δ({q1},0))
=ε-Closure(Φ)

δ1=(q1,1)=ε-Closure(δ(ε-Closure(q1,1)
=ε-Closure(δ({q1},1))
=ε-Closure(q1)
={q1}
Conversion Of E-NFA To NFA -example

3. Final State?
⚫ q0 & q1 Both Are Final States Because
ε-Closure(q0)={q0,q1}
ε-Closure(q1)={q1}
Conversion from NFA to DFA
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)
Conversion from NFA to DFA-
Example

State 0 1

→q0 q0 q1

q1 {q1, q2} q1

*q2 q2 {q1, q2}


Conversion from NFA to DFA-Example
δ'([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,

δ'([q1, q2], 0) = δ(q1, 0) 𝖴 δ(q2, 0)


q2].

= {q1, q2} 𝖴 {q2}

δ'([q1, q2], 1) = δ(q1, 1) 𝖴 δ(q2, 1)


= [q1, q2]

= {q1} 𝖴 {q1, q2}


= {q1, q2}
= [q1, q2]
Conversion from NFA to DFA-
Example
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]


Note: The state q2 can be
eliminated because q2 is
an unreachable state
Minimization of FSM:
⚫ Suppose there is a DFA ,D < Q, ∑, q0, δ, F > which recognizes a language
L. Then the minimized DFA D < Q’, ∑, q0, δ’, F’ > can be constructed
for language L as:
Step 1: We will divide Q (set of states) into two sets. One set will contain
all final states and other set will contain non-final states. This partition is
called P0.
Step 2: Initialize k = 1
Step 3: Find Pk by partitioning the different sets of Pk-1. In each set of Pk-1,
we will take all possible pair of states. If two states of a set are
distinguishable, we will split the sets into different sets in Pk.
Step 4: Stop when Pk = Pk-1 (No change in partition)
Step 5: All states of one set are merged into one. No. of states in
minimized DFA will be equal to no. of sets in Pk.
⚫ Example
Consider the following DFA shown in figure.

Minimization of FSM:
Minimization of FSM:
⚫ Step 1. P0 will have two sets of states. One set will contain q1, q2, q4 which
are final states of DFA and another set will contain remaining states. So P0 =
{
{ q1, q2, q4 }, { q0, q3, q5 } }.
Step 2. To calculate P1, we will check whether sets of partition P0 can
be partitioned or not:
⚫ For set { q1, q2, q4 } :
δ ( q1, 0 ) = δ ( q2, 0 ) = q2 and δ ( q1, 1 ) = δ ( q2, 1 ) = q5, So q1 and
q2 are
not distinguishable.
Similarly, δ ( q1, 0 ) = δ ( q4, 0 ) = q2 and δ ( q1, 1 ) = δ ( q4, 1 ) = q5, So
q1 and q4 are not distinguishable.
Since, q1 and q2 are not distinguishable and q1 and q4 are also
not distinguishable, So q2 and q4 are not distinguishable. So,
{ q1, q2, q4 } set will not be partitioned in P1.
Minimization of FSM:
⚫ For set { q0, q3, q5 } :
δ ( q0, 0 ) = q3 and δ ( q3, 0 ) =
q0 δ ( q0, 1) = q1 and δ ( q3, 1 )
= q4
Moves of q0 and q3 on input symbol 0 are q3 and q0 respectively which are
in same set in partition P0. Similarly, Moves of q0 and q3 on input symbol
1 are q3 and q0 which are in same set in partition P0. So, q0 and q3 are not
distinguishable.
⚫ δ ( q0, 0 ) = q3 and δ ( q5, 0 ) = q5 and δ ( q0, 1 ) = q1 and δ ( q5, 1 ) = q5
Moves of q0 and q5 on input symbol 0 are q3 and q5 respectively which
are in different set in partition P0. So, q0 and q5 are distinguishable. So,
set { q0, q3, q5 } will be partitioned into { q0, q3 } and { q5 }. So,
P1 = { { q1, q2, q4 }, { q0, q3}, { q5 } }
Minimization of FSM:
⚫ To calculate P2, we will check whether sets of partition P1 can be partitioned
or not:

For set { q1, q2, q4 } :
δ ( q1, 0 ) = δ ( q2, 0 ) = q2 and δ ( q1, 1 ) = δ ( q2, 1 ) = q5, So q1 and q2
are not distinguishable.
Similarly, δ ( q1, 0 ) = δ ( q4, 0 ) = q2 and δ ( q1, 1 ) = δ ( q4, 1 ) = q5, So
q1 and q4 are not distinguishable.
Since, q1 and q2 are not distinguishable and q1 and q4 are also not
distinguishable, So q2 and q4 are not distinguishable. So,
{ q1, q2, q4 } set will not be partitioned in P2.
Minimization of FSM:
⚫ For set { q0, q3 } :
δ ( q0, 0 ) = q3 and δ ( q3, 0 ) =
q0 δ ( q0, 1 ) = q1 and δ ( q3, 1 )
= q4
Moves of q0 and q3 on input symbol 0 are q3 and q0 respectively which are
in same set in partition P1. Similarly, Moves of q0 and q3 on input symbol 1
are q3 and q0 which are in same set in partition P1. So, q0 and q3 are not
distinguishable.
⚫ For set { q5 }:
Since we have only one state in this set, it can’t be further partitioned. So,
P2 = { { q1, q2, q4 }, { q0, q3 }, { q5 } }
Since, P1=P2. So, this is the final partition. Partition P2 means that q1, q2
and q4 states are merged into one. Similarly, q0 and q3 are merged into one.
Minimized DFA corresponding to DFA of Figure 1 is shown in Figure 2 as:
Minimization of FSM:
Equivalence between two FSM’s:

Definition : (equivalence of finite state machines): Two finite


state machines M1 and M2 are equivalent (M1≡M2) if they
have the same input and output alphabets and if, starting from
their respective initial states, they produce the same output for
any input string.
Equivalence between two FSM’s:
Equivalence between two FSM’s:
• Solution: The initial states in M1 and M2 are q1 and q4. |Let
us see that combined transition of M1 and M2 on inputs c and
d as follows:

States/Inputs c d

(q1,q4) (q1,q4) (q2,q6)


(q2,q6) (q3,q7) (q1,q4)
(q3,q7) (q2,q5) (q3,q7)
(q2,q5) (q3,q7) (q1,q4)
Equivalence between two FSM’s:
 (q1,q4) is new state
 (q2,q6) is new state
 (q3,q7) is new state
 (q2,q5) is new state

Let us analyze the above transition table carefully, then we find


that, the behavior of M1 and M2 is similar.

We do not get a pair (q , q’) where q is a final state ,and q’ is a


non final state (or vice versa) at every row. Therefore M and
M’ are equivalent.

You might also like