MODULE 1

FINITE AUTOMATA

1. The Central Concepts of Automata Theory

Symbol: Symbol is an entity or user defined entity. It can be a single digit, a single
alphabet, or a single symbol.

Ex: 1, a, b, #

Alphabet: Alphabet is a finite set of symbols. It is denoted by ∑.

Ex: ∑ = {a, b}

∑ = {0, 1, 2, +}

∑ = {#, β, Δ}

String: It is a finite sequence of symbols over an alphabet ∑. The string is denoted by w.

Ex: Let ∑ = {#, β, Δ} ,

the valid set of strings w1 = # , w2 = β , w3 = Δ

w4 = #β , w5 = #Δ , w6 = βΔ,

w7 = #βΔ, w8 = ### etc

Length of string: number of symbols in the string. It is represented as |w|.

Ex: if string w = # , then |w| = 1

Ex: if string w = #βΔ , then |w| = 3

Empty String: A string with zero symbols. It is represented as ε or Ʌ.

Ex: if string w = ε , then |w| = 0

Prefix of a String: It is any number of leading symbols of the string.

Ex: if string w = #βΔ, then

prefixes are ε , # , #β , #βΔ

proper prefixes are ε , # , #β

Suffix of a String: It is any number of trailing symbols of the string.

Ex: if string w = #βΔ, then

suffixes are #βΔ , βΔ , Δ , ε

proper suffixes are βΔ , Δ , ε

Concatenation of Strings: If w1 and w2 are any two strings, then their concatenation is
represented as “w1.w2”. Concatenation is represented with “.”

Ex: if w1 = #β, w2 = Δ, then w1.w2 = #β Δ

Language: Let the finite automata M be defined over the alphabet ∑. The formal language
of M is a set comprising of valid strings over the alphabet ∑. It is represented as L.

Ex: Let M be the finite automata with all strings over ∑ = {#, β, Δ}

then L = { ε , #, β , Δ , #β, #Δ, βΔ, #βΔ, ### . . . . .}

Ex: Let M be the finite automata with all strings of length two over ∑ = {#, β, Δ}

then L = { #β, #Δ, βΔ }

Grammar: An "automata grammar" typically refers to a formal grammar used to define

the language accepted by an automaton. This grammar is a set of rules that specifies the
structure of valid strings or sequences of symbols that the automaton can recognize or
generate.

Operations on Languages:

a) Union – Let L1 and L2 be two languages. Then their union is a language comprising
of all strings from both L1 and L2. It represented as L1 U L2.

Ex: Let L1 = { #β , #Δ } , L2 = { Δ , #βΔ }

L1 U L2 = { #β , #Δ , Δ , #βΔ }

b) Concatenation – Let L1 and L2 be two languages. Then their concatenation is a

language comprising of all strings from L1 concatenated with L2. It represented as
L1.L2 = { X.Y | X ϵ L1 , Y ϵ L2 }
Ex: Let L1 = { #β , #Δ } , L2 = { Δ , #βΔ }

L1.L2 = { #βΔ , #β#βΔ , #ΔΔ , #Δ#βΔ }

c) Closure Operations

i) Kleene Closure (∑*) – Set of all possible combination of strings including ε

Ex: Let ∑ = {# , β , Δ}

then ∑* = { ε , # , β , Δ , #β , #Δ , βΔ , #βΔ , ### . . . . .}

ii) Positive Closure (∑+) – Set of all possible combination of strings excluding ε
Ex: Let ∑ = {#, β, Δ}

then ∑+ = { #, β , Δ , #β , #Δ , βΔ , #βΔ , ### . . . . .}

2. Problems on Automata Languages

Problem 1: Determine the language over ∑ = {#, β, Δ} comprising of all strings that
contain at least one Δ.

Answer : L = { Δ , #Δ , βΔ , ##Δ , #Δ# , Δ## , ΔΔ# , Δ#Δ , ΔΔΔ , #βΔ , #Δβ ,

. . . . . }

Problem 2: Determine the language over ∑ = {#, β, Δ} comprising of all strings in which
the 2nd symbol is Δ.

Answer : L = { #Δ , βΔ , ΔΔ , #Δ# , ΔΔ# , ΔΔΔ , #Δβ , . . . . . }

3. Introduction to Automata
An automaton is a “system where energy, materials and information are transformed,
transmitted and used for performing some functions without direct participation of man”.
Automaton is a discrete machine. Figure 1.1 shows the model of discrete automaton.

Figure 1.1 Model of Discrete Automaton

The characteristics of discrete automaton are:

(i) Input – At each of the discrete instants of time t1, t2, . . . tm , the input values I1 , I2
. . . . Ip are applied as input to model. Each input symbol takes a value from the input
alphabet ∑.

iii) Output – O1 , O2 , . . . . Oq are the outputs of the model; each output symbol takes
a value from the output alphabet O.

(iii) States – At any instant of time the automaton can be in one of the states q1, q2 , . .
. , qn.

(iv) State relation – At any instant of time, the next state of the automaton is determined
by the present state and the present input.

(v) Output relation – The output is related to either state only or to both the input and
the state. It should be noted that at any instant of time the automaton is in some state.
On ‘reading’ an input symbol, the automaton moves to a next state which is given by the
state relation.

4. Introduction to Finite Automata

FA is a mathematical model of a system with discrete input and output. Finite automata
(FA), often referred to as Finite State Machines (FSMs), represent a fundamental concept
in theoretical computer science and are essential in understanding computation and formal
language theory. They serve as abstract mathematical models of computation with a finite
set of states and a well-defined set of transitions between these states based on input
symbols.

FA serve as fundamental models of computation with a finite set of states and transitions
between these states based on input symbols. These models help computer scientists and
researchers understand the nature of computation, formal languages, and the
fundamental limits of what can be efficiently computed within the realm of regular
languages.
FA finds applications in various domains of computer science, including:

a) Lexical analysis in compilers: They are used to recognize and tokenize strings
based on specific patterns or regular expressions.

b) Modeling and understanding regular languages and their properties.

c) Pattern matching:

✓ Automata aid in searching for patterns within text or sequences

efficiently

✓ for scanning large bodies of text, such as web pages to find

occurrence of words or other pattens

d) Network protocols:

✓ Finite automata are employed in protocol specifications and network

traffic analysis.

✓ for verifying systems of all types that have a finite number of distinct
states such as communication protocols

e) Software: for designed and checking behavior of digital circuit;

f) Hardware: to implement switches

At its core, a finite automaton consists of:

a) States: These are distinct configurations or conditions in which the automaton can
exist at any given point during its operation.

b) Transitions: These depict the movement between states based on input symbols.
Transitions are governed by a set of rules or a transition function.

c) Accepting States (optional): In certain types of finite automata, there might be

specific states that are designated as accepting or final states, indicating successful
recognition of an input string.

Figure 1.2 Block diagram of the Finite Automaton

A FA operates by transitioning between different states in response to the input symbols
it reads. It follows a set of rules defined by its structure and transition function. Figure 1.2
shows the block diagram of the finite automaton.

Finite Automata can recognize and accept strings that belong to the languages they are
designed for (e.g., regular languages for DFAs and NFAs). The step-by-step explanation of
how a Finite Automaton operates:

a) States: The FA starts in a designated initial state from a set of finite states. Each
state represents a particular configuration or condition of the automaton at a given
moment.

b) Transition Function: The FA has a transition function that defines the rules for
transitioning between states based on the input symbols it receives. This function
specifies the next state the FA moves to when it reads a particular input symbol
while being in a certain state. The transition function can be represented in the
form of a transition table or a transition diagram or a transition relation.

