The Three Faces of Regular Languages

1. The Three Faces of Regular Languages September 25, 2001

2. Announcements • OH’s (this week only) • Today 4-5:15 (instead of Thursday) • None on Tue/Wed (he22ld Wed’s OH yesterday) • HW 2 delayed by one week • Now due Tuesday, 10/2 • Anticipate covering all necessary material for HW2 today • Can download egrep for PC’s (included with Cygwin). See the course links page. • HW 3 is still due Thursday, 10/4! • Will try my best not to delay this due date. • Greg Estren will give Thursday’s lecture

3. Agenda • NFA’s • Formal Definition • Closure under regular operations • Union () • Concatenation () • Kleene-* • Kleene-+ • Determinization • Regular Expressions (REX’s) • Formal Definition • Simulation by NFA’s • Simulation of FA’s • Conclusion: FA’s  NFA’s  REX’s

4. 1 1 0 1 0 0,1 0,1 0 NFA’s -Informally The static picture of an NFA is as a graph whose edges are labeled by S and by e (together called Se) and with start vertex q0 and accept states F. EG: Q: Why is this any different for deterministic FA’s? Isn’t an FA just a labeled graph in the same way? e e

5. NFA’s -Informally A: FA’s are labeled graphs. However, determinism gives an extra constraint on the form that the graphs can take. Specifically, d must be a function. Graph theoretically this means that every vertex has exactly one edge of a given label sticking out of it. (Of course, e’s cannot appear either.) Summarizing: any labeled graph you can come up with is an NFA, as long as it only has one start state. Later, even this restriction will be dispensed with.

6. NFA Examples M1: M2: M3: M4: e e 0 0,1 e 1 1

7. NFA’s. Formal Definition. DEF: A nondeterministicfinite automaton (NFA) is encapsulated by M = (Q, S, d, q0, F ) in the same way as an FA, except that d has different domain and codomain. Here, P (Q ) is the power set of Q so that d(q,a) is the set of all endpoints of edges from q which are labeled by a.

8. NFA’s. Formal Definition. e q1 q0 q0 M1: M2: M3: M4: Q: What are d(q0,0), d(q0,1), d(q0,e) in each of M1, M2, M3 and in M4.? q0 e q2 0 q1 0,1 q3 q0 e q2 1 1

9. NFA’s. Formal Definition. e q1 q0 q0 M1: M2: M3: M4: M1: d(q0,0) = d(q0,1) = d(q0,e) =  M2: Same M3: d(q0,0) = d(q0,1) = , d(q0,e) = {q1,q2} M4: d(q0,0)={q1,q3}, d(q0,1)={q2,q3}, d(q0,e)= q0 e q2 0 q1 0,1 q3 q0 e q2 1 1

10. Formal Definition of an NFA:Dynamic Just as with FA’s, there is an implicit auxiliary tape containing the input string which is operated on by the NFA. As opposed to FA’s, NFA’s are parallel machines –able to be in several states at any given instant. The NFA reads the tape from left to right with each new character causing the NFA to go into another set of states. When the string is completely read, the string is accepted depending on whether the NFA’s final configuration contains an accept state.

11. Formal Definition of an NFA:Dynamic DEF: A string u is accepted by an NFA M iff there exists a path starting at q0 which is labeled by u and ends in an accept state. The language accepted byM is the set of all strings which are accepted by M and is denoted by L (M ). Notes: • In computing the label of a path, you should delete all e’s. • The only difference in acceptance for NFA’s vs. FA’s are the words “there exists”. In FA’s the path always exists and is unique.

12. NFA’s. Accepted String Examples. 0 q1 0,1 q3 M4: Q: Which of the following strings is accepted? • e • 0 • 1 • 0111 q0 e q2 1 1

13. NFA’s. Accepted String Examples. 0 q1 0,1 q3 A: • e is rejected. No path labeled by empty string from start state to an accept state. • 0 is accepted. EG the path • 1 is accepted. EG the path • 0111 is accepted. There is only one accepted path: q0 e q2 1 1

14. NFA’s. Regular Operations.Schematic. The red circle stands for the start state q0, the green portion represents the accept states F, and the other states are gray

15. NFA’s. Schematic Union. The union AB is formed by putting the automata in parallel. Create a new start state and connect it to the former start states using e-edges:

