CMPS 3223
Theory of Computation
Automata, Computability, & Complexity
by Elaine Rich
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Slides provided by author
Slides edited for use by MSU Department of
Computer Science – R. Halverson
1
Finite State Machines
& Regular Languages
Chapter 5A
Pages 54-71
2
Homework for 5A
Page 121+
• Exercises 1 – 6 (all parts)
• #2 – may need to develop nondeterministic first
• #6 – can be deterministic or nondeterministic
More will be assigned in 5B.
3
Languages and Machines
4
Regular Languages
Regular
Language
L
Defines
Regular Expression
Accepts
Regular Grammar
Finite State
Machine
5
Finite State Machine (FSM)
Non-technical definition
Finite State Machine (FSM)
• Computational device having a string as
input and having one of 2 possible outputs
– Accept or Reject
6
Finite State Machine (FSM)
Non-technical Description of Operation
• There is a designated Start state
• Reads 1 character at a time, left to right
• (Current State, Character)  New State
– Repeat
• Stop when no more characters OR no defined
New State
• Every state is designated as either an Accepting
or Rejecting state
• Ending state designation determines if string is
Accepted or Rejected
7
Example Finite State Machine
Incoming arrow indicates start state
Double Circles  Accepting state
Single Circles  Rejecting state
Note: time required <= |string|
8
Finite State Machine Example
• Drinks in a machine cost 25¢
• Accepts Nickels, Dimes, Quarters only
• Insert coins, push “Soda” button, drink is
dispensed if “Enough Money”
• LANGUAGE: String of coin sequences adding
to 25¢ (or more) allowing drink to be dispensed
– {Q,DDN, NNND, DNNN,DND, etc…}
– Actually, S can be inserted within any string
– What about extra money (change)?
• Look at one final product!
9
FSM for Drink Machine
An FSM to accept $.25 in change for a drink
Note that states are “labeled” for clarity
Machine has ERRORS!! Can you find them??
But you get the idea!
Should there be a “50” state? Why or why not?
10
Formal Definition of a DFSM
MEMORIZE!!!
Deterministic Finite State Machine (DFSM) is M:
M = (K, , , s, A), where:
K is a finite set of states
 is an alphabet
s  K is the initial state
A  K is the set of accepting states, and
 is the transition function from (K  ) to K
*The set of ALL strings accepted by M form the
Language defined by the DFSM.
11
Configurations of DFSMs
A Configuration of a DFSM M is an element of
K  *
Configuration captures the two things that
make a difference to M’s future behavior:
• its current state
• the input that remains to be read.
The Initial Configuration of a DFSM M, on
input w, is (sM, w) , where sM is start state of M
12
Transition Function - 
• Defines the DFSM, one state at a time
•  is set of all pairs of states in M &
characters in ∑
(Current State, Current Character)  New State
Note: we often reduce the set  to those pairs that
are “useful” or to only those that can lead to an
Accepting state
13
Complete vs. Incomplete FSM
• Complete FSM
– A transition is defined for every possible state
and every possible character in the alphabet
– Note: Can cause FSM to be larger than necessary, but
ALWAYS processes the entire string
• Incomplete FSM
– One which defines a transition for every
possible state & every possible character in
the alphabet which can lead to an accepting
state
– Note: If no transition is defined, the string is Rejected
14
Complete vs. Incomplete Example
∑ = {a, b, c}
L = {strings beginning with c & followed by
only a’s & b’s, at least 1}
C
S
a
q1
b
15
The Yields Relations
The yields-in-one-step relation |-M
(q, w) |-M (q', w') iff
• w = a w' for some symbol a  , and
•  (q, a) = q'
|-M * is the reflexive, transitive closure of |-M.
Transitions defined by processing ONE character
M refers to the particular machine, so can leave it
off, usually.
16
Computations Using FSMs
A Computation by M is a finite sequence of
configurations C0, C1, …, Cn for some n  0
such that:
*C0 is an initial configuration,
*Cn is of the form (q, ), for some state q  KM
•
 indicates empty string, entire string is processed &
