Language class LFSA

1
Lecture 14

• Language class LFSA
• Study limits of what can be done with FSAs
• Closure Properties
• Comparing to other language classes

2
LFSA Unit Overview

• Study limits of LFSA
• Understand what languages are in LFSA
• Develop techniques for showing L in LFSA
• Understand what languages are not in LFSA
• Develop techniques for showing L not in LFSA
• Prove Closure Properties of LFSA
• Identify relationship of LFSA to other language
  classes

3
Closure Properties of LFSA

• Remember ideas from REC

4
LFSA closed under set complement

• If L is in LFSA, then Lc is in LFSA
• Proof
• Let L be an arbitrary language in LFSA
• Let M be the FSA such that L(M) L
• M exists by definition of L in LFSA
• Construct FSA M from M
• Argue L(M) Lc
• There exists an FSA M such that L(M) Lc
• Lc is in LFSA

5
Visualization

• Let L be an arbitrary language in LFSA
• Let M be the FSA such that L(M) L
• M exists by definition of L in LFSA
• Construct FSA M from M
• Argue L(M) Lc
• Lc is in LFSA

LFSA
LFSA
6
Construct FSA M from M

• What did when we proved that REC is closed under
  set complement?
• Construct program P from program P
• P is basically the same program as program P
• The only difference comes at the end
• If P is about to return no, P returns yes
  instead
• If P is about to return yes, P returns no
  instead
• Can we translate this to FSA setting?

7
Construct FSA M from M

• M (Q, S, q0, A, d)
• M (Q, S, q, A, d)
• M should say yes when M says no
• M should say no when M says yes
• How?
• Q Q
• S S
• q q0
• d d
• A Q-A

8
Example
Q Q S S q q0 d d A Q-A
a
a
2
b
1
b
b
3
FSA M
a
9
Construction is an algorithm
FSA M
FSA M
Construction Algorithm

• Set Complement Construction
• Algorithm Specification
• Input FSA M
• Output FSA M such that L(M) L(M)c
• Comments
• This algorithm can be in any computational model.
• It does not have to be (and typically is not) an
  FSA
• These set closure constructions are useful.
• More on this later

10
Construction is an algorithm
FSA M
FSA M
Construction Algorithm

• Your algorithm must give a complete specification
  of M in terms of M
• Example
• Let input FSA M (Q, S, q0, A, d)
• Output FSA M (Q, S, q, A, d) where
• Q Q
• S S
• q q0
• d d
• A Q-A
• When describing such constructions, I will often
  only focus on the critical component, in this
  case A Q-A, but you must specify all
  components of M in terms of M.

11
LFSA closed under Set Intersection Operation
(also set union, set difference, and symmetric
difference)
12
LFSA closed under set intersection operation

• Let L1 and L2 be arbitrary languages in LFSA
• Let M1 and M2 be FSAs s.t. L(M1) L1, L(M2)
  L2
• M1 and M2 exist by definition of L1 and L2 in
  LFSA
• Construct FSA M3 from FSAs M1 and M2
• Argue L(M3) L1 intersect L2
• There exists FSA M3 s.t. L(M3) L1 intersect L2
• L1 intersect L2 is in LFSA

13
Visualization

• Let L1 and L2 be arbitrary languages in LFSA
• Let M1 and M2 be FSAs s.t. L(M1) L1, L(M2)
  L2
• M1 and M2 exist by definition of L1 and L2 in
  LFSA
• Construct FSA M3 from FSAs M1 and M2
• Argue L(M3) L1 intersect L2
• There exists FSA M3 s.t. L(M3) L1 intersect L2
• L1 intersect L2 is in LFSA

LFSA
14
Algorithm Specification

• Input
• Two FSAs M1 and M2
• Output
• FSA M3 such that L(M3) L(M1) intersection L(M2)
  

FSA M1 FSA M2
FSA M3
15
Use Old Ideas

• Key concept Try ideas from previous closure
  property proofs
• Example
• How did the algorithm for proving recursive
  languages are closed under set intersection work?
• Run both input programs on the input string
• Say yes only if both say yes
• Try to create an FSA M3 that simultaneously runs
  M1 and M2 on the input string