16. Union Example L= {x has even length}  {x ends with 11} a e e 1 1 0 d e b f 1 0 0,1 0,1 0 c

17. The Game of e-DETERMINIZE Rules (only large font differs from DETERMINIZE): • The NFA is made up of a team • The referee calls out the input string • Each member of the team is responsible for knowing who they ‘pass the buck’ to. If necessary, turn the buck into referee (in case transition undefined), or spread the buck around to several teammates (if multiple choices). If you are an e-source and you’re holding a buck, make sure that all your e-targets also hold a buck before referee calls out next letter. • Each member of the team is responsible for knowing themselves (know if you are in F ) • At the end of input string, any accept states holding the buck should call out: “ACCEPT” • If no one says ACCEPT, input was rejected.

18. NFA’s. Schematic Concatenation. The concatenation A Bis formed by putting the automata in serial. The start state comes from A while the accept states come from B. The A’s accept states are turned off and connected via e-edges to B ’s start state:

19. Concatenation Example L= {x has even length}  {x ends with 11} 0 1 e 1 0 d e b f 1 0,1 0,1 0 c

20. NFA’s. Schematic Kleene-+. The Kleene-+ A+is formed by creating a feedback loop. The accept states connect to the start state via e-edges:

21. Kleene-+ Example x is a streak of 1 or more 1’s followed by a streak of 2 or more 0’s L = { }+ = {} x starts with 1, ends with 0, and alternates between 1 or more consecutive 1’s and 2 or more consecutive 0’s 1 0 1 0 0 c d e f e

22. NFA’s. Schematic Kleene-*. The construction follows from Kleene-+ construction using the fact that A* is the union of A+ with the empty string. Just create Kleene-+ and add a new start accept state connecting to old start state with an e-edge:

23. Kleene-* Example x is a streak of 1 or more 1’s followed by a streak of 2 or more 0’s L = { }* = {} x starts with 1, ends with 0, and alternates between 1 or more consecutive 1’s and 2 or more consecutive 0’s, ORx is e a e 1 0 1 0 0 c d e f e

24. Closure of NFA’s under Regular Operations The constructions above all show that NFA’s are constructively closed under the regular operations. THM 1: If L1 andL2 are accepted by NFA’s, then so are L1 L2 ,L1 L2, L1+ and L1*. In fact, the accepting NFA’s can be constructed algorithmically in linear time. This is almost what we want. If we can show that all NFA’s can be converted into DFA’s this will show that DFA’s –and hence regular languages– are closed under the regular operations.

25. Regular Expressions We are already familiar with the regular operations. Regular expressions give a way of symbolizing a sequence of regular operations, and therefore a way of generating new languages from old. For example, to generate the finite language {banana,nab}* from the atomic languages {a},{b} and {n} we could do the following: ( ({b}{a}{n}{a}{n}{a})({n}{a}{b}) )* Regular expressions specify the same in a more compact form: (banananab)*

26. Regular Expressions DEF: The set of regular expressions over an alphabet S and the languages in S* which they generate are defined recursively: • Base Cases: Each symbol a S as well as the symbols e and  are regular expressions: • a generates the atomic language L(a ) = { a } • e generates the language L( e) = { e} •  generates the empty language L() = { } =  • Inductive Cases: if r1and r2 are regular expressions so are r1r2, (r1)(r2), (r1)* and (r1)+: • L(r1r2) = L(r1)L(r2), so r1r2 generates the union • L((r1)(r2)) = L(r1)L(r2), so (r1)(r2)is the concatenation • L((r1)*) = L(r1)*, so (r1)*represents the Kleene-* • L((r1)+) = L (r1)+:, so (r1)+represents the Kleene-+

27. Regular Expressions. Table of Operations including UNIX

28. Regular Expressions. Simplifications. Just as algebraic formulas can be simplified by using less parentheses when the order of operations is clear, regular expressions can be simplified. Using the pure definition of regular expressions to express the language {banana,nab}* we would be forced to write something nasty like: ((((b)(a))(n))(((a)(n))(a))(((n)(a))(b)))* Using the operator precedence ordering *,  ,  and the associativity of  allows us to obtain the simpler: (banananab)* This is done in the same way as one would simplify the algebraic expression with re-ordering disallowed: ((((b)(a))(n))(((a)(n))(a))+(((n)(a))(b)))4=(banana+nab)4

