3-FiniteAutomata Anim

(Unit-1 part-B)
 Deterministic Finite Automata: Definition of DFA, How A DFA

Process Strings, The language of DFA
 Nondeterministic Finite Automata: Formal Definition, an
application, Text Search, Finite Automata with Epsilon-
Transitions.
 Conversion of NFA with €-transitions to NFA without €-
transitions. Conversion of NFA to DFA, Moore and Melay
machines
Dr.K.Shahu Chatrapati Ph.D,MCSI,MISTE
Professor & HOD
Dept of CSE,JNTUHCEM 1
Finite Automaton (FA)
 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
 Recognizer for “Regular Languages”
 Deterministic Finite Automata (DFA)

 The machine can exist in only one state at any given time
 Non-deterministic Finite Automata (NFA)
 The machine can exist in multiple states at the same time
Professor & HOD
Deterministic Finite Automata
- Definition
 A DFA 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 alphabet.
 δ is the transition function where
δ: Q × ∑ → Q
 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).
Professor & HOD
Graphical Representation of a
DFA: State Diagram
Graphical Representation of a DFA
 A DFA is represented by
digraphs called state diagram.
 The vertices represent the
states.
 The arcs labeled with an input
alphabet show the transitions.
 The initial state is denoted by an
empty single incoming arc.
 The final state is indicated by
double circles or *.
Professor & HOD
Transition Table:
The transition table is basically a tabular
representation of the transition function. It
takes two arguments (a state and a symbol)
and returns a state (the "next state").
 Columns correspond to input symbols.
 Rows correspond to states.
 Entries correspond to the next state.
Present Next Next
 The start state is denoted by an arrow
State state for State of with no source.
Input 0 Input 1  The accept state is denoted by a double
circle .
→q0 q1 q2
q1 q0 q2
q2
q2 q2 Professor & HOD
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:
 “Final” states == same as “accepting states”
 Other states == same as “non-accepting states”
Professor & HOD
Dept of CSE,JNTUHCEM
6
Regular expression: (0+1)*01(0+1)*
DFA for strings containing 01
• What makes this DFA deterministic? • Q = {q0,q1,q2}
1 0 0,1 • ∑ = {0,1}
• start state = q0
start 0 1
q0 q1 q2 • F = {q2}
Accepting • Transition table
state symbols
0 1
q0 q1 q0
states
q1 q1 q2
Dr.K.Shahu Chatrapati Ph.D,MCSI,MISTE *q2 q2 q2
Professor & HOD
Dept of CSE,JNTUHCEM • * indicate final state 7
Extension of transitions (δ) to
Paths (δ)
δ (q,w) = destination state from state q on input string w
In above example :
δ (q0,1)=qo
δ (q0,0)=q1
δ (q1,0)=q1
δ (q1,1)=q2
δ (q2,0)=q2
δ (q2,1)=q2
Note: if no transition output is :⏀
Professor & HOD
Example #2
Design a FA with ∑ = {0, 1} accepts those string which starts with 1 and
ends with 0.
Professor & HOD
DFA:String acceptance
 In Above example
= δ (q0,1110)
= δ(q1,110)
=δ(q1,10)
=δ(q1,0)
=δ(q2, ε) (δ(q, ε)=q)
=q2 (final state) string
Professor & HOD
Example #3
 Build a DFA for the following language:
L = { w | w is a binary string that has even
number of 1s and even number of 0s}
 ?
Professor & HOD
11
Non-deterministic Finite
Automata (NFA)
 A Non-deterministic Finite Automaton
(NFA)
 is of course “non-deterministic”
 Implying that the machine can exist in more
than one state at the same time
 Transitions could be non-deterministic
1 qj
qi … • Each transition function therefore
1 maps to a set of states
qk
Professor & HOD
Non-deterministic Finite
Automata (NFA)
An NFA is also defined by the 5-tuple:
 {Q, ∑ , q0,F, δ }
 Q ==> a finite set of states
 ∑ ==> a finite set of input symbols (alphabet)
 q0 ==> a start state
 F ==> set of accepting states
 δ ==> a transition function, which is a mapping
between Q x ∑ ==> 2Q
Professor & HOD
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.
Professor & HOD
14
Regular expression: (0+1)*01(0+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
q0 q1 q2 • F = {q2}
Final • Transition table
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}
Professor & HOD
Extension of δ to NFA Paths
 Basis: δ (q,) = {q}
 Induction:
 Let δ (q0,w) = {p1,p2…,pk}
 δ (pi,a) = Si for i=1,2...,k
 Then, δ (q0,wa) = S1 U S2 U … U Sk
Ex: δ(q0q1,a)= δ(q0,a) U δ(q1,a)

Professor & HOD
 In above example :
 δ (q0,0)={q0,q1}
 δ (q0,1)= q0
 δ (q1,0)= ⏀
 δ (q1,1)=q2
 δ (q2,0)=q2
 δ (q2,1)=q2
 Note: if no transition output is :⏀
Professor & HOD
NFA:String acceptance
 Check input string :0011
