1. CS 3240 – Chapter 3

2.  How would you delete all C++ files from a directory from the command line?  How about all PowerPoint files that start with the letter a?  PowerPoint file names that contain the string 3240? 2CS 3240 - Regular Languages and Grammars

3.  *.cpp  a*.ppt  *3240*.ppt  These are wildcard expressions  Not bona fide regular expressions 3CS 3240 - Regular Languages and Grammars

4. LanguageMachineGrammar RegularFinite AutomatonRegular Expression, Regular Grammar Context-FreePushdown AutomatonContext-Free Grammar Recursively Enumerable Turing MachineUnrestricted Phrase- Structure Grammar 4CS 3240 - Introduction

5.  Text patterns that represent regular languages  We’ll show shortly that for every regular expression there is a finite automaton that accepts that language  And vice-versa  The operators are:  ( ) (Grouping)  * (Kleene Star)  + (Union)  xy(Concatenation) 5CS 3240 - Regular Languages and Grammars

6.  1) Specify base case(s)  2) Show how to generate other elements  Rules that use what’s in the set already  Example: Non-negative multiples of 5, F  1) 0, 5 is in F  2) For x, y in F, then x + y is in F  Alternate definition:  1) 0 is in F  2) For x in F, so is x + 5 CS 3240 - Regular Languages and Grammars6

7.  Base cases:  The empty set: ∅ or ( )  The empty string: λ  Any letter in Σ  Recursive rules: Given regular expressions r, r 1, r 2 :  (r)(Grouping)  r * (Kleene Star)  r 1 + r 2 (Union)  r 1 r 2 (Concatenation) 7CS 3240 - Regular Languages and Grammars

8.  All strings beginning with a:  a(a + b) *  All strings containing aba:  (a + b) * aba(a + b) *  All strings of even length:  ((a + b)(a + b)) * = (aa + ba + ab + bb) * = ((a + b) 2 ) *  All strings of odd length:  (a+b)((a + b) 2 ) *  Valid decimal integers in C:  (1+2+3+4+5+6+7+8+9)(0+1+2+3+4+5+6+7+8+9) * 8CS 3240 - Regular Languages and Grammars

9.  Put anything you want on an edge  Use an “else” branch as well  [0-9] (if-branch)  ~[0-9] or [^(0-9)] or else CS 3240 - Regular Languages and Grammars9 (Decimal integers)

10.  (b * ab * ab * ab * + b) *  = b * (ab * ab * ab * ) *  = b * + (b * ab * ab * ab * ) *  (a(a+bb) * ) *  ((a + b)a) * 10CS 3240 - Regular Languages and Grammars

11.  L( ∅ ) = ∅  L(λ) = λ  L(c) = c, for c ∊ Σ  L((r)) = L(r)  L(r * ) = L(r) *  L(r 1 + r 2 ) = L(r 1 ) ∪ L(r 2 )  L(r 1 r 2 ) = L(r 1 )L(r 2 ) 11CS 3240 - Regular Languages and Grammars

12. 12  r+s = s+r  (r+s)+t = r+(s+t)  r+r = r  r + ∅ = r  (rs)t = r(st)  rλ = λr = r  r ∅ = ∅ r = ∅  r(s+t) = rs+rt  (r+s)t = rt+st

13. 1. For every regular expression there is an associated NFA that accepts the same language  And therefore a DFA, by conversion 2. For every FA (either NFA or DFA) there is a regular expression that represents the same language 13CS 3240 - Regular Languages and Grammars

14.  We will show how to convert each element of the definition of regular expressions to an NFA  This is sufficient!  And shows the convenience of recursive definitions (review slide 7 now)  because if we can give a machine for every case in the definition of REs, we are done! 14CS 3240 - Regular Languages and Grammars

15. Empty Language Empty String Single Character 15CS 3240 - Regular Languages and Grammars

16. 16CS 3240 - Regular Languages and Grammars

17.  Just draw the lambdas from a new start state to the start states of each machine  Remove the start notation from the original start states  (No need to have a new final state) CS 3240 - Regular Languages and Grammars17

18. 18CS 3240 - Regular Languages and Grammars

19.  1) Just draw a lambda from each final state of the first machine to the start state of the second machine  2) remove the acceptability of those final states of the first machine CS 3240 - Regular Languages and Grammars19

20. 20CS 3240 - Regular Languages and Grammars

21.  We need to do two things:  1) Add the empty string, if needed  2) Loop from each final state back to the start state  Procedure:  1) If the empty string is not accepted, create a new start state which accepts, and connect to the original start state with λ  2) Add a λ-edge from each final state to the original (or the new) start state CS 3240 - Regular Languages and Grammars21

22.  Draw NFAs for the REs on slides 8 and 9 CS 3240 - Regular Languages and Grammars22

