Finite Automata with Output

 Moore Machines
 Mealy Machines
 Moore = Mealy

Theory of Automata 2
Benefits

◼ What is we want to do following to the word

❑ count the occurrence of a certain substring
❑ get the incremented number
❑ mark the locations of the substring in the word
❑ take the complement of the number
❑ Get the parity of the number

◼ Final accepted/rejected may not be required

◼ Not limited by the size of the buffer if we want to wait for the final
output

Sept 30, 2013 Mehreen Alam - Theory of Automata 3

Theory of Automata 3
Theory of Automata 4
Theory of Automata 5
Theory of Automata 6
Moore machine is a collection of five things:
1. A finite set of states q0, q1, q2, ..., where q0 is designated
as the start state.
2. An alphabet of letters for forming the input string = {a,
b, c, …}.
3. An alphabet of possible output characters Γ = {0, 1, 2,
…}.
4. A transition table that shows for each state and each
input letter what state is reached next.
5. An output table that shows what character from Γ is
printed by each state as it is entered.

Theory of Automata 7
 We did not assume that the input alphabet is the same as
the output alphabet Γ.

 To keep the output alphabet separate from the input

alphabet, we give it a different name Γ (instead of ∑) and
use number symbols {0, 1, …} (instead of {a, b, …}).

 We refer to input symbols as letters, whereas we refer to

output symbols as characters.

 We adopt the policy that a Moore machine always begins

by printing the character dictated by the mandatory start
state. So, if the input string has 7 letters, then the output
string will have 8 characters, because it includes 8 states
in its path.

Theory of Automata 8
 A Moore machine does not define a language of
accepted words, because there is no such thing as a
final state.

 Every possible input string creates an output string. The

processing is terminated when the last input letter is
read and the last output character is printed.

 There are some subtle ways to turn Moore machines

into language definers.

Theory of Automata 9
 Input alphabet: ∑ = {a, b}
 Output alphabet: Γ = {0, 1}
 Names of states: q0, q1, q2, q3 with q0 being the start
state.
 Transition and output table (combined):
Old State Output by New state New state
Old State after a after b
q0 1 q1 q3
q1 0 q3 q1
q2 0 q0 q3
q3 1 q1 q2
Theory of Automata 10
Old State Output by New state New state
Old State after a after b
q0 1 q1 q3
q1 0 q3 q1
q2 0 q0 q3
q3 1 q1 q2
Theory of Automata 11
 Moore machines have pictorial representations similar
to FAs.

 The difference is that inside each state, in addition to

the state name, we also specify the output character
printed by that state, using the format state –
name/output.

 Hence, the Moore machine in the above example has

the following pictorial representation:

Theory of Automata 12
 We indicate the start state by an outside arrow since there is no
room for the usual - sign.

 Given the input string abab, the output sequence is 10010.

 Note that the length of the output string is one longer than the
length of the input string.

Theory of Automata 13
 Suppose we are interested in knowing exactly how many
times the substring aab occurs in a long input string.
The following Moore machine will count this for us:

 Every state of this machine prints out a 0, except for q3,

which prints a 1.

Theory of Automata 14
Input a a a b a b b a a b b
State q0 q1 q2 q2 q3 q1 q0 q0 q1 q2 q3 q0
Output 0 0 0 0 1 0 0 0 0 0 1 0
Every state of this machine prints out a 0, except for q3, which prints a 1.

Printing 1  final state words that end in

aab
Theory of Automata 15
 To get to q3, we must have come from q2 and have just
read a b. To get to q2, we must have read at least two a’s
in a row.

 After finding the subtring aab and tallying a 1 for it, the
machine looks for the next aab. Hence, the number of 1’s
in the output string is exactly the number of substrings
aab in the input string.

 Consider an FA that accepts a language L:

– If we add printing character 0 to any non-final state and 1 to
each final state, then the 1’s in any output string mark the end
position of all substrings that are words in L.
– In a similar way, a Moore machine can be said to define the
language of all input strings whose output ends with a 1.
– The Moore machine above with q0 = - and q3 = + accepts all
words that end with aab.

Theory of Automata 16
A Mealy machine is a collection of four things:
1. A finite set of states q0, q1, q2, ..., where q0 is designated as the
start state.

2. An alphabet of letters for forming the input string ∑ = {a, b, …}.

3. An alphabet of possible output characters Γ = {0, 1, …}.

4. A pictorial representation with states represented by small

circles and directed edges indicating transition between states.

◦ Each edge is labeled with a compound symbol of the form i/o where i
is an input letter and o is an output character.

◦ Every state must have exactly one outgoing edge for each possible
input letter.

◦ The edge we travel is determined by the input letter i. While traveling

on the edge, we must print the output character o.
Theory of Automata 17
 Given the input string aaabb, the output is
01110.
 In a Mealy machine the output string has the
same number of characters as the input string
has letters.

Theory of Automata 18
 A Mealy machine does not define a language by
accepting and rejecting input strings: It has no
final states.
 However, there is a sense in which a Mealy
machine can recognize a language, as we will
see later.
 Note the following notation simplification:

Theory of Automata 19
 The following Mealy machine prints out the 1’s
complement of an input bit string.
 This means that it will produce a bit string that
has a 1 whenever the input string has a 0, and
a 0 whenever the input has a 1.

 If the input string is 001010, the output will be

