1. Finite Automata & Regular Languages Sipser, Chapter 1

2. Deterministic Finite Automata A DFA or deterministic finite automaton M is a 5-tuple, M = (Q, , , q 0, F), where: Q is a finite set of states of M  is the finite input alphabet of M  : Q    Q is the state transition function q 0 is the start state of M F  Q is the set of accepting states or final states of M

3. DFA Example State diagram Q = { q 0, q 1 }  = { 0, 1 } F = { q 1 } q0q0 q1q1 0 1 0 1M  01 q0q0 q0q0 q1q1 q1q1 q1q1 q0q0 State Table

4. State table & state transition function State table State transition function  (q 0, 0) = q 0,  (q 0, 1) = q 1  (q 1, 0) = q 1,  (q 1, 1) = q 0  01 q0q0 q0q0 q1q1 q1q1 q1q1 q0q0

5. State transitions If q, q’  Q, s  , and  (q, s) = q’, then we say that q’ is an s-successor of q, or there is a transition from q to q’ on input s, and we write q  s q’ Example: since  (q 0, 1) = q 1, then there is a transition from q 0 to q 1 on input 1, and we write q 0  1 q 1.

6. State sequences If a string of input symbols w = s 0 s 1 s 2 … s k-1 takes M from initial state q 0 to state q k, namely q 0  s0 q 1  s1 q 2  s2 q 3  …  s[k-1] q k then we say that q k is a w-successor of q 0, and write q 0  w q k. Also q 0 q 1 q 2 … q k is called an admissible state sequence for w.

7. Strings accepted by a DFA Let M = (Q, , , q 0, F) be a DFA, and w = s 0 s 1 s 2 … s k-1   * be a string over alphabet . Then M accepts w if there exists an admissible state sequence q 0 q 1 q 2 … q k for w, starting at initial state q 0 and ending with state q k, where q k  F. That is, M accepts input string w if M ends up in one of the final states.

8. Language recognized by a DFA The language L(M) that is recognized by a DFA, M = (Q, , , q 0, F), is the set of all strings accepted by M. That is, L(M) = { w   * | M accepts w } = { w   * | q 0  w q k, q k  F }. Example: For the previous DFA, L(M) is the set of all strings of 0s and 1s with odd parity, that is, odd number of 1s.

9. DFA Example 2 Recognizer for 11*01* B D A C 1 1 0 1 0 0 0,1 Trap

10. DFA Example 2 M = (Q, , , q 0, F), L(M) = 11*01* Q = { q 0 =A, B, C, D }  = { 0, 1 } F = { C }  01 ADB BCB CDC DDD

11. DFA Example 3 Modulo 3 counter A B C 1 1 1,R 2,R 2 2 0,R 0 0

12. DFA Example 3 M = (Q, , , q 0, F) Q = { q 0 =A, B, C }  = { 0, 1, 2, R } F = { A }  012R AABCA BBCAA CCABA

13. Regular Languages A language L   * is called regular if there exists a DFA M such that L(M)=L. Earlier, we defined a language L   * as regular if there exists a T3 or regular (left-linear or right-linear) grammar G such that L(G)=L. We shall prove that these two definitions are equivalent.

14. Operations on Regular Languages Let A and B be regular languages: Union: A  B = { x | x  A or x  B } Concatenation: AB = { xy | x  A and y  B }. Kleene Closure (A-star) A* = {x 1 x 2 x 3... x k | k  0 and x i  A }

15. Examples of regular operations A = { good, bad }, B = { boy, girl } A  B = { good, bad, boy, girl } AB = { goodboy, goodgirl, badboy, badgirl } A* = {, good, bad, goodgood, goodbad, badgood, badbad, … }

16. Closure under Union If A and B are regular languages, then their union, A  B, is a regular language

17. Union Machine M(A  B) q0 q1F q2F p0 p1F p2F M(A) M(B) r0

18. Closure under Concatenation If A and B are regular languages, then their concatenation, AB, is a regular language.

19. Concatenation Machine M(AB)

20. Closure under Kleene Star If A is a regular language, then the Kleene closure of A, A*, is also a regular language

21. Kleene Closure Machine M(A*)

22. NFAs: Nondeterministic Finite Automata Presence of lambda transtitions. May have more than one initial state. On input a, state q may have no transition out. On input a, state q may have more than one transition out.

23. NFAs A nondeterministic finite automaton M is a five-tuple M = ( Q, , R, I, F ), where Q is a finite set of states  is the (finite) input alphabet R is the transition relation, R  Q  Q I  Q is the set of initial states F  Q is the set of final states

24. Example NFAs NFA that recognizes the language 0*1  1*0 NFA that recognizes the language (0  1)*11 (0  1)*

25. Converting NFAs to DFAs Given a NFA, M = (Q, , R, I, F), build a DFA, M’ = (Q’, , , S 0, F’) as follows. The states S 0, S 1, S 2, … of M’ are sets of states of M. The initial state of M’ is obtained by putting together all the initial states of M and all states reachable from those by transitions, and calling this set S 0, the initial state of M’

26. Converting NFAs to DFAs For each state S k already in Q’ in M’, and for each input symbol a  , put together into a set S j all states of M reachable from each state in S k on input a. This set S j may or may not yet already be in Q’. Also it may be the empty set . Add to  the transition from S k to S j on input a. Since there can only be a finite number of subsets of states of M, this procedure will stop after a finite number of steps.

27. Example conversions Convert the NFA for the language (0  1)*00  (0  1)*11 to a DFA 0,1 00 1 1 A B C D E F

28. State transition table of NFA 01 AA,BA- BC-- C--- DDD,E- E-F- F---

29. State table of DFA 01 A,DA,B,DA,D,E A,B,DA,B,C,DA,D,E A,B,DA,D,E,F A,B,C,D A,D,E A,D,E,FA,B,DA,D,E,F

30. State diagram of DFA 0 1 0 1 10 0 1 0 1 AD ABD ADE ABCD ADEF

31. Regular Expressions (r.e.) If a  , then the set a = {a} is a r.e. The set = { } is a r.e. The set  = { } is a r.e. If R and S are r.e., then (R  S) is a r.e. If R and S are r.e., then (RS) is a r.e. If R is a r.e., then ( R )* is a r.e. Any r.e. is obtained by a finite application of the above rules.

32. REs and Regular Languages R.E.s are shorthand notation for regular languages.

33. Regex: REs in Unix [a-f], [^a-f] R*, R+, R? {R} RS R|S

34. Minimization of DFAs Subset construction (Myhill-Nerode Theorem)

35. NFAs, DFAs, & Lexical Analyzer Generators Sec 3.6: Finite Automata, Aho, Sethi, Ullman, “Compilers: P.T.T” Sec 3.7: From REs to NFAs (Thompson’s Construction) Sec 3.8: Design of a Lexical Analyzer generator Sec 3.9: Optimization of DFA-based Lexical Analyzers