=δ (q0, 0011)
= δ (q0q1,011)= δ (q0,0)U δ (q1,0)
=q0q1UΦ
=q0q1
= δ(q0q1,11)=δ (q0,1)U δ (q1,1)
=q0Uq2
=q0q2
= δ(q0q2,1)=δ (q0,1)U δ (q2,1)
=q0Uq2
=q0q2
= δ(q0q2, ε)=q0,q2 (q2 is the final state so string accepted in this
machine)
Professor & HOD
 In above example :
 δ (q0,1)=qo
 δ (q0,0)=q1
 δ (q1,0)=q1 Note: if no transition output is :⏀
 δ (q1,1)=q2
 δ (q2,0)=q2
 δ (q2,1)=q2
Professor & HOD
Note: Omitting to explicitly show error states is just a matter of design convenience
(one that is generally followed for NFAs), and
i.e., this feature should not be confused with the notion of non-determinism.
What is an “error state”?

 A DFA for recognizing the key word
“while” w h i l e
q0 q1 q2 q3 q4 q5
Any other input symbol

qerr
Any symbol
 An NFA for the same purpose:

w h i l e
q0 q1 q2 q3 q4 q5
Professor & HOD
Dept of CSE,JNTUHCEM Transitions into a dead state are implicit 20
Example #2
 Build an NFA for the following language:
L = { w | w ends in 01}
 ?
 Other examples
 Keyword recognizer (e.g., if, then, else,
while, for, include, etc.)
 Strings where the first symbol is present
somewhere later on at least once
Professor & HOD
Example #3
NFA with ∑ = {0, 1} and accept all string of
length atleast 2.
Present State Next state for Input 0 Next State of Input 1
→q0 q1 q1
q1 q2 q2
*q2 ε ε
Professor & HOD
But, DFAs and NFAs are equivalent in their power to capture langauges !!
Differences: DFA vs. NFA

 NFA
DFA
1. All transitions
Some transitions
are could
deterministic
be non-deterministic
 Each
A transition
transition
could
leads
leadtotoexactly
a subset
one
ofstate
states
2. Not each
For all symbol
state,transitions
transition on
need
all to
possible
be defined
symbols
explicitly
(alphabet)
(if undefined
should
be defined
will go to an error state – this is just a design convenience, not to be
3. confused with if“non-determinism”)
Accepts input the last state visited is in F
3.
4. Accepts
Sometimes input if onetoofconstruct
harder the last states is inofFthe number of states
because
4.
5. Generally easier than a DFA
Practical implementation to construct
is feasible
5. Practical implementations limited but emerging (e.g., Micron
automata processor)
Professor & HOD
Equivalence of DFA & 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 (in the next few slides…)
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.
Professor & HOD
Proof for the if-part
 If-part: A language L is accepted by a DFA if it
is accepted by an NFA
 rephrasing…
 Given any NFA N, we can construct a DFA D
such that L(N)=L(D)
 How to convert an NFA into a DFA?
 Observation: In an NFA, each transition maps to a
subset of states
 Idea: Represent:
each “subset of NFA_states”  a single “DFA_state”
Professor & HOD
NFA to DFA by subset construction
 Let N = {QN,∑,δN,q0,FN}
 Goal: Build D={QD,∑,δD,{q0},FD} s.t.
L(D)=L(N)
 Construction:
1. QD= all subsets of QN (i.e., power set)
2. FD=set of subsets S of QN s.t. S∩FN≠Φ
3. δD: for each subset S of QN and for each input symbol
a in ∑:
 δD(S,a) = U δN(p,a)
Professor & HOD
NFA to DFA construction:
Example
Adobe Acrobat
Document
Professor & HOD
27
FA with -Transitions
 We can allow explicit -transitions in finite automata
 i.e., a transition from one state to another state
without consuming any additional input symbol

 Explicit -transitions between different states
introduce non-determinism.
 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
Professor & HOD
Example of an -NFA
L = {w | w is empty, or if non-empty will end in 01}
0,1
0 1
 -closure of a state q,
q0 q1 q2 ECLOSE(q), is the set

of all states (including
start q’0 itself) that can be
reached from q by
δE 0 1
 repeatedly making an
*q’0 Ø Ø {q’0,q0}
ECLOSE(q’0) arbitrary number of -
q0 {q0,q1} {q0} {q0} ECLOSE(q0) transitions.
ECLOSE(q1)
q1 Ø {q2} {q1}
*q2 Ø Ø {q2} ECLOSE(q2) Professor & HOD
To simulate any transition:
Step 1) Go to all immediate destination states.
Step 2) From there go to all their -closure states as well.
Example of an -NFA
L = {w | w is empty, or if non-empty will end in 01}
0,1
0 1
Simulate for w=101:
q0 q1 q2
 q0’
 
start q’0
q0’ q0
1 1
δE 0 1 Ø q0
 x 0
ECLOSE(q’0)
*q’0 Ø Ø {q’0,q0} q1
q0 {q0,q1} {q0} {q0} ECLOSE(q0) 1
q2
q1 Ø {q2} {q1}
*q2 Ø Ø {q2} Professor & HOD 30
Equivalency of DFA, NFA, -NFA
 Theorem: A language L is accepted by
some -NFA if and only if L is accepted by
some DFA
 Implication:

DFA ≡ NFA ≡ -NFA
 (all accept Regular Languages)
Professor & HOD
31
Eliminating -transitions
Let E = {QE,∑,δE,q0,FE} be an -NFA
Goal: To build DFA D={QD,∑,δD,{qD},FD} s.t. L(D)=L(E)
Construction:
1. QD= all reachable subsets of QE factoring in -closures
2. qD = ECLOSE(q0)
3. FD=subsets S in QD s.t. S∩FE≠Φ
4. δD: for each subset S of QE and for each input symbol a∑:

Let R= U δE(p,a) // go to destination states
p in s

δD(S,a) = U ECLOSE(r) // from there, take a union
r in R of all their -closures
Professor & HOD
Example: -NFA  DFA
Adobe Acrobat
Document
Professor & HOD
33
Minimization of DFA
Adobe Acrobat
Document
Professor & HOD
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. Moore machine can be described by 6 tuples
(Q, q0, ∑, O, δ, λ) where,
 Q: finite set of states
 q0: initial state of machine
 ∑: finite set of input symbols
 O: output alphabet
 δ: transition function where Q × ∑ → Q

λ: output function where Q → O
Professor & HOD

Moore Machine Example
Adobe Acrobat
Document
Professor & HOD
36
Mealy Machine
 A Mealy machine is a machine in which output symbol

depends upon the present input symbol and present state of
the machine. In the Mealy machine, the output is
represented with each input symbol for each state separated
by /. The Mealy machine can be described by 6 tuples
(Q, q0, ∑, O, δ, λ') where

Q: finite set of states
q0: initial state of machine
∑: finite set of input alphabet
O: output alphabet
δ: transition function where Q × ∑ → Q
λ': output function where Q × ∑ →O
Professor & HOD
Mealy Machine Examples
Adobe Acrobat
Document
Professor & HOD
Conversion from Mealy machine to Moore Machine
 In Moore machine, the output is associated with

every state, and in Mealy machine, the output is
given along the edge with input symbol. To convert
Moore machine to Mealy machine, state output
symbols are distributed to input symbol paths. But
while converting the Mealy machine to Moore
machine, we will create a separate state for every
new output symbol and according to incoming and
outgoing edges are distributed.
Professor & HOD
39
steps converting Mealy machine to the Moore machine:
The following steps are used for

converting Mealy machine to the
Moore machine:
 Step 1: For each state(Qi), calculate the number of different
outputs that are available in the transition table of the Mealy
machine.
 Step 2: Copy state Qi, if all the outputs of Qi are the same.
Break qi into n states as Qin, if it has n distinct outputs where n
= 0, 1, 2....
 Step 3: If the output of initial state is 0, insert a new initial state
at the starting which gives 1 output
Professor & HOD
Conversion from Mealy machine to Moore Machine
Example’s
Adobe Acrobat
Document
Professor & HOD
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.
Professor & HOD
42
Method for conversion of 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))
Professor & HOD
Moore machine to Mealy Machine Example’s
Adobe Acrobat
Document
Professor & HOD
44
Summary
Professor & HOD
 DFA
 Definition
 Transition diagrams & tables
 NFA
 Definition
 Transition diagrams & tables
 DFA vs. NFA

 NFA to DFA conversion using subset construction
 Equivalency of DFA & NFA
 Removal of redundant states and including dead states
 -transitions in NFA
 Moore Machine,Mealy machine
 Convert Mealy machine to Moore Machine
 Convert Moore Machine to Mealy machine 45

3-FiniteAutomata Anim

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

3-FiniteAutomata Anim

Uploaded by

Copyright:

Available Formats

(Unit-1 part-B)

 Deterministic Finite Automata: Definition of DFA, How A DFA

 Deterministic Finite Automata (DFA)

DFA for strings containing 01

• What makes this DFA deterministic? • Q = {q0,q1,q2}

NFA for strings containing 01

Why is this non-deterministic?

0,1 0,1 •  = {0,1}

an input of 0 is received? q1 Φ {q2}

Ex: δ(q0q1,a)= δ(q0,a) U δ(q1,a)

What is an “error state”?

Any other input symbol

 An NFA for the same purpose:

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

Differences: DFA vs. NFA

without consuming any additional input symbol

Definition:  -NFAs are those NFAs with at least one

Moore machine is a finite state machine in which the next state is

Moore Machine Example

 A Mealy machine is a machine in which output symbol

(Q, q0, ∑, O, δ, λ') where

 In Moore machine, the output is associated with

The following steps are used for

 In the Moore machine, the output is associated with every

Method for conversion of Moore

machine. The equivalent Mealy

 Transition diagrams & tables

 Transition diagrams & tables

 DFA vs. NFA

You might also like