CS3240 Chap 2

CS 3240 - Chapter 2
Language
Machine
Grammar
Regular
Finite
Automaton
Regular
Expression,
Regular Grammar
Context-Free
Pushdown
Automaton
Context-Free
Grammar
Recursively
Enumerable
Turing Machine
Unrestricted
Phrase-Structure
Grammar
CS 3240 - Introduction
2.1:
2.2:
Deterministic Finite Automata

Non-deterministic Finite
Automata
2.3: Equivalence of DFAs and NFAs
2.4: State Minimization
Removing redundant states
CS 3240 - Finite Automata
Finite State Machine

Determinism: Always traverses the
same path and yields the same result
for the same input
Consists of:
A finite set of states
Exactly one start state
One or more final (accepting) states
An input alphabet
A transition function
Quintuple:
1)
A set of states, Q
2) An input alphabet,
3) A transition function, : Q x ->
Q
4) An initial state, q0
5) A set of final states, F Q
= ({q0,q1,q2}, {0,1} , , q0, {q1})

is defined as:
(q0,0) = q0
(q1,0) = q0
(q2,0) = q2
(q0,1) = q1
(q1,1) = q2
(q2,1) = q1
-q0
q0
q1
+q1
q0
q2
q2
q2
q1
Each state has exactly 2 out-edges (1 for

each letter)
What language is
this?
Strings
that have an even number of
as
Strings
that end in ab
Strings
that contain aba
Strings
over {0, 1} that end in 001
Each
state is a case in a switch

statement
Each states code examines a character
and changes state accordingly
All of this is in a read-loop
See fa1.cpp
Advantage:
Easy to code
Disadvantage:
Hard-codes the machine
10
Transition
table is stored in a 2-d
array
See fa2.cpp
Advantage:
Even easier to code
Disadvantage:
Hard-codes the table
11
Transition
table is read at runtime
See fa3.py (with input file fa3.dat)
Advantage:
Can process any DFA
Disadvantage:
Hard to code in a static language
Not so bad in Python, etc.
12
Sometimes
a state can never be exited
A black hole :-)
What language is
this?
13
If
we have a DFA for a language, L,

how can we form a DFA for its
complement?
* - L
Think
of the roles of final states in

recognizing strings
14
Find
a DFA for the set of all strings

except those that contain 001 as a
substring
First build a DFA that accepts strings
containing 001
Then invert the acceptability of
each state
Now all other strings will be accepted
15
Note that the empty string () is accepted
16
regular language is one that has a

DFA that accepts it
We just proved that the complement
of a regular language is also regular!
To show that a language is regular, we
find a DFA for it
If it isnt regular, well, thats another
story
Wait for Section 4.3
17
Build
a DFA that accepts all strings

over {a, b} that start and end in the
letter a (but not just a)
This one needs a jail
Build
a DFA for the language over

{a, b} containing an even number of
both as and bs
18
19
20
21
Consider
binary numbers as input
strings:
Construct a DFA where each state
represents the remainder of the number

mod 2
2 states representing 0 and 1, respectively
Making the 0state final accepts even numbers
Making the 1state final accepts odd numbers
Pretty easy
the last digit read determines the remainder
22
Consider binary numbers as input strings:

Construct a DFA where each state represents
the remainder of the number mod 3
Need 3 states representing 0, 1 and 2, respectively

Making the 0state final accepts numbers 0 mod 3
Must consider that reading the next bit, b,
forms the number 2n+b, where n is the

numeric value of the string processed so far
before reading b
Remember: n m mod 3 n = 3k+m, 0m<3
23
Design
a DFA for all strings over {0,

1} that have a 1 in the third position
from the end:
For example, 00100, 110,
24
Non-Deterministic Finite Automaton (NFA)

differs from a DFA in that it may have:
1. Zero or more out-edges from a state for the
same character
A Choice (multiple edges or even leave them out)
2. A move between states can consume no input

Moves on a whim (-transitions)
As
long as there exists at least one path to

a final state, the corresponding string is
accepted
25
Note: 2 out-edges for a
Note: no out-edges.
Not required in an
NFA.
Any subsequent
input
crashes the system.
26
It
is easier to design solutions
They
can be converted to an
equivalent DFA!
Rabin-Scott algorithm
27
Quintuple:
1)
2)
3)
A set of states, Q
An input alphabet,
A transition function, : Q x ({})
-> 2Q
4) An initial state, q0
5) A set of final states, F Q
Note:
DFAs are a special case of NFAs

28
Free ride from 1

to 2
29
Strings
Strings
Strings
that contain aa
that contain aa or bb
that begin and end with the
same letter
(ab + aba)*
30
Start
with the start state
Could be a composite
Out-going -transitions give a free ride!
See
where each character takes you
May be a set of states (we track all
simultaneously)
May be nowhere (this will be the jail in the DFA)
Repeat
until theres no place to go!

I find it easier to use transition tables
vs. transition graphs
31
The
lambda closure of a state in a