c) Reading Input: As the FA processes an input string symbol by symbol, it

transitions between states according to the transition function. For each symbol it
reads from the input, the automaton moves from its current state to a new state
as determined by the transition function.

d) Acceptance (for DFAs): In the case of a Deterministic Finite Automaton (DFA), if

the input string is completely processed and the automaton ends up in one of its
designated accepting (or final) states, the input string is accepted by the
automaton. Otherwise, if the automaton ends up in a non-accepting state or cannot
transition further, the input string is rejected.

e) Behavior (for NFAs): For a Nondeterministic Finite Automaton (NFA), the process
is similar, but with more flexibility. An NFA might have multiple possible transitions
for a given state and input symbol. It can be in multiple states simultaneously, and
it accepts an input string if there exists at least one path that leads to an accepting
state.

f) Completion of Input: Once the entire input string is processed, the FA halts, and
its final state or states determine whether the input string is accepted or rejected
based on the language it recognizes.

5. Types of Finite Automata

Finite automata are classified into two main types:

a) Deterministic Finite Automata (DFA): These machines accept or reject strings

of symbols by transitioning between states according to a single, unique transition
for each input symbol. DFAs recognize regular languages and are defined by a
precise set of rules for each state and input symbol combination.

b) Nondeterministic Finite Automata (NFA): Unlike DFAs, NFAs can have multiple
possible transitions for a given state and input symbol. They are more flexible in
their behavior, allowing transitions to multiple states simultaneously or the option
to "guess" the correct path. NFAs recognize the same class of languages as DFAs,
but their design and operation are more versatile.
6. Mathematical Model of DFA
A DFA can be represented mathematically as a 5-tuple:

