Finite-State Machines with No Output
Ying Lu
Based on Slides by Elsa L Gunter, NJIT,
Costas Busch, and Longin Jan Latecki,
Temple University
Kleene closure
• A and B are two sets of strings.
The concatenation of A and B is
AB={xy: x string in A and y string in B}
• Example: A={0, 11} and B={1, 10, 110}
AB={01,010,0110,111,1110,11110}
• A0={λ}, where λ represents the empty string
An+1=AnA
for n=0,1,2,…
Let A be any set of strings formed of characters in V.
Kleene closure of A, denoted by A*, is

A A
*
k
k 0
Examples:
If C={11}, then C*={12n: n=0,1,2,…}
If B={0,1}, then B*={all binary strings}.
Finite State Automata
• A FSA is similar to a compiler in that:
– A compiler recognizes legal programs in some (source) language.
– A finite-state machine recognizes legal strings in some language.
• Example: Pascal Identifiers
– sequences of one or more letters or digits,
starting with a letter:
letter | digit
letter
S
A
Finite Automaton
•
Input
String
Finite
Automaton
Output
“Accept”
or
“Reject”
Finite State Automata
• A finite state automaton over an alphabet
is illustrated by a state diagram:
– a directed graph
– edges are labeled with elements of alphabet,
– some nodes (or states), marked as final
– one node marked as start state
Transition Graph
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
initial
state
state
transition
a, b
q4
accepting
state
Initial Configuration
a
a
b
b
•
Input String
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Reading the Input
a
a
b
b
•
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
•
a b b a
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
•
a b b a
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
•
a b b a
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Input finished
a b b a
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
accept
Rejection
a
a
b
•
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
•
a b a
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
•
a b a
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
•
a b a
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Input finished
a b a
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
reject
a, b
q4
Another Rejection

•
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4

•
a, b
q5
b
q0 a
reject
a
a
b
q1 b q2 b q3 a
a, b
q4
Another Example
a a b
a, b
a
q0
b
q1
a, b
q2
a a b
a, b
a
q0
b
q1
a, b
q2
a a b
a, b
a
q0
b
q1
a, b
q2
a a b
a, b
a
q0
b
q1
a, b
q2
Input finished
a a b
a
q0
a, b
accept
b
q1
a, b
q2
Rejection Example
b a b
a, b
a
q0
b
q1
a, b
q2
b a b
a, b
a
q0
b
q1
a, b
q2
b a b
a, b
a
q0
b
q1
a, b
q2
b a b
a, b
a
q0
b
q1
a, b
q2
Input finished
b a b
a, b
a
q0
b
q1
a, b
q2
reject
Finite State Automata
• A finite state automaton M=(S,Σ,δ,s0,F)
consists of
• a finite set S of states,
• a finite input alphabet Σ,
• a state transition function δ: S x Σ  S,
• an initial state s0,
• F subset of S that represent the final states.
Finite Automata
• Transition
s1 
 s2
a
• Is read ‘In state s1 on input “a” go to state s2’
• At the end of input
– If in accepting state => accept
– Otherwise => reject
• If no transition possible (got stuck) => reject
• FSA = Finite State Automata
Input Alphabet 
•
  a, b
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Set of States Q
•
Q  q0 , q1, q2 , q3 , q4 , q5 
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Initial State q0
•
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Set of Accepting States F
•
F  q4 
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Transition Function 
•
 : S   S
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
 q0 , a   q1
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
 q0 , b   q5
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
 q2 , b   q3
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Transition Function 
q0•
a
q1
q2
q5

q1
q5
q3
q4
q5
q5
q4
q5
b
q5
q2
q3
q5
q5
q5
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Language accepted by FSA
• The language accepted by a FSA is the set of strings
accepted by the FSA.
• in the language of the FSM shown below:
x, tmp2, XyZzy, position27.
• not in the language of the FSM shown below:
• 123, a?, 13apples.
letter | digit
letter
S
A
Example
LM   abba
M
•
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
accept
Example
LM    , ab, abba
M
•
a, b
q5
b
q0 a
accept
a
a
b
q1 b q2 b q3 a
accept
a, b
q4
accept
Example
•
LM   {a b : n  0}
n
a, b
a
q0
b
q1
accept
a, b
q2
trap state
Extended Transition Function  *
 * : Q  *  Q
•
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
 * q0 , ab   q2
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
 * q0 , abba   q4
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
 * q0 , abbbaa   q5
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Observation: if there is a walk from
with label w then
q to q
 * q, w  q
w
q
q
w  1 2  k
q
1
2
k
q
Example: There is a walk from q0 to q5
with label abbbaa
 * q0 , abbbaa   q5
a, b
q5
b
q0 a
a
a
b
q1 b q2 b q3 a
a, b
q4
Recursive Definition
 * q ,    q
 * q, w    ( * (q, w), )
