Transcript Module 15

Module 15
• FSA’s
– Defining FSA’s
– Computing with FSA’s
• Defining L(M)
– Defining language class LFSA
– Comparing LFSA to set of solvable languages
(REC)
1
Finite State Automata
New Computational Model
2
Tape
• We assume that you have already seen
FSA’s in CSE 260
– If not, review material in reference textbook
• Only data structure is a tape
– Input appears on tape followed by a B character
marking the end of the input
– Tape is scanned by a tape head that starts at
leftmost cell and always scans to the right
3
Data type/States
• The only data type for an FSA is char
• The instructions in an FSA are referred to as
states
• Each instruction can be thought of as a
switch statement with several cases based
on the char being scanned by the tape head
4
Example program
1 switch(current tape cell) {
case a: goto 2
case b: goto 2
case B: return yes
}
2 switch (current tape cell) {
case a: goto 1
case b: goto 1
case B: return no;
}
5
New model of computation
1 switch(current tape cell) {
case a: goto 2
case b: goto 2
case B: return yes
}
2 switch (current tape cell) {
case a: goto 1
case b: goto 1
case B: return no;
}
• FSA M=(Q,S,q0,A,d)
– Q = set of states = {1,2}
– S = character set = {a,b}
• don’t need B as we see below
– q0 = initial state = 1
– A = set of accepting (final) states
= {1}
• A is the set of states where we
return yes on B
• Q-A is set of states that return no
on B
– d = state transition function
6
Textual representations of d *
1 switch(current tape cell) {
case a: goto 2
case b: goto 2
case B: return yes
d(1,a) = 2, d(1,b)=2,
d(2,a)=1, d(2,b) = 1
{(1,a,2), (1,b,2), (2,a,1), (2,b,1)}
}
2 switch (current tape cell) {
case a: goto 1
case b: goto 1
case B: return no;
}
1
2
a
b
2
1
2
1
7
Transition diagrams
1 switch(current tape cell) {
case a: goto 2
case b: goto 2
case B: return yes
}
2 switch (current tape cell) {
case a: goto 1
case b: goto 1
case B: return no;
}
a,b
2
1
a,b
Note, this transition diagram
represents all 5 components
of an FSA, not just the transition
function d
8
Exercise *
• FSA M = (Q, S, q0, A, d)
–
–
–
–
–
Q = {1, 2, 3}
S = {a, b}
q0 = 1
A = {2,3}
d: {d(1,a) = 1, d(1,b) = 2, d(2,a)= 2, d(2,b) = 3,
d(3,a) = 3, d(3,b) = 1}
• Draw this FSA as a transition diagram
9
Transition Diagram
a
a
1
b
2
b
b
3
a
10
Computing with FSA’s
11
Computation Example *
a
a
1
b
2
b
b
3
a
Input: aabbaa
12
Computation of FSA’s in detail
• A computation of an FSA M on an input x is
a complete sequence of configurations
• We need to define
– Initial configuration of the computation
– How to determine the next configuration given
the current configuration
– Halting or final configurations of the
computation
13
Initial Configuration
a
a
b
1
2
b
b
3
FSA M
a
• Given an FSA M and an
input string x, what is the
initial configuration of the
computation of M on x?
– (q0,x)
– Examples
•
•
•
•
•
•
x = aabbaa
(1, aabbaa)
x = abab
(1, abab)
x=l
(1, l)
14
Definition of |-M
• (1, aabbaa) |-M (1, abbaa)
a
a
b
1
2
b
b
3
FSA M
a
– config 1 “yields” config 2 in
one step using FSA M
• (1,aabbaa) |-3M (2, baa)
– config 1 “yields” config 2 in 3
steps using FSA M
• (1, aabbaa) |-*M (2, baa)
– config 1 “yields” config 2 in 0
or more steps using FSA M
• Comment:
– |-M determined by transition
function d
– There must always be one and
only one next configuration
• If not, M is not an FSA
15
Halting Configurations *
a
• Halting configuration
a
b
1
2
b
b
3
FSA M
a
– (q, l)
– Examples
• (1, l)
• (3, l)
• Accepting Configuration
– State in halting configuration is
in A
• Rejecting Configuration
– State in halting configuration is
not in A
16
a
a
FSA M on x *
b
b
FSA M
b
a
• Two possibilities for M running on x
– M accepts x
• M accepts x iff the computation of M on x ends up in an
accepting configuration
• (q0, x) |-*M (q, l) where q is in A
– M rejects x
• M rejects x iff the computation of M on x ends up in a rejecting
configuration
• (q0, x) |-*M (q, l) where q is not in A
– M does not loop or crash on x
17
a
a
Examples *
b
b
FSA M
b
a
– For the following input strings, does M
accept or reject?
• l
• aa
• aabba
• aab
• babbb
18
Definition of d*(q, x)
a
b
1
b
a
• Notation from the book
• d(q, c) = p
• dk(q, x) = p
2
– k is the length of x
b
3
FSA M
a
• d*(q, x) = p
• Examples
–
–
–
–
–
d(1, a) = 1
d(1, b) = 2
d4(1, abbb) = 1
d*(1, abbb) = 1
d*(2, baaaaa) = 3
19
a
L(M) and
LFSA *
• L(M) or Y(M)
a
b
b
FSA M
b
a
– The set of strings M accepts
• Basically the same as Y(P) from previous unit
– We say that M accepts/decides/recognizes/solves L(M)
• Remember an FSA will not loop or crash
– What is L(M) (or Y(M)) for the FSA M above?
• N(M)
– Rarely used, but it is the set of strings M rejects
• LFSA
– L is in LFSA iff there exists an FSA M such that L(M) = L.
20
LFSA Unit Overview
• Study limits of LFSA
– Understand what languages are in LFSA
• Develop techniques for showing L is in LFSA
– Understand what languages are not in LFSA
• Develop techniques for showing L is not in LFSA
• Prove Closure Properties of LFSA
• Identify relationship of LFSA to other
language classes
21
Comparing language classes
Showing LFSA is a subset of REC,
the set of solvable languages
22
LFSA subset REC
• Proof
– Let L be an arbitrary language in LFSA
– Let M be an FSA such that L(M) = L
• M exists by definition of L in LFSA
–
–
–
–
Construct C++ program P from FSA M
Argue P solves L
There exists a C++ program P which solves L
L is solvable
23
Visualization
•Let L be an arbitrary language in LFSA
•Let M be an FSA such that L(M) = L
•M exists by definition of L in LFSA
•Construct C++ program P from FSA M
•Argue P solves L
•There exists a program P which solves L
•L is solvable
L
L
LFSA
M
FSA’s
REC
P
C++ Programs
24
Construction *
FSA
M
Program
Construction
P
Algorithm
• The construction is an algorithm which
solves a problem with a program as input
– Input to A: FSA M
– Output of A: C++ program P such that P solves
L(M)
– How do we do this?
25
Comparing computational
models *
• The previous slides show one method for
comparing the relative power of two different
computational models
– Computational model CM1 is at least as general or
powerful as computational model CM2 if
• Any program P2 from computational model CM2 can be
converted into an equivalent program P1 in computational
model CM1.
– Question: How can we show two computational models
are equivalent?
26