23.  First remove all jails  Then, if needed, convert the DFA to an equivalent NFA with  A start state with no incoming edges  A single final state with no outgoing edges  Will need lambda transitions for this  Then “eliminate” all but the start and final states  Without changing the language accepted  Using GTGs… 23CS 3240 - Regular Languages and Grammars

24.  Allow regular expressions on the edges Accepts a * + a * (a+b)c * [Note: (c * ) * = c * ] 24CS 3240 - Regular Languages and Grammars

25.  If the start state has an incoming edge (even if it’s a loop), create a new start state with a lambda transition to the old start state: CS 3240 - Regular Languages and Grammars25

26.  If there is more than one final state, or if the single final state has an outgoing edge (even if it’s a loop), create a new final state and link to it with a lambda transition from each final state: CS 3240 - Regular Languages and Grammars26

27.  “Remove” each intermediate state, one at a time: 1. Combine each incoming path with each outgoing path (only “through” paths; not loops) 2. Determine the regular expression equivalent to the combined path through the current state 3. Add an edge with that RE between the incoming state and the outgoing state 4. Repeat until all intermediate states vanish CS 3240 - Regular Languages and Grammars27

28. CS 3240 - Regular Languages and Grammars28

29. CS 3240 - Regular Languages and Grammars29 To eliminate 2: 1-2-1: af * b 1-2-3: af * c 3-2-1: df * b 3-2-3: df * c

30. CS 3240 - Regular Languages and Grammars30 To eliminate 1: 0-1-3: (e+af * b) * (h+af * c) 3-1-3: (i+df * b)(e+af * b) * (h+af * c)

31. CS 3240 - Regular Languages and Grammars31 Eliminate 3 (Final Result): (e+af * b) * (h+af * c)(g+df * c+(i+df * b)(e+af * b) * (h+af * c)) *

32. CS 3240 - Regular Languages and Grammars32

33.  Find a regular expression for the language containing all strings that do not contain the substring aa CS 3240 - Regular Languages and Grammars33

34.  See bypass.docbypass.doc  Shows different possibilities by eliminating states in different orders  But the REs obtained are equivalent ▪ Meaning they represent the same language CS 3240 - Regular Languages and Grammars34

35. LanguageMachineGrammar RegularFinite AutomatonRegular Expression, Regular Grammar Context-FreePushdown AutomatonContext-Free Grammar Recursively Enumerable Turing MachineUnrestricted Phrase- Structure Grammar 35CS 3240 - Introduction

36.  There is a natural correspondence between FAs and grammars  Right-linear Grammars  “Linear” means there is at most one variable on the right-hand side of the rule  “Right-linear” means the variable occurs as the last entry in the rule: ▪ A → abC CS 3240 - Regular Languages and Grammars36

37.  The variables represent states  The right-hand side contains the character(s) on the edge, optionally followed by the target state  The accepting states have a lambda rule CS 3240 - Regular Languages and Grammars37 A → aB | bC | λ B → aA | bD C → aD | bA D → aC | bB

38.  Go to an accepting state with no out-edges CS 3240 - Regular Languages and Grammars38 A → b

39.  S → aaS | bbS | abA | baA | λ  A → aaA | bbA | abS | baS CS 3240 - Regular Languages and Grammars39 a GTG

40.  Construct a regular grammar for the language denoted by aab * a 1. First build a GTG 2. Then map to a right-linear grammar CS 3240 - Regular Languages and Grammars40

41.  S → Xa  X → Xb | aa  How did I come up with this? CS 3240 - Regular Languages and Grammars41

42.  If you have the single variable only at the left ends, you have a left-linear grammar  This is also a regular grammar  We will show how to convert between right- linear and left-linear grammars  We will use two facts to establish the process:  If L is regular, so is L R (Section 2.3, exercise 12)  L(G R ) = L(G) R (obvious, but on next slide…) CS 3240 - Regular Languages and Grammars42

43.  G R means you reverse the right-hand sides of each rule in a grammar, G  The language generated is L(G) R (the reverse of L(G)) CS 3240 - Regular Languages and Grammars43 S → abS | X X → bX | λ (ab) * b * S → Sba | X X → Xb | λ b * (ba) *

44. 1. Convert the right-linear grammar to a GTG 2. “Reverse” the GTG (a la Section 2.3, #12)  Ensure a single final state (use λ if needed)  Interchange the role of the start and final states  Reverse all arrows 3. Convert the reversed GTG to a right-linear grammar 4. Reverse the right-hand sides of each rule to obtain the left-linear grammar CS 3240 - Regular Languages and Grammars44

45. CS 3240 - Regular Languages and Grammars45 A → aB B → abA | b C → bB B → aA A → baB | λ ba(baa) * C → Bb B → Aa A → Bab | λ (aab) * ab (rev)

46.  Reverse the grammar, G, obtaining right- linear grammar, G R, for L(G) R  Convert to GTG  Reverse the GTG  Convert to Right-linear CS 3240 - Regular Languages and Grammars46

47. CS 3240 - Regular Languages and Grammars47