1. COMP3190: Principle of Programming Languages DFA and its equivalent, scanner

2. - 1 - Outline v DFA & NFA »DFA »NFA »NFA →DFA »Minimize DFA v Regular expression v Regular languages v Scanner

3. - 2 - Example of DFA q1 q2 1 0 01 δ01 q1 q2 q1q2

4. - 3 - Deterministic Finite Automata (DFA) v 5-tuple: »Q: finite set of states »Σ: finite set of “letters” (alphabet) »δ: Q × Σ → Q (transition function) »q 0 : start state (in Q) »F : set of accept states (subset of Q) v Acceptance: Given an input string, it is consumed with the automata in a final state.

5. - 4 - Another Example of a DFA S q1 q2 r1 r2 a b a ab b b ab a

6. - 5 - Outline v DFA & NFA »DFA »NFA »NFA →DFA »Minimize DFA v Regular expression v Regular languages v Context free languages &PDA v Scanner v Parser

7. - 6 - Non-deterministic Finite Automata (NFA) Transition function is different v δ: Q × Σ ε → P(Q) v P(Q) is the powerset of Q (set of all subsets) v Σ ε is the union of Σ and the special symbol ε (denoting empty) String is accepted if there is at least one path leading to an accept state, and input consumed.

8. - 7 - Example of an NFA q1q2q3q4 0, 1 1 0, ε1 0, 1 δ01ε q1{q1}{q1, q2} q2{q3} q3{q4} q4{q4} What strings does this NFA accept?

9. - 8 - Outline v DFA & NFA »DFA »NFA »NFA →DFA »Minimize DFA v Regular expression v Regular languages v Context free languages &PDA v Scanner v Parser

10. - 9 - Converting an NFA to a DFA v For set of states S,  - closure(S) is the set of states that can be reached from S without consuming any input. v For a set of states S, DFAedge(s, c) is the set of states that can be reached from S by consuming input symbol c. v Each set of NFA states corresponds to one DFA state (hence at most 2 n states).

11. - 10 - v  -closure({1})={1 ， 2}=I J={5 ， 4 ， 3}  -closure(J)=  -closure({5 ， 4 ， 3}) ={5 ， 4 ， 3 ， 6 ， 2 ， 7 ， 8} 6 1 a  23 4 5 7 8 a a    

12. - 11 - IIaIa IbIb {X,5,1}{5,3,1}{5,4,1} {5,3,1}{5,2,3,1,6,Y}{5,4,1} {5,3,1}{5,2,4,1,6,Y} {5,2,3,1,6,Y} {5,4,6,1,Y} {5,3,6,1,Y}{5,2,4,1,6,Y} {5,3,6,1,Y}{5,2,4,1,6,Y} {5,3,6,1,Y}{5,2,3,1,6,Y}{5,4,6,1,Y} X Y  51 4 2 3 6 a b   a b a b a b

13. - 12 - Iab 012 132 214 334 465 565 634 0 1 2 3 5 4 6 a ab b b a b a a b a b a b

14. - 13 - Convert NFA to DFA v NFA DFA

15. - 14 - NFA to DFA Exercises v Convert the following NFA’s to DFA’s 15 possible states on this second one (might be easier to represent in table format)

16. - 15 - Outline v DFA & NFA »DFA »NFA »NFA →DFA »Minimize DFA v Regular expression v Regular languages v Scanner

17. - 16 - Equivalent States. Example 16 Consider the accept states c and g. They are both sinks meaning that any string which ever reaches them is guaranteed to be accepted later. Q: Do we need both states? a b 1 0,1 e c g f 0 0 0 1 1

18. - 17 - Equivalent States. Example 17 A: No, they can be unified as illustrated below. Q: Can any other states be unified because any subsequent string suffixes produce identical results? a b 1 0,1 e cg f 00 0 1 1

19. - 18 - Equivalent States. Example 18 A: Yes, b and f. Notice that if you’re in b or f then: 1. if string ends, reject in both cases 2. if next character is 0, forever accept in both cases 3. if next character is 1, forever reject in both cases So unify b with f. a b 1 0,1 e cg f 00 0 1 1

20. - 19 - Equivalent States. Example 19 Intuitively two states are equivalent if all subsequent behavior from those states is the same. Q: Come up with a formal characterization of state equivalence. a 0,1 d e 1 cg bf 0 0 1