implies a complete DFSM
*C0 |-M C1 |-M C2 |-M … |-M Cn.
However, M Halts when the last character has
be processed or a next transition is not defined
17
Accepting and Rejecting
A DFSM M Accepts a string w iff
(s, w) |-M * (q, ), for some q  AM.
A DFSM M Rejects a string w iff
(s, w) |-M* (q, ), for some q  AM.
The language accepted by M, denoted L(M), is
the set of all strings accepted by M.
Theorem: Every DFSM M, on input s, halts in |s|
steps.
18
Example Language
L = {x | x is an odd integer}
• Is 3456 L?
• How will we develop a machine to
answer the question?
• Process characters left to right
• Assume the current character is the
LAST character
• What are the necessary states?
19
An Example Computation
An FSM to accept odd integers:
even
odd
even
q0
q1
odd
On input 235, the configurations are:
(q0, 235)
(q0, 35)
(q1, 5)
|||-
(q0, 35)
(q1, 5)
(q1,  ) Accept
Thus (q0, 235) |-* (q1, ) [* means 0 or more steps]
20
Developing a DFSM
Heuristic – a generality, a recommendation
• List or Label the possible states of a
machine based upon the language or
problem definition
• Determine the transitions between the
states
21
Developing DFSM Examples
• L = {x | x contains an even number of a’s}
– What would the states of the DFSM be?
– What would the transitions be?
• L = {x | x contains an even number of a’s &
odd number of b’s}
– What would the states of the DFSM be?
– What would the transitions be?
22
Even a’s Odd b’s
Let L = {w  {a, b}* : w contains an even
number of a’s and an odd number of b’s}
23
5.2 - 5.3 Regular Languages
A language is regular iff it is accepted
by some FSM.
We have defined
several regular
languages…
24
Regular Examples
L = {w  {a,b}*| every region of a’s is of
even length}
L = {w  {a,b}*| w contains at most 1 b }
L = {w  {a,b}*| no 2 consecutive
characters are the same }
L = {w  {a,b}*| anbn, n>=1}
25
A Very Simple Example
L = {w  {a, b}* | every a is immediately
followed by a b}.
The Existence Problem
• Does the definition imply the existence of any
characters?
• Is the empty string a member of the language?
26
Parity Checking Example
L = {w  {0, 1}* : w has odd parity}.
Complete or incomplete DFSM?
27
No More Than One b
L = {w  {a, b}* : w contains no more than
1 b}
Complete or incomplete DFSM?
28
Error States or Dead States
An Error State or Dead State is a
rejecting state from which the
string can never go back to an
Accepting State.
Some DFSM can have, others cannot!
29
Error States or Dead States
∑ = {a, b, c}
L = {strings beginning with c & followed by
only a’s & b’s, at least 1}
C
a
S
q1
a,b
b
d
a, b
30
Checking Consecutive Characters
L = {w  {a, b}*| no two consecutive
characters are the same}.
ERROR – d is not an
accepting state
d is Dead State;
once in that state
string cannot be
accepted.
31
DFSM Example
L=
{w  {a, b}* : every a region in w is of even length}
d is a Dead State – Can Be Removed!
32
The Language of Floating Point
Numbers is Regular
Example strings:
+3.0, 3.0, 0.3E1, 0.3E+1, -0.3E+1, -3E8
The language is accepted by the DFSM:
33
A Simple Communication Protocol
34
Controlling a Soccer-Playing Robot
35
A Simple Controller
36
Vowels in Alphabetical Order
L = {w  {a - z}* : all five vowels, a, e, i, o, and u,
occur in w in alphabetical order}.
37
Developing FSMs
Sometimes, it is “easier” to develop the
FSM for the complement of the
language, then reverse the Accept &
Reject states
Do you believe this would work???
L = {w  {a, b}* : w does not contain the
substring aab}.
38
Complement of FSMs
L = {w  {a, b}* : w does not contain the
substring aab}.
Start with a machine for L
How must it be changed?
39
A Building Security System
L = {event sequences such that the alarm
should sound}
40
FSMs Predate Computers
The Prague Orloj, originally built in 1410.
41
The Abacus
42
The Missing Letter Language
Let  = {a, b, c, d}.
Let LMissing =
{w : there is a symbol ai   not appearing in w}.
Try to make a DFSM for Lmissing
First develop machine for set of strings containing
ALL 4 characters, then reverse.
43
5.4 Definition of an NDFSM
Memorize
A Non-deterministic Finite State Machine
M = (K, , , s, A), where:
• K is a finite set of states
•  is an alphabet
• s  K is the initial state
• A  K is the set of accepting states,
•  is the transition relation, a finite
subset of (K  (  {})) to K
Non-deterministic if there is at least one state from
which there are 2 or more transitions defined for a
single character.
44
NDFSM Example
45
*NDFSM – Accepting a String
A NDFSM M accepts a string w iff there
exists some path along which w drives
M to some Accepting state.
The language accepted by M, denoted
L(M), is the set of all strings accepted
by M.
NOTE: significant difference between
deterministic & non-deterministic
46
*NDFSM – Rejecting a String
A NDFSM M rejects a string w iff all
paths along which w drives M lead to
an Rejecting state.
NOTE: significant difference between
deterministic & non-deterministic
47
DFSM vs. NDFSM
Time Complexity of determining
accept/reject for string w
• DFSM – O(n) where n = |w|
• NDFSM – O(X) where X = ????
– X stated in terms of what??
– How does complete vs. incomplete
machine affect time?
48
NDFSM Time Complexity
Given a string w with
|w| = 2, how many
possible paths to
determine accept or
reject? What if |w| is
larger? What if the FSM
gets larger?
49
Epsilon () Transitions
• An Epsilon () Transition
– Is one that does not consume a
character of the input string.
– Allows movement from one state to
another without consuming a character
of the input string.