M = ( Q , ∑ , δ , q0 , F )

Where Q: finite nonempty set of states

∑: finite nonempty set of the input symbols called input alphabet

q0: initial state q0 ϵ Q

F: set of final states F ⊆ Q

δ: Transition function QX∑→Q

Every transition in a DFA has only one possible next state.

Example DFA: Let the DFA be M = ( Q , ∑ , δ , q4 , F )

where Q = { q4 , q7 } , ∑ = { +, X } , q4 is initiate state , F = {q4}

δ is defined as

Transition Relation Transition Table

δ ( q4 , + ) = q7 Next State
Present
State/∑ + X
δ ( q4 , X ) = q4

δ ( q7 , + ) = q4 ➔ q4 q7 q4

δ ( q7 , X ) = q7 q7 q4 q7

Transition Diagram

7. Mathematical Model of NFA

A NFA can be represented mathematically as a 5-tuple:

M = ( Q , ∑ , δ , q0 , F )

Where Q: finite nonempty set of states

∑: finite nonempty set of the input symbols called input alphabet

q0: initial state q0 ϵ Q

F: set of final states F ⊆ Q

δ: Transition function Q X ∑ → 2Q

A transition in an NFA can have more than one possible next state.
Example NFA: Let the NFA be M = ( Q , ∑ , δ , q4 , F )

where Q = { q4 , q7 } , ∑ = { +, X } , q4 is initiate state , F = {q4}

δ is defined as

Transition Relation Transition Table

δ ( q4 , + ) = q7 Next State
Present
State/∑ + X
δ ( q4 , X ) = q4

δ ( q7 , + ) = q4 ➔ q4 q7 q4

δ ( q7 , X ) = q4 , q7 q7 q4 q4 , q7

Transition Diagram

8. Acceptability of Strings
Let the DFA be M = ( Q , ∑ , δ , q0 , F ). A string X is said to be accepted by M if δ (q0, X)
= q where q ϵ F.

A string is said to be accepted by NFA if there exists at least one completed path that ends
with a final state. Let the MFA be M = ( Q , ∑ , δ , q0 , F). A string X is said to be accepted
by M if δ (q0, X) contains some final state.

Example Problem 1: For the following DFA, determine the acceptability of the string
XX+X.

Answer: Let the given DFA be M = M = ( Q , ∑ , δ , q4 , F ) where Q = { q4 , q7 } ,

∑ = { + , X } , q4 is initiate state , F = { q4 }
δ is defined as

Transition Relation Transition Table

δ ( q4 , + ) = q7 Next State
Present
State/∑ + X
δ ( q4 , X ) = q4

δ ( q7 , + ) = q4 ➔ q4 q7 q4

δ ( q7 , X ) = q7 q7 q4 q7

Transition Diagram

Acceptability of the string “XX+X”

δ ( q4 , X X + X ) = δ ( q4 , X + X ) = δ ( q4 , + X ) = δ ( q7 , X ) = q7

As q7 is not a final state, string “XX+X” is not accepted by the given FA.