q
w
q1 
q
 * q , w   q
 (q1, )  q
 * q, w    (q1, )
 * q, w  q1
 * q, w    ( * (q, w), )
Language Accepted by FSAs
• For a FSA
M  Q, ,  , q0 , F 
• Language accepted by
•
M:
LM   w  * :  * q0 , w  F 
q0
w
q
q  F
Observation
• Language rejected by M :
LM   w  * :  * q0 , w  F 
q0
w
q
q  F
Example
•
LM = { all strings with prefix ab }
a, b
q0
a
q1
b
a
q3
b
q2
accept
a, b
Example
• LM  = { all strings without
substring 001 }
0
1
0,1
1

0
0
0
00
1
001
Example
• L( M )  awa : w  a, b*
b
a
b
q0
a
q2
q3
a
b
q4
a, b
Deterministic FSAs
• If a FSA has for every state exactly one
edge for each letter in alphabet then
FSA is deterministic
• In general a FSA is non-deterministic.
• Deterministic FSA special kind of nondeterministic FSA
Example FSA
• Deterministic FSA
• Regular expression: (0  1)* 1
1
0
1
0
Example DFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
1
0
1
0
Example DFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
1
0
1
0
Example DFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
1
0
1
0
Example DFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
1
0
1
0
Example DFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
1
0
1
0
Example DFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
1
0
1
0
Example DFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
1
0
1
0
Example NFSA
• Regular expression: (0  1)* 1
• Non-deterministic FSA
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
• Guess
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
• Backtrack
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
• Guess again
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
• Guess
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
• Backtrack
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
• Guess again
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
0
1
1
Example NFSA
• Regular expression: (0  1)* 1
• Accepts string 0 1 1 0 1
• Guess (Hurray!!)
0
1
1
If a language L is recognized by
a nondeterministic FSA,
then L is recognized by a deterministic FSA
NFSA
FSA
How to Implement an FSA
A table-driven approach:
• table:
– one row for each state in the machine, and
– one column for each possible character.
• Table[j][k]
– which state to go to from state j on character k,
– an empty entry corresponds to the machine getting
stuck.
The table-driven program for a
Deterministic FSA
state = S // S is the start state
repeat {
k = next character from the input
if (k == EOF) // the end of input
if state is a final state then accept
else reject
state = T[state,k]
if state = empty then reject // got stuck
}
In-Class Exercise
• Construct a finite-state automaton that
recognizes the set of bit strings consisting of
a 0 followed by a string with an odd number
of 1s.
Appendix
Regular Expressions
Regular expressions
describe regular languages
Example:
(a  b  c) *
describes the language
a, bc*   , a, bc, aa, abc, bca,...
Recursive Definition
Primitive regular expressions:
Given regular expressions
,  , 
r1 and r2
r1  r2
r1  r2
r1 *
r1 
Are regular expressions
Examples
A regular expression:
a  b  c  * (c  )
Not a regular expression:
a  b  
Languages of Regular
Expressions
Lr 
: language of regular expression
r
Example
L(a  b  c) *   , a, bc, aa, abc, bca,...
Definition
For primitive regular expressions:
L   
L    
La   a
Definition (continued)
For regular expressions r1 and
r2
Lr1  r2   Lr1   Lr2 
Lr1  r2   Lr1  Lr2 
Lr1 *   Lr1  *
Lr1   Lr1 
Example
Regular expression:
a  b   a *
La  b   a *  La  b  La *
 La  b  La *
  La   Lb   La  *
 a  b a *
 a, b , a, aa, aaa,...
 a, aa, aaa,...,b, ba, baa,...
Example
Regular expression
r  a  b  * a  bb
Lr   a, bb, aa, abb, ba, bbb,...
Example
Regular expression
Lr   {a b
r  aa  * bb  * b
2n 2m
b : n, m  0}
Example
Regular expression
r  (0  1) * 00 (0  1) *
L(r ) = { all strings with at least
two consecutive 0 }
Example
Regular expression
r  (1  01) * (0   )
L(r ) = { all strings without
two consecutive 0 }
Equivalent Regular Expressions
• Definition:
•
Regular expressions r1 and
•
are equivalent if
r2
L(r1)  L(r2 )
Example
L = { all strings without two consecutive 0 }
r1  (1  01) * (0   )
r2  (1* 011*) * (0   )  1* (0   )
L(r1)  L(r2 )  L
r1 and r2
are equivalent
regular expr.
Example: Lexing
• Regular expressions good for
describing lexemes (words) in a
programming language
– Identifier = (a  b  …  z  A  B  … 
Z) (a  b  …  z  A  B  …  Z  0  1
 …  9  _  ‘ )*
– Digit = (0  1  …  9)
Implementing Regular
Expressions
• Regular expressions, regular grammars
reasonable way to generates strings in
language
• Not so good for recognizing when a
string is in language
• Regular expressions: which option to
choose, how many repetitions to make
• Answer: finite state automata