50
Sources of Non-determinism
2 Types
1. Epsilon transition
2. 2+ transitions for a single character
Which path should be taken???
51
Use of Epsilon Transitions
Optional Substrings
L = {w  {a, b}* : w is made up of an optional a
followed by aa followed by zero or more b’s}
L = {aa, aaa, aab, aaab, aabb, aaabb, … }
52
Use of Epsilon Transitions
Multiple Sublanguages
L = {w  {a, b}* : w = aba or |w| is even}
53
Pattern Matching
L = {w  {a, b, c}* : x, y  {a, b, c}* (w = x abcabb y)}.
An NDFSM:
But how do you know when to take the a-transition to q1?
Strategically,
1. First time, take it on first a,
2. Second time, take it on second a, etc…
Until all a’s are exhausted or you accept the string.
54
NDFSM to DFSM
1. Try again –develop a Deterministic
Machine
2. There is an algorithm that allows you to
convert NDFSM to DFSM
** but more on that later
55
Pattern Matching
L = {w  {a, b, c}* : x, y  {a, b, c}* (w = x abcabb y)}.
A DFSM:
56
Multiple Keywords
L = {w  {a, b}* : x, y  {a, b}*
(w = x abbaa y or w = x baba y)}.
57
Checking from the End
L = {w  {a, b}* :
the fourth to the last character is a}
58
Another Pattern Matching Example
L = {w  {0, 1}* : w is the binary encoding of a
positive integer that is divisible by 16 or is
odd}
How can you rewrite as a string problem?
59
Another Pattern Matching Example
L = {w  {0, 1}* : w is the binary encoding of a
positive integer that is
(1) divisible by 16, or
(2) is odd}
How can you rewrite as a string problem?
(1) 5th character from end is a 1
(2) last character is 1
60
Another NDFSM
Do for Homework!
L1= {w  {a, b}*: aa occurs in w}
L2= {x  {a, b}*: bb occurs in x}
L3= {y :  L1 or L2 }
M1 =
M 2=
M 3=
61
Analyzing Nondeterministic FSMs
Does this FSM accept:
baaba
Remember: we just have to find one accepting path.
62
Homework for 5A
Pages 53-71
Page 121+
• Exercises 1 – 6 (all parts)
• #2 – may need to develop nondeterministic first
• #6 – can be deterministic or nondeterministic
More will be assigned in 5B.
63