Example Problem 2: For the following NFA, determine the acceptability of the string
XX+X.

Answer: Let the given NFA be M = ( Q , ∑ , δ , q4 , F ) where Q = { q4 , q7 } ,

∑ = { + , X } , q4 is initiate state , F = { q4 }

δ is defined as

Transition Relation Transition Table

δ ( q4 , + ) = q7 Next State
Present
State/∑ + X
δ ( q4 , X ) = q4

δ ( q7 , + ) = q4 ➔ q4 q7 q4

δ ( q7 , X ) = q4 , q7 q7 q4 q4 , q7

Transition Diagram

Acceptability of the string “XX+X”

δ ( q4 , X X + X ) = δ ( q4 , X + X ) = δ ( q4 , + X ) = δ ( q7 , X ) = q4

As q4 is a final state, string “XX+X” is accepted by the given FA.

9. Problems on Design of FA
Problem 1: Design a DFA that recognizes the language over { v , p } containing strings
that start with 'v' and have an odd length.

Answer: Let the FA that recognizes the language over { v , p } containing strings that start
with 'v' and have an odd length be

M = ( Q , ∑ , δ , q0 , F ) where Q = { q4 , q5 , q6 } ,

∑ = { v , p } , q4 is initiate state , F = { q5 }

δ is defined as

Transition Relation Transition Table

δ ( q4 , v ) = q5 Next State
Present
State/∑ v p
δ ( q5 , v ) = q6

δ ( q5 , p ) = q6 ➔ q4 q5

δ ( q6 , v ) = q5 q5 q6 q6
4
δ ( q6 , p ) = q5 q6 q5 q5

Transition Diagram

Acceptability of the string “v p v p p ”

δ ( q4 , v p v p p ) = δ ( q5 , p v p p ) = δ ( q6 , v p p ) = δ ( q5 , p p ) = δ ( q6 , p ) = q5

As q5 is a final state, string “v p v p p ” is accepted by the given FA.

10. Equivalence of NFA and DFA

Note: δ’ ( [q0 , q1 , . . . . , qn ] , a ) = δ ( q0 , a ) U δ ( q1 , a ) U . . . . U δ ( qn , a )

Example Problem: Convert the following NFA to equivalent DFA.

Answer: Let the given NFA be M = ( Q , ∑ , δ , q3 , F ) where Q = { q3 , q5 } ,

∑ = { + , X } , q3 is initiate state , F = { q3 }

δ is defined as

Transition Relation Transition Table

δ ( q3 , + ) = q5 Next State
Present
State/∑ + X
δ ( q3 , X ) = q3

δ ( q5 , + ) = q3 ➔ q3 q5 q3

δ ( q5 , X ) = q3 , q5 q5 q3 q3 , q5

Transition Diagram

Let the equivalent DFA be M’ = ( Q’ , ∑ , δ’ , q3 , F’ )

where Q’ = { [q3] , [q5] , [q3 , q5] } , ∑ = { + , X } , [q3] is initiate state ,

F’ = { [q3] , [q3 , q5] }

δ’ is defined as

Transition Relation Transition Table

δ’ ( q3 , + ) = [q5] Present Next State

State/∑ + X
δ’ ( q3 , X ) = [q3]
➔ [q3] [q5] [q3]
δ’ ( q5 , + ) = [q3] [q5] [q3] [q3 , q5]

δ’ ( q5 , X ) = [q3 , q5] [q3,q5] [q3 , q5] [q3 , q5]

δ’ ( [q3 , q5] , + ) = [q3 , q5]

δ’ ( [q3 , q5] , X ) = [q3 , q5]

Transition Diagram

11. NFA with ε-transitions (NFA-ε)

It is an NFA including transitions on the empty input symbol ε.

An NFA-ε can be represented mathematically as a 5-tuple:

M = ( Q , ∑ , δ , q0 , F )

Where Q: finite nonempty set of states

∑: finite nonempty set of the input symbols called input alphabet

q0: initial state q0 ϵ Q

F: set of final states F ⊆ Q

δ: Transition function QX{∑x ε } → 2Q

