1. 1 Lecture 16 FSA’s –Defining FSA’s –Computing with FSA’s Defining L(M) –Defining language class LFSA –Comparing LFSA to set of solvable languages (REC)

2. 2 Quick Review What is the functional definition of a configuration? What is a computation?

3. 3 Finite State Automata New Computational Model

4. 4 Observations This Turing machine always moves to the right State 1 is used only to bypass the initial blank Character written is always character read –That is, it is read-only Turing machine returns as soon as blank B is reached 1 switch(current tape cell) { case B: write B; right; goto 2; } 2 switch(current tape cell) { case a: write a; right; goto 3; case b: write b; right; goto 3; case B: write B; stay; return YES; } 3 switch(current tape cell) { case a: write a; right; goto 2; case b: write b; right; goto 2; case B: write B; stay; return NO; }

5. 5 Simplifications Have input start in tape cell 1 Eliminate unnecessary components from model 2 switch(current tape cell) { case a: goto 3 case b: goto 3 case B: return yes } 3 switch (current tape cell) { case a: goto 2 case b: goto 2 case B: return no; } 1 switch(current tape cell) { case B: write B; right; goto 2; } 2 switch(current tape cell) { case a: write a; right; goto 3; case b: write b; right; goto 3; case B: write B; stay; return YES; } 3 switch(current tape cell) { case a: write a; right; goto 2; case b: write b; right; goto 2; case B: write B; stay; return NO; }

6. 6 New model of computation FSA M=(Q, ,q 0,A,  ) –Q = set of states = {1,2} –  = character set = {a,b} don’t need B as we see below also don’t need  since FSA is read only –q 0 = 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 –  = state transition function 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; }

7. 7 Textual representations of  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; } 1 2 ab 11 22  (1,a) = 2,  (1,b)=2,  (2,a)=1,  (2,b) = 1 {(1,a,2), (1,b,2), (2,a,1), (2,b,1)}

8. 8 Transition diagrams 1 2 a,b 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; } Note, this transition diagram represents all 5 components of an FSA, not just the transition function 

9. 9 Exercise FSA M = (Q, , q 0, A,  ) –Q = {1, 2, 3} –  = {a, b} –q 0 = 1 –A = {2,3} –  : {  (1,a) = 1,  (1,b) = 2,  (2,a)= 2,  (2,b) = 3,  (3,a) = 3,  (3,b) = 1} Draw this FSA as a transition diagram

10. 10 Transition Diagram 1 2 3 a a a b b b

11. 11 Computing with FSA’s

12. 12 Computation Example (1, aabbaa) (1,abbaa) (1,bbaa) (2,baa) (3,aa) (3,a) (3  1 2 3 a a a b b b Input: aabbaa

13. 13 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

14. 14 Given an FSA M and an input string x, what is the initial configuration of the computation of M on x? –(q 0,x) –Examples x = aabbaa (1, aabbaa) x = abab (1, abab) x = (1, ) Initial Configuration 1 2 3 a a a b b b FSA M

15. 15 (1, aabbaa) |- M (1, abbaa) –config 1 “yields” config 2 in one step using FSA M (1,aabbaa) |- M (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  –There must always be one and only one next configuration If not, M is not an FSA Definition of |- M 1 2 3 a a a b b b 3 FSA M *

16. 16 Halting configuration –(q, ) –Examples (1, ) (3, ) Accepting Configuration –State in halting configuration is in A Rejecting Configuration –State in halting configuration is not in A Halting Configurations 1 2 3 a a a b b b FSA M

17. 17 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 (q 0, x) |- M (q, ) where q is in A –M rejects x M rejects x iff the computation of M on x ends up in a rejecting configuration (q 0, x) |- M (q, ) where q is not in A –M does not loop or crash on x There is always one and only one next configuration. Tape head always moves right one cell until EOF FSA M on x b b b a a a FSA M * *

18. 18 –For the following input strings, does M accept or reject? aa aabba aab babbb Examples b b b a a a FSA M

19. 19 Notation from the book  (q, c) = p  k (q, x) = p –k is the length of x  * (q, x) = p Examples –  (1, a) = 1 –  (1, b) = 2 –  4 (1, abbb) = 1 –  * (1, abbb) = 1 –   (2, baaaaa) = 3 Definition of  * (q, x) 1 2 3 a a a b b b FSA M

20. 20 L(M) or Y(M) –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. L(M) and LFSA b b b a a a FSA M

21. 21 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

22. 22 Comparing language classes Showing LFSA is a subset of REC, the set of solvable languages

23. 23 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

24. 24 Visualization LFSA REC FSA’s C ++ Programs L L M P 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

25. 25 Construction 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) –Informal description of algorithm Implement FSA M as C ++ program using switch statements, etc. Construction Algorithm FSA M Program P

26. 26 Comparing computational models The previous slides show one method for comparing the relative power of two different computational models –Computational model CM 1 is at least as general or powerful as computational model CM 2 if Any program P 2 from computational model CM 2 can be converted into an equivalent program P 1 in computational model CM 1. –Question: How can we show two computational models are equivalent?