21. - 20 - Obtaining the minimal equivalent DFA v Initially two equivalence classes: accept and nonaccept states.  Search for an equivalence class C and an input letter a such that with a as input, the states in C make transitions to states in k>1 different equivalence classes. v Partition C into k classes accordingly v Repeat until unable to find a class to partition.

22. - 21 - Minimization Example 21 Split into two teams. ACCEPT vs. NONACCEPT

23. - 22 - Minimization Example 22 0-label doesn’t split up any teams

24. - 23 - Minimization Example 23 1-label splits up NONACCEPT's

25. - 24 - Minimization Example 24 No further splits. HALT! Start team contains original start

26. - 25 - Minimization Example. End Result 25 States of the minimal automata are remaining teams. Edges are consolidated across each team. Accept states are break-offs from original ACCEPT team.

27. - 26 - Minimization Example. Compare 26 100100101 10000

28. - 27 - a e b f c g d h 0 0 0 0 0 0 0 0 1 1 11 1 1 1 1 Class Exercise

29. - 28 - Outline v DFA & NFA v Regular expression v Regular languages v Scanner

30. - 29 - Regular Expressions R is a regular expression if R is v “a” for some a in Σ. v ε (the empty string). v member of the empty language. v the union of two regular expressions. v the concatenation of two regular expr. v R 1 * (Kleene closure: zero or more repetitions of R 1 ).

31. - 30 - Examples of Regular Expressions {0, 1}* 0 all strings that end in 0 {0, 1} 0* string that start with 1 or 0 followed by zero or more 0s. {0, 1}* all strings {0 n 1 n, n >=0} not a regular expression!!!

32. - 31 - Regular Expressions in Java v Ex: pattern match. v Is text in the set described by the pattern? v public class RE { public static void main(String[] args) { String pattern = args[0]; String text = args[1]; System.out.println(text.matches(pattern)); } v % java RE "..oo.oo." bloodroot true v % java RE "[$_A-Za-z][$_A-Za-z0-9]*" ident123 true v % java RE "[a-z]+@([a-z]+\.)+(edu|com)" rs@cs.princeton.edu true

33. - 32 - Regular Expression Notation in Java v a: an ordinary letter v ε: the empty string v M | N: choosing from M or N v MN: concatenation of M and N v M*: zero or more times (Kleene star) v M + : one or more times v M?: zero or one occurence v [a-zA-Z] character set alternation (choice) v. period stands for any single char exc. newline

34. - 33 - Converting a regular expression to a NFA v Empty string v Single character v union operator v Concatenation v Kleene closure

35. - 34 - Regular expression→NFA Language: Strings of 0s and 1s in which the number of 0s is even Regular expression: (1*01*0)*1*

36. - 35 - NFA → DFA Initial classes: {A, B, E}, {C, D} No class requires partitioning! Hence a two-state DFA is obtained.

37. - 36 - Minimize DFA

38. - 37 - Outline v DFA & NFA v Regular expression v Regular languages v Scanner

39. - 38 - Regular language v a formal language »a set of finite sequences of symbols from a finite alphabet v it can be generated by a regular grammar

40. - 39 - Regular Grammar v Later definitions build on earlier ones v Nothing defined in terms of itself (no recursion) Regular grammar for numeric literals in Pascal: digit → 0|1|2|...|8|9 unsigned_integer → digit digit* unsigned_number → unsigned_integer ((. unsigned_integer) | ε ) (( e (+ | - | ε ) unsigned_integer ) | ε )

41. - 40 - Important Theorems v A language is regular if a regular expression describes it. v A language is regular if a finite automata recognizes it. v DFAs and NFAs are equally powerful.

42. - 41 - Outline v DFA & NFA v Regular expression v Regular languages v Scanner

43. - 42 - Scanning v Accept the longest possible token in each invocation of the scanner. v Implementation. »Capture finite automata.  Case(switch) statements.  Table and driver.

44. - 43 - Scanner for Pascal

45. - 44 - Scanner for Pascal(case Statements)

46. - 45 - Scanner Generators v Start with a regular expression. v Construct an NFA from it. v Use a set of subsets construction to obtain an equivalent DFA. v Construct the minimal equivalent DFA.