Example NFA-ε: Let the NFA-ε be M = ( Q , ∑ , δ , q4 , F )

where Q = { q4 , q7 } , ∑ = { + , X } , q4 is initiate state , F = { q4 }

δ is defined as

Transition Relation Transition Table

δ ( q4 , ε ) = q7 Present Next State

State/∑
δ ( q4 , X ) = q4
+ X ε
➔ q4 q4 q7
δ ( q7 , + ) = q4
q7 q4 q7
δ ( q7 , X ) = q7

Transition Diagram
12. Conversion of NFA-ε to NFA

Note: ε-closure(q) = set of all states p such that there is a path from q to p with label ε.

ε-closure(q) includes “q” itself.

𝛿̂ (𝑞 , ε) = ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝑞)

𝛿̂ (𝑞 , a) = ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿(𝛿̂ (𝑞 , ε ), 𝑎))

Example Problem: Convert the following NFA-ε to equivalent NFA without ε-transitions.

Answer: Let the NFA-ε be M = ( Q , ∑ , δ , q4 , F )

where Q = { q4 , q7 } , ∑ = { + , X } , q4 is initiate state , F = { q4 }

δ is defined as

Transition Relation Transition Table

δ ( q4 , ε ) = q7 Present Next State

State/∑
δ ( q4 , X ) = q4
+ X ε
➔ q4 q4 q7
δ ( q7 , + ) = q4
q7 q4 q7
δ ( q7 , X ) = q7

Transition Diagram

Step 1: Find ε-closure(q) for all states q ϵ Q

ε-closure(q4) = 𝛿̂ (𝑞4 , ε) = { q4 , q7 }

ε-closure(q7) = 𝛿̂ (𝑞7 , ε) = { q7 }

Step 2: Find the mapping function 𝛿̂ (𝑞) for all states q ϵQ

𝛿̂ (𝑞4 , +) = ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒 (𝛿(𝛿̂ (𝑞4, ε), +))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿(ε − closure(𝑞4), +))

 = ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿({𝑞4 , 𝑞7}, +))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿(𝑞4, +) ∪ 𝛿(𝑞7, +))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒( { ∅ } ∪ { 𝑞4 })

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒( { 𝑞4 })

= { 𝑞4 , 𝑞7 }

𝛿̂ (𝑞4 , 𝑋) = ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒 (𝛿(𝛿̂ (𝑞4, ε), 𝑋))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿(ε − closure(𝑞4), 𝑋))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿({𝑞4 , 𝑞7}, 𝑋))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿(𝑞4, 𝑋) ∪ 𝛿(𝑞7, 𝑋))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒( { 𝑞4 } ∪ { 𝑞7 })

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒( { 𝑞4 , 𝑞7 })

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒( 𝑞4) ∪ ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒( 𝑞7)

= { 𝑞4 , 𝑞7 } ∪ { 𝑞7 }

= { 𝑞4 , 𝑞7 }

𝛿̂ (𝑞7 , +) = ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒 (𝛿(𝛿̂ (𝑞7, ε), +))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿(ε − closure(𝑞7), +))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿({𝑞7} , +))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒( { 𝑞4 })

= { 𝑞4 , 𝑞7 }

𝛿̂ (𝑞7 , 𝑋) = ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒 (𝛿(𝛿̂ (𝑞7, ε), 𝑋))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿(ε − closure(𝑞7), 𝑋))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒(𝛿({𝑞7} , 𝑋))

= ε − 𝑐𝑙𝑜𝑠𝑢𝑟𝑒( { 𝑞7 })

= { 𝑞7 }

Let the NFA without ε-transitions be M’ = ( Q , ∑ , δ’ , q4 , F’ )

where Q = { q4 , q7 } , ∑ = { + , X } , q4 is initiate state ,

F’ = F U { q , if ε-closure(q) ϵ F } = { q4 } U { Φ } = { q4 }

δ’ is defined as

Transition Relation Transition Table

𝛿̂ (𝑞4 , +) = = { 𝑞4 , 𝑞7 } Present Next State