110101
Theory of Automata 20
 Let consider a Mealy machine, called increment
machine, which reads a binary number and prints out
the binary number that is one larger.

 Assume that the input bit string is a binary number fed

in backward; that is, unit digit first, then 2’s digit, 4’s
digit, etc.

 The output string will be the binary number that is one

greater and that is generated right to left.

 The machine will have 3 states: start, owe-carry and

no-carry. The owe-carry state represents the overflow
when two bits of 1’s are added, we print a 0 and we
carry a 1.

Theory of Automata 21
 From the start state, if we read a 0, we print a 1
(incrementing process), and we go to the no-carry state.
If we read a 1, we print a 0 (incrementing) and we go to
the owe-carry state.

 At any point in the process, in we are in the no-carry

state, we print the next bit just as we read it and
remains in no-carry.

 However, if we are in the owe-carry state and read a 0,

we print a 1 and go to no-carry. If we are in owe-carry
and read a 1, we print a 0 and we loop back to owe-
carry.

Theory of Automata 22
 Let the input string be 1011 (binary representation of 11).
 The string is fed into the machine as 1101 (backwards).
 The output will be 0011, which when reversed is 1100 and
is the binary representation of 12.
 In Mealy machine, output length = input length. Hence, if
input were 1111, then output would be 0000 (overflow
situation).

Theory of Automata 23
 Although a Mealy machine does not accept or reject an
input string, it can recognize a language by making its
output string answer some question about the input.

 Consider the language of all words that have a double

letter (aa or bb) in them.

 We can build a Mealy machine that can take an input

string of a’s and b’s, and print out an output string of
0’s and 1’s such that if the n-th output character is a 1,
it means that the n-th input letter is the second letter in
a pair of double letters.

 The complete picture of this machine is as follows:

Theory of Automata 24
 If the input string is ababbaab, the output will be
00001010.
 This machine recognizes the occurrences of aa or bb.
 Note that the triple letter word aaa produces the output
011 since the second and third letters are both the back
end of a pair of double a’s.

Theory of Automata 25
 So far, we have define that two machines are equivalent
if they accept the same language.
 In this sense, we cannot compare a Mealy machine and
a Moore machine because they are not language
definers.

Definition:
 Given the Mealy machine Me and the Moore machine Mo
(which prints the automatic start state character x), we
say that these two machines are equivalent if for every
input string, the output string from Mo is exactly x
concatenated with the output string from Me.

Theory of Automata 26
If Mo is a Moore machine, then there is a Mealy machine
Me that is equivalent to Mo.
Proof by constructive algorithm:
 Consider a particular state in Mo, say state q4, which
prints a certain character, say t.

 Consider all the incoming edges to q4. Suppose these

edges are labeled with a, b, c, ...

 Let us re-label these edges as a/t, b/t, c/t, ... and let us
erase the t from inside the state q4. This means that we
shall be printing a t on the incoming edges before we
enter q4.

Theory of Automata 27
 becomes

 We leave the outgoing edges from q4 alone. They will be

relabeled to print the character associated with the state
to which they lead.

 If we repeat this procedure for every state q0, q1, ..., we

turn Mo into its equivalent Me.

Theory of Automata 28
 Following the above algorithm, we convert a Moore
machine into a Mealy machine as follows:

Theory of Automata 29
For every Mealy machine Me, there is a Moore machine
Mo that is equivalent to it.
Proof by constructive algorithm:

 We cannot just do the reverse of the previous algorithm.

If we try to push the printing instruction from the edge
(as it is in Me) to the inside of the state (as it should be
for Mo), we may end up with a conflict: Two edges may
come into the same state but have different printing
instructions, as in this example:

Theory of Automata 30
 What we need are two copies of q4, one that prints a 0
(labeled as q14/0), and the other that prints a 1 (labeled
as q24/1). Hence,

– The edges a/0 and b/0 will go into q14/0.

– The edge b/1 will go into q24/1.

 The arrow coming out of each of these two copies must

be the same as the edges coming out of q4 originally.

Theory of Automata 31
 If all the edges coming into a state have the same
printing instruction, we simply push that printing
instruction into the state.

becomes

Theory of Automata 32
 An edge that was a loop in Me may becomes two edges
in Mo, one that is a loop and one that is not.

becomes

Theory of Automata 33
 If there is ever a state that has no incoming edges, we can
assign it any printing instruction we want, even if this state
is the start state.
 If we have to make copies of the start state in Me, we can
let any of the copies be the start state in Mo, because they
all give the identical directions for proceeding to other
states.
 Having a choice of start states means that the conversion
of Me into Mo is NOT unique.
 Repeating this process for each state of Me will produce an
equivalent Mo. The proof is completed.
 Together, Theorems 8 and 9 allow us to say Me = Mo.

Theory of Automata 34
 Convert the following Mealy machine into a
Moore machine:

Theory of Automata 35
 Following the algorithm, we first need two
copies of q0:

Theory of Automata 36
 All the edges coming into state q1 (and also q3) have the
same printing instruction. So, apply the algorithm to q2
and q3:

Theory of Automata 37
 The only job left is to convert state q2. There are 0-
printing edges and 1-printing edges coming into q2. So,
we need two copies of q2. The final Moore machine is:

Theory of Automata 38