29. Regular Expressions. Example. Q: Find a regular expression that generates the language consisting of all bit-strings which contain a streak of seven 0’s or contain two disjoint streaks of three 1’s. Note: A streak of nine 0’s is valid because it contains a sub-streak of seven 0’s. EG: • Legal: 010000000011010, 01110111001, 111111 • Illegal: 11011010101, 10011111001010

30. Regular Expressions. Example. A: (01)*(0713(01)*13)(01)* An even briefer valid answer is: S*(0713S*13)S* The official answer using only the standard regular operations is: (01)*(0000000111(01)*111)(01)* A brief UNIX answer is: (0|1)*(0{7}|1{3}(0|1)*1{3})(0|1)*

31. Regular Expressions. A Language in their Own Right. Regular expressions are just strings. Consequently, the set of regular expressions is a set of strings, so by definition is a language. Q: Supposing that only union, concatenation and Kleene-* are considered. What is the alphabet for the language of regular expressions over the base alphabetS ?

32. Regular Expressions. A Language in their Own Right. A: S{ (, ), , *}

33. REX  NFA Since NFA’s are closed under the regular operations we immediately get: THM 2: Given any regular expression r there is an NFA N which simulates r. I.e. the language accepted by N is precisely the language generated by r so that L(N ) = L(r ). Furthermore, the NFA is constructible in linear time.

34. REX  NFA Proof. The proof works by induction, using the recursive definition of regular expressions. First we need to show how to accept the base case regular expressions aS, e and . These are respectively accepted by the NFA’s: a q0 q1 q0 q0

35. REX  NFA Finally, we need to show how to inductively accept regular expressions formed by using the regular operations. These are just the constructions that we saw before, encapsulated by:

36. REX  NFA. Example. Q: Find an NFA for the regular expression (01)*(0000000111(01)*111)(01)* the previous exercise.

37. REX  NFA. Example. (01)*(0000000111(01)*111)(01)* A: See how the NFA was constructed.

38. REX NFA  FA The fact that regular expressions can be converted into NFA’s means that it makes sense to call the languages accepted by NFA’s “regular”. However, the regular languages were defined to be the languages accepted by FA’s, which are by default, deterministic. It would be nice if NFA’s could be determinized and converted to FA’s, for then the definition of “regular” languages, as being FA-accepted would be justified. Let’s try this next.

39. 0,1 0 a 0,1 0,1 0,1 e d c f 0,1 1 b Determinizing NFA’s Q: Determinize the left-most state of:

40. Determinizing NFA’s A: No problem. Under-deterministic crashes can be fixed by adding a fail sink-state: Q: Now do the same for the start state. 0,1 0 a 0,1 0,1 0,1 e d c f 0,1 0,1 1 b 0,1 hell

41. Determinizing NFA’s A: No such luck!!! In general, over-determinism is much harder to fix. Different sequences of letters create different possible combinations of active states. To determinize, will need to take these combinations into account. INSPIRATION: The game of DETERMINIZE (and e-DETERMINIZE) gives the intuition for how this works!

42. Determinizing NFA’s Recall that in the game, we kept track of active states as the input was being called out. If at the end of the input, one of the active states happened to be an accept state, the input was accepted. Graph theoretically, what the game does is keep track of all endpoints of all possible paths of the prefixes of the input string.

43. 0 0,1 0,1 1 1 0 0 0 1 0 1 Determinizing NFA’s For example, consider the following NFA which reads the input 11000.

44. Determinizing NFA’s 0 0,1 0,1 1 0 1

45. Determinizing NFA’s 0 0,1 0,1 1 0 1

46. Determinizing NFA’s 0 0,1 0,1 1 0 1

47. Determinizing NFA’s 0 0,1 0,1 1 0 1

48. Determinizing NFA’s 0 0,1 0,1 1 0 1 Accepted!

49. Determinizing NFA’s Recall that in the Cartesian product construction, we kept track of two parallel automata by using spliced states. Let’s try to modify this approach for determinizing. Q: How can we remember all the active states in a computation by a single state? 0 0,1 0,1 1 0 1

50. Determinizing NFA’s A: Keep track of all active states by thinking of each set of states as a state in its own right. EG: If the right-most states are q2 and q3 here the active “state” is {q2, q3 }. 0 0,1 0,1 1 0 1