1 Introducing Finite Automata

1.1 Problems and Computation

Decision Problems
Decision Problems
Given input, decide yes or no
Examples: Is x an even number? Is x prime? Is there a path from s to t in graph G?
i.e., Compute a boolean function of input
General Computational Problem
In contrast, typically a problem requires computing some non-boolean function, or carrying out an
interactive/reactive computation in a distributed environment
Examples: Find the factors of x. Find the balance in account number x.
In this course, we will study decision problems because aspects of computability are captured
by this special class of problems
What Does a Computation Look Like?
Some code (a.k.a. control): the same for all instances
The input (a.k.a. problem instance): encoded as a string over a nite alphabet
As the program starts executing, some memory (a.k.a. state)
Includes the values of variables (and the program counter)
State evolves throughout the computation
Often, takes more memory for larger problem instances
But some programs do not need larger state for larger instances!
1.2 Finite Automata: Informal Overview
Finite State Computation
Finite state: A xed upper bound on the size of the state, independent of the size of the input
A sequential program with no dynamic allocation using variables that take boolean
values (or values in a nite enumerated data type)
1
If t-bit state, at most 2
t
possible states
Not enough memory to hold the entire input
Streaming input: automaton runs (i.e., changes state) on seeing each bit of input
An Automatic Door
Front
pad
Rear
pad
door
Figure 1: Top view of Door
closed
open
front
neither
rear
both
neither
front
rear
both
Figure 2: State diagram of controller
Input: A stream of events <front>, <rear>, <both>, <neither> . . .
Controller has a single bit of state.
Finite Automata
Details
Automaton
A nite automaton has: Finite set of states, with start/initial and accepting/nal states; Transitions
from one state to another on reading a symbol from the input.
Computation
Start at the initial state; in each step, read the next symbol of the input, take the transition (edge)
labeled by that symbol to a new state.
Acceptance/Rejection: If after reading the input w, the machine is in a nal state then w is
accepted; otherwise w is rejected.
2
q
0
q
1
0 0
1
1
Figure 3: Transition Diagram of automaton
Conventions
The initial state is shown by drawing an incoming arrow into the state, with no source.
Final/accept states are indicated by drawing them with a double circle.
Example: Computation
On input 1001, the computation is
1. Start in state q
0
. Read 1 and goto q
1
.
2. Read 0 and goto q
1
.
3. Read 0 and goto q
1
.
4. Read 1 and goto q
0
. Since q
0
is not a nal state 1001 is rejected.
On input 010, the computation is
1. Start in state q
0
. Read 0 and goto q
0
.
2. Read 1 and goto q
1
.
3. Read 0 and goto q
1
. Since q
1
is a nal state 010 is accepted.
q
0
q
1
0 0
1
1
3
1.3 Applications
Finite Automata in Practice
grep
Thermostats
Coke Machines
Elevators
Train Track Switches
Security Properties
Lexical Analyzers for Parsers
2 Formal Denitions
2.1 Deterministic Finite Automaton
Dening an Automaton
To describe an automaton, we to need to specify
What the alphabet is,
What the states are,
What the initial state is,
What states are accepting/nal, and
What the transition from each state and input symbol is.
Thus, the above 5 things are part of the formal denition.
Deterministic Finite Automata
Formal Denition
Denition 1. A deterministic nite automaton (DFA) is M = (Q, , , q
0
, F), where
Q is the nite set of states
is the nite alphabet
: Q Q Next-state transition function
4
0 1
q
0
q
0
q
1
q
1
q
1
q
0
Figure 5: Transition Table representation
q
0
Q initial state
F Q nal/accepting states
Given a state and a symbol, the next state is determined.
Formal Example of DFA
Example 2.
q
0
q
1
0 0
1
1
Figure 4: Transition Diagram of DFA
Formally the automaton is M = (q
0
, q
1
, 0, 1, , q
0
, q
1
) where
(q
0
, 0) = q
0
(q
0
, 1) = q
1
(q
1
, 0) = q
1
(q
1
, 1) = q
0
Computation
Denition 3. For a DFA M = (Q, , , q
0
, F), string w = w
1
w
2
w
k
, where for each i w
i
,
and states q
1
, q
2
Q, we say q
1
w

M
q
2
if there is a sequence of states r
0
, r
1
, . . . r
k
such that
r
0
= q
1
,
for each i, (r
i
, w
i+1
) = r
i+1
, and
r
k
= q
2
.
Denition 4. For a DFA M = (Q, , , q
0
, F) and string w

, we say M accepts w i q
0
w