State/∑ + X
𝛿̂ (𝑞4 , 𝑋) = = { 𝑞4 , 𝑞7 }
➔ q4 q4, q7 q4, q7
𝛿̂ (𝑞7 , +) = = { 𝑞4 , 𝑞7 }
q7 q4, q7 q7
𝛿̂ (𝑞7 , 𝑋) = = { 𝑞7 }

Transition Diagram

13. FA with Output

Finite Automata with outputs are extensions of traditional Finite Automata (FA) where
transitions not only depend on the current state and input symbol but also produce outputs
during state transitions. These outputs could be associated with transitions or states
themselves. FA with output is of two types - Mealy and Moore machines.

a) Moore Machine: The output is associated with each state rather than with
transitions. Upon entering a state, the machine produces an output determined by
that state.

b) Mealy Machine: Outputs are associated with transitions, meaning the output
depends on both the current state and the input symbol. Outputs are produced
when a transition occurs from one state to another due to an input symbol.

Moore Machine:

In Moore machine, output function Z(t) depends only on the present state q(t) and is
independent of the current input. "t” is a discrete instant of time.

Z(t) = λ (q(t) )

A Moore machine is represented mathematically using a 6-tuple:

M = ( Q , ∑ , Δ , δ , λ , q0 )

Where Q: finite nonempty set of states

∑: finite nonempty set of the input symbols called input alphabet

Δ: finite nonempty set of the output symbols called output alphabet

q0: initial state q0 ϵ Q

δ: Transition function QX ∑ →Q
 λ: output function Q → Δ

For a Moore machine if the input string is of length “n”, the output string is of length “n+1”.

Example Moore Machine:

Let the Moore Machine be M = ( Q , ∑ , Δ , δ , λ , q4 )

where Q = { q4 , q7 } , ∑ = { + , X } , Δ = { P , M } , q4 is initiate state

δ is defined as

Transition Relation Transition Table

δ ( q4 , + ) = q7 Next State δ
Present Output
State/∑ + X λ
δ ( q4 , X ) = q4

δ ( q7 , + ) = q4 ➔ q4 q7 q4 P

δ ( q7 , X ) = q7 q7 q4 q7 M

Transition Diagram

Output Function λ

λ ( q4 ) = P

λ ( q7 ) = M

Problem: For the above Moore Machine, determine the output for the input string “XX+X”.

δ ( q4 , X X + X ) = δ ( q4 , X + X ) = δ ( q4 , + X ) = δ ( q7 , X ) = q7

λ ( q4 ) -------→ λ ( q4 ) -------→ λ ( q4 ) -------→ λ ( q7 ) --→ λ ( q7 )

Output P P P M M

Output for the given input string “XX+X” is “PPPMM”

Mealy Machine:

In Mealy machine, output function Z(t) depends on the present state q(t) and the current
input x(t).

Z(t) = λ ( q(t) , x(t) )

A Mealy machine is represented mathematically using a 6-tuple:

M = ( Q , ∑ , Δ , δ , λ , q0 )

Where Q: finite nonempty set of states

 ∑: finite nonempty set of the input symbols called input alphabet

Δ: finite nonempty set of the output symbols called output alphabet

q0: initial state q0 ϵ Q

δ: Transition function QX ∑ →Q

λ: output function Q X ∑ → Δ

For a Mealy machine if the input string is of length “n”, the output string is of length “n”.

Example Mealy Machine:

Let the Mealy Machine be M = ( Q , ∑ , Δ , δ , λ , q4 )

where Q = { q4 , q7 } , ∑ = { + , X } , Δ = { P , M } , q4 is initiate state

δ is defined as

Transition Relation Transition Table

δ ( q4 , + ) = q7 + X
Present
State/∑ Next Output Next Output
δ ( q4 , X ) = q4
State δ λ State δ λ
δ ( q7 , + ) = q4 ➔ q4 q7 M q4 P
δ ( q7 , X ) = q7 q7 q4 P q7 M

Transition Diagram

Output Function λ

λ ( q4 , + ) = M

λ ( q4 , X ) = P

λ ( q7 , + ) = P

λ ( q7 , X ) = M

Problem: For the above Mealy Machine, determine the output for the input string “XX+X”.