16
Run M1 and M2 Simultaneously
0
1
0
1
1
l
0
2
0
0
1
1
M1
What happens when M1 and M2 run on input string
11010?
17
Construction

• Input
• FSA M1 (Q1, S1, q1, d1, A1)
• FSA M2 (Q2, S2, q2, d2, A2)
• Output
• FSA M3 (Q3, S3, q3, d3, A3)
• What is Q3?
• Q3 Q1 X Q2 where X is cartesian product
• In this case, Q3 (l,A), (l,B), (0,A), (0,B),
  (1,A), (1,B), (2,A), (2,B)
• What is S3?
• S3 S1 S2
• In this case, S3 0,1

18
Construction

• Input
• FSA M1 (Q1, S1, q1, d1, A1)
• FSA M2 (Q2, S2, q2, d2, A2)
• Output
• FSA M3 (Q3, S3, q3, d3, A3)
• What is q3?
• q3 (q1, q2)
• In this case, q3 (l,A)
• What is A3?
• A3 (p, q) p in A1 and q in A2
• In this case, A3 (0,B)

19
Construction

• Input
• FSA M1 (Q1, S1, q1, d1, A1)
• FSA M2 (Q2, S2, q2, d2, A2)
• Output
• FSA M3 (Q3, S3, q3, d3, A3)
• What is d3?
• For all p in Q1, q in Q2, a in S, d3((p,q),a)
  (d1(p,a),d2(q,a))
• In this case,
• d3((0,A),0) (d1(0,0),d2(A,0))
• (0,B)
• d3((0,A),1) (d1(0,1),d2(A,1))
• (1,A)

20
Example Summary
1
0
1
1
0
1
1
l
0
2
0
l,A
0,A
1,A
2,A
1
0
1
1
0
0
0
M1
1
0
0
1
l,B
0,B
1,B
2,B
0
1
M3
21
Observation

• Input
• FSA M1 (Q1, S1, q1, d1, A1)
• FSA M2 (Q2, S2, q2, d2, A2)
• Output
• FSA M3 (Q3, S3, q3, d3, A3)
• What is A3?
• A3 (p, q) p in A1 and q in A2
• What if operation were different?
• Set union, set difference, symmetric difference

22
Observation continued

• Input
• FSA M1 (Q1, S1, q1, d1, A1)
• FSA M2 (Q2, S2, q2, d2, A2)
• Output
• FSA M3 (Q3, S3, q3, d3, A3)
• What is A3?
• Set intersection A3 (p, q) p in A1 and q in
  A2
• Set union A3 (p, q) p in A1 or q in A2
• Set difference A3 (p, q) p in A1 and q not
  in A2
• Symmetric difference A3 (p, q) (p in A1 and
  q not in A2) or (p not in A1 and q in A2)

23
Observation conclusion

• LFSA is closed under
• set intersection
• set union
• set difference
• symmetric difference
• The constructions used to prove these closure
  properties are essentially identical

24
Comments

• You should be able to execute this algorithm
• Convert two FSAs into a third FSA with the
  correct properties.
• You should understand the idea behind this
  algorithm
• The third FSA essentially runs both input FSAs
  simultaneously on any input string
• How we set A3 depending on the specific set
  operation
• You should understand the importance of this
  algorithm
• Design tool
• Suppose you need to build an FSA to accept some
  language L3
• You observe L3 L1 intersection L2
• You already have or can easily build FSAs to
  accept L1 and L2
• Use this algorithm on those FSAs to constrct an
  FSA to accept L3
• You should be able to construct new algorithms
  for new closure property proofs

25
Comparing language classes

• Showing LFSA is a subset of REC

26
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 program P from FSA M
• Argue P decides L
• There exists a program P which decides L
• L is recursive

27
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 decides L
• There exists a program P which decides L
• L is recursive

LFSA
REC
28
Comparison
29
Construction
FSA M
Program P
Construction Algorithm

• The construction is again an algorithm A
• Input to A FSA M
• Output of A C program P such that P decides
  L(M)
• Informal description of algorithm
• Implement FSA M as C program using switch
  statements, etc.

30
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?