M
q
for some q F.
Useful Notation
5
Denition 5. For a DFA M = (Q, , , q
0
, F), let us dene a function

M
: Q

T(Q) such
that

M
(q, w) = q

Q[ q
w

M
q

.
We could say M accepts w i

M
(q
0
, w) F ,= .
Proposition 6. For a DFA M = (Q, , , q
0
, F), and any q Q, and w

, [

M
(q, w)[ = 1.
Acceptance/Recognition
Denition 7. The language accepted or recognized by a DFA M over alphabet is L(M) = w

[ M accepts w. A language L is said to be accepted/recognized by M if L = L(M).

2.2 Examples
Example I
q
0
0, 1
Figure 6: Automaton accepts all strings of 0s and 1s
Example II
q
0
q
1
0 1
1
0
Figure 7: Automaton accepts strings ending in 1
Example III
6
q
0
q
1
0 0
1
1
Figure 8: Automaton accepts strings having an odd number of 1s
Example IV
q
0
q
1
q
2
q
3
1
1
1
1
0 0 0 0
Figure 9: Automaton accepts strings having an odd number of 1s and odd number of 0s
3 Designing DFAs
3.1 General Method
Typical Problem
Problem
Given a language L, design a DFA M that accepts L, i.e., L(M) = L.
Methodology
Imagine yourself in the place of the machine, reading symbols of the input, and trying to
determine if it should be accepted.
Remember at any point you have only seen a part of the input, and you dont know when it
ends.
Figure out what to keep in memory. It cannot be all the symbols seen so far: it must t into
a nite number of bits.
7
3.2 Examples
Strings containing 0
Problem
Design an automaton that accepts all strings over 0, 1 that contain at least one 0.
Solution
What do you need to remember? Whether you have seen a 0 so far or not!
q
noz
q
zer
1
0, 1
0
Figure 10: Automaton accepting strings with at least one 0.
Even length strings
Problem
Design an automaton that accepts all strings over 0, 1 that have an even length.
Solution
What do you need to remember? Whether you have seen an odd or an even number of symbols.
q
e
q
o
0, 1
0, 1
Figure 11: Automaton accepting strings of even length.
Pattern Recognition
Problem
Design an automaton that accepts all strings over 0, 1 that have 001 as a substring, where u is a
substring of w if there are w
1
and w
2
such that w = w
1
uw
2
.
Solution
What do you need to remember? Whether you
havent seen any symbols of the pattern
8
have just seen 0
have just seen 00
have seen the entire pattern 001
Pattern Recognition Automaton
q

q
0
q
00
q
p
1
0
1
0
0
1
0, 1
Figure 12: Automaton accepting strings having 001 as substring.
grep Problem
Problem
Given text T and string s, does s appear in T?
Nave Solution
=s?

=s?

=s?

=s?

=s?

T
1
T
2
T
3
. . . T
n
T
n+1
. . . T
t
Running time = O(nt), where [T[ = t and [s[ = n.
grep Problem
Smarter Solution
Solution
Build DFA M for L = w [ there are u, v s.t. w = usv
Run M on text T
Time = time to build M + O(t)!
Questions
9
Is L regular no matter what s is?
If yes, can M be built eciently?
Knuth-Morris-Pratt (1977): Yes to both the above questions.
Multiples
Problem
Design an automaton that accepts all strings w over 0, 1 such that w is the binary representation
of a number that is a multiple of 5.
Solution
What must be remembered? The remainder when divided by 5.
How do you compute remainders?
If w is the number n then w0 is 2n and w1 is 2n + 1.
(a.b + c) mod 5 = (a.(b mod 5) + c) mod 5
e.g. 1011 = 11 (decimal) 1 mod 5 10110 = 22 (decimal) 2 mod 5 10111 = 23 (decimal)
3 mod 5
Automaton for recognizing Multiples
q
0
q
1
q
4
q
2
q
3
0
1
0
1
1
0
1
0
0
1
Figure 13: Automaton recognizing binary numbers that are multiples of 5.
A One k-positions from end
Problem
10
Design an automaton for the language L
k
= w [ kth character from end of w is 1
Solution
What do you need to remember? The last k characters seen so far!
Formally, M
k
= (Q, 0, 1, , q
0
, F)
States = Q = w [ w 0, 1

and [w[ k
(w, b) =

wb if [w[ < k
w
2
w
3
. . . w
k
b if w = w
1
w
2
. . . w
k
q
0
=
F = 1w
2
w
3
. . . w
k
[ w
i
0, 1
11