NFA is the set of states containing:
The state itself
All states reachable from the state by a
lambda transition
When
you enter a state in an NFA,

you can clearly reach any state in its
lambda closure
32
a
0
{0,1,
2}
33
a
0
{0,1,
2}
{0,1, {0,1, 2
2}
2}
{1,2
}
34
a
0
{0,1,
2}
{0,1, {0,1, 2
2}
2}
{1,2
}
{1,2
}
{1,2
}
35
aa
-0 0
bb
{0,1,
{0,1,
2}
2}
+
{0,1, 2
{0,1,2 2}
}
{1,2
}
+2
+
{1,2}
{1,2
}
36
Begin with the lambda closure of the original

start state as the new start state
This is your initial current state
For each state in the current (composite) state:

For each original transition leaving the current
original state, add the states in the lambda closure

of the corresponding target state to the result state
Continue until no more new (composite) states
emerge
Any transitions that go nowhere go to the jail

state
Final states are those with any original final state
37
Well do this by
hand
38
NFAs
leave out states and edges that

dont contribute to the language
When taking a complement, you need
those missing things!
The non-determinism complicates matters
as well
Only
DFAs can be complemented by

inverting the acceptability of each state
So convert the NFA to a DFA first

39
40
DFA can have redundant states
Often happens when converting from an
NFA
Sometimes
its easy to
remove/combine them by inspection
Sometimes its not!
There
is an algorithm to determine
whether states are distinguishable
41
42
43
States p and q are indistinguishable if,

starting in p and q, every string leads to the
same state of finality (i.e., the strings fail or
succeed together)
*(p,w) F *(q,w) F, and
*(p,w) F *(q,w) F
for all strings w
So we start with strings of length 0

then length 1, length 2
We stop if any string shows p and q distinguishable
44
Mark
all final states distinguishable from

non-final states (strings of length 0
distinguish these states, obviously)
Repeat until no new unmarked pairs are
marked distinguishable:
For all unmarked pairs of states, (p,q):
For each letter, c, of the alphabet :
If (p,c) and (q,c) are distinguishable, mark p and q

distinguishable
Combine each group of remaining

mutually indistinguishable states into a
single state
45
46
Start by grouping final vs. non-final states:

{q2, q4} vs. {q0, q1, q3}
Mark all 6 pairings between these groups distinguishable:
q0
q1
q2
q3
q4
q0
q1
q2
q3
q4
47
Check remaining unmarked pairs:

(q2,q4): (q2,0) = q1, (q4,0) = q4, => distinguishable
(q1,q3): (q1,0) = (q3,0) and (q1,1) = (q3,1) , =>
indistinguishable
q0
q0
q1
q2
q3
q4
q1
q2
x
x
q3
x
x
q4
48
49
Minimize
the machine on slide 44
dont combine the jails ahead of time,
just for fun
50
What
if two states, p and q, say, are

indistinguishable, and also states q
and r are indistinguishable?
51

CS3240 Chap 2

Uploaded by

Copyright:

Available Formats

CS3240 Chap 2

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CS3240 Chap 2

Uploaded by

Copyright:

Available Formats

CS 3240 - Chapter 2

Deterministic Finite Automata

CS 3240 - Finite Automata

Finite State Machine

= ({q0,q1,q2}, {0,1} , , q0, {q1})

CS 3240 - Finite Automata

CS 3240 - Finite Automata

Each state has exactly 2 out-edges (1 for

CS 3240 - Finite Automata

that have an even number of

that contain aba

over {0, 1} that end in 001

CS 3240 - Finite Automata

state is a case in a switch

table is stored in a 2-d

CS 3240 - Finite Automata

table is read at runtime

See fa3.py (with input file fa3.dat)

CS 3240 - Finite Automata

a state can never be exited

A black hole :-)

we have a DFA for a language, L,

of the roles of final states in

CS 3240 - Finite Automata

a DFA for the set of all strings

Note that the empty string () is accepted

CS 3240 - Finite Automata

regular language is one that has a

a DFA that accepts all strings

a DFA for the language over

CS 3240 - Finite Automata

CS 3240 - Finite Automata

CS 3240 - Finite Automata

CS 3240 - Finite Automata

binary numbers as input

represents the remainder of the number

Consider binary numbers as input strings:

the remainder of the number mod 3

Need 3 states representing 0, 1 and 2, respectively

Must consider that reading the next bit, b,

forms the number 2n+b, where n is the

a DFA for all strings over {0,

CS 3240 - Finite Automata

Non-Deterministic Finite Automaton (NFA)

2. A move between states can consume no input

long as there exists at least one path to

Note: 2 out-edges for a

CS 3240 - Finite Automata

is easier to design solutions

CS 3240 - Finite Automata

DFAs are a special case of NFAs

Free ride from 1

CS 3240 - Finite Automata

CS 3240 - Finite Automata

with the start state

where each character takes you

May be a set of states (we track all

May be nowhere (this will be the jail in the DFA)