δ ( q4 , X X + X ) = δ ( q4 , X + X ) = δ ( q4 , + X ) = δ ( q7 , X ) = q7

λ ( q4 , X ) ---→ λ ( q4 , X ) ---→ λ ( q4 , + ) --→ λ ( q7 , X )

Output P P M M

Output for the given input string “XX+X” is “PPMM”

14. Converting Moore Machine to Mealy Machine
Problem: Convert the following Moore Machine to Mealy Machine.

Answer:

Let the given Moore Machine be M = ( Q , ∑ , Δ , δ , λ , q4 )

where Q = { q4 , q7 } , ∑ = { + , X } , Δ = { P , M } , q4 is initiate state

δ is defined as

Transition Relation Transition Table

δ ( q4 , + ) = q7 Next State δ
Present Output
State/∑ + X λ
δ ( q4 , X ) = q4

δ ( q7 , + ) = q4 ➔ q4 q7 q4 P

δ ( q7 , X ) = q7 q7 q4 q7 M

Transition Diagram

Output Function λ

λ ( q4 ) = P

λ ( q7 ) = M

Let the equivalent Mealy Machine be M’ = ( Q , ∑ , Δ , δ , λ’ , q4 )

where Q = { q4 , q7 } , ∑ = { + , X } , Δ = { P , M } , q4 is initiate state

δ is defined as

Transition Relation Transition Table

δ ( q4 , + ) = q7
+ X
Present
δ ( q4 , X ) = q4 State/∑ Next Output Next Output
State δ λ State δ λ
δ ( q7 , + ) = q4
➔ q4 q7 M q4 P
δ ( q7 , X ) = q7
q7 q4 P q7 M

Transition Diagram

= λ ( q4 ) = λ ( q7 )

Output Function λ’

λ ( q4 , + ) = M

λ ( q4 , X ) = P

λ ( q7 , + ) = P

λ ( q7 , X ) = M

15. Converting Mealy Machine to Moore Machine

Problem: Convert the following Mealy Machine to Moore Machine.

Answer:

Let the given Mealy Machine be M = ( Q , ∑ , Δ , δ , λ , q4 )

where Q = { q4 , q7 } , ∑ = { + , X } , Δ = { P , M } , q4 is initiate state

δ is defined as

Transition Relation Transition Table

δ ( q4 , + ) = q7
+ X
Present
δ ( q4 , X ) = q4 State/∑ Next Output Next Output
State δ λ State δ λ
δ ( q7 , + ) = q4
➔ q4 q7 M q4 M
δ ( q7 , X ) = q7
q7 q4 P q7 M

Transition Diagram

Output Function λ

λ ( q4 , + ) = M

λ ( q4 , X ) = M

λ ( q7 , + ) = P

λ ( q7 , X ) = M

Let the equivalent Moore Machine be M’ = ( Q’ , ∑ , Δ , δ’ , λ’ , q4’ )

δ’ is defined as

Transition Table
+ X
Present
State/∑ Next Output Next Output
State δ λ State δ λ
➔ q4M q7 M q4M M

q4P q7 M q4M M

q7 q4P P q7 M

+ X
Present
State/∑ Next Output Next Output
State δ λ State δ λ

➔ q4’ q7 M q4M M

q4M q7 M q4M M

q4P q7 M q4M M

q7 q4P P q7 M
 Present Next State δ Output
State/∑ + X λ

➔ q4’ q7 q4M ε
q4M q7 q4M M

q4P q7 q4M P

q7 q4P q7 M

Transition Relation Transition Diagram

δ ( q4’ , + ) = q7

δ ( q4’ , X ) = q4M

δ ( q4M , + ) = q7

δ ( q4M , X ) = q4M

δ ( q4P , + ) = q7

δ ( q4P , X ) = q4M

δ ( q7 , + ) = q4P

δ ( q7 , X ) = q7

where Q = { q4’ , q4M , q4P, q7 } , ∑ = { + , X } , Δ = { P , M } , q4’ is initiate state

Output Function λ’

λ ( q4’ ) = ε
λ ( q4M ) = M

λ ( q4P ) = P

λ ( q7 ) = M