Recap from Last Time

Transcription

1 Regular Expressions

2 Recap from Last Time

3 Regular Languages A language L is a regular language if there is a DFA D such that L( D) = L. Theorem: The following are equivalent: L is a regular language. There is a DFA for L. There is an NFA for L.

4 The Union of Two Languages If L1 and L 2 are languages over the alphabet Σ, the language L 1 L 2 is the language of all strings in at least one of the two languages. If L1 and L 2 are regular languages, is L 1 L 2? ε Machine for L 1 Machine for L 1 L 2 ε Machine for L 2

5 Concatenation Example Let Σ = { a, b,, z, A, B,, Z } and consider these languages over Σ: Noun = { Puppy, Rainbow, Whale, } Verb = { Hugs, Juggles, Loves, } The = { The } The language TheNounVerbTheNoun is { ThePuppyHugsTheWhale, TheWhaleLovesTheRainbow, TheRainbowJugglesTheRainbow, }

6 Concatenating Regular Languages

7 Concatenating Regular Languages Machine for L 1

8 Concatenating Regular Languages Machine for L 1 Machine for L 2

9 Concatenating Regular Languages ε ε Machine for L 1 ε Machine for L 2

10 Concatenating Regular Languages ε ε Machine for L 1 ε Machine for L 2

11 Concatenating Regular Languages ε ε ε Machine for L 1 Machine for L 2 Machine for L 1 L 2

12 The Kleene Closure An important operation on languages is the Kleene Closure, which is defined as Mathematically: L * = L i i = 0 w L* iff n N. w L n Intuitively, all possible ways of concatenating any number of copies of strings in L together.

13 The Kleene Star Machine for L

14 The Kleene Star ε Machine for L

15 The Kleene Star ε Machine for L

16 The Kleene Star ε ε ε Machine for L

17 The Kleene Star ε ε ε Machine for L

18 The Kleene Star ε ε ε Machine for L Machine for L*

19 Another View of Regular Languages

20 Rethinking Regular Languages We currently have several tools for showing a language is regular. Construct a DFA for it. Construct an NFA for it. Apply closure properties to existing languages. We have not spoken much of this last idea.

21 Constructing Regular Languages Idea: Build up all regular languages as follows: Start with a small set of simple languages we already know to be regular. Using closure properties, combine these simple languages together to form more elaborate languages. A bottom-up approach to the regular languages.

22 Regular Expressions Regular expressions are a descriptive format used compactly describe a language. Used extensively in software systems for string processing and as the basis for tools like grep and flex. Conceptually: regular languages are strings describing how to assemble a larger language out of smaller pieces.

23 Atomic Regular Expressions The regular expressions begin with three simple building blocks. The symbol Ø is a regular expression that represents the empty language Ø. The symbol ε is a regular expression that represents the language { ε } This is not the same as Ø! For any a Σ, the symbol a is a regular expression for the language { a }

24 Compound Regular Expressions We can combine together existing regular expressions in four ways. If R1 and R 2 are regular expressions, R 1 R 2 is a regular expression for the concatenation of the languages of R 1 and R 2. If R1 and R 2 are regular expressions, R 1 R 2 is a regular expression for the union of the languages of R 1 and R 2. If R is a regular expression, R* is a regular expression for the Kleene closure of the language of R. If R is a regular expression, (R) is a regular expression with the same meaning as R.

25 Operator Precedence Regular expression operator precedence: (R) R* R 1 R 2 R 1 R 2 So ab*c d is parsed as ((a(b*))c) d

26 Regular Expression Examples The regular expression trick treat represents the regular language { trick, treat } The regular expression booo* represents the regular language { boo, booo, boooo, } The regular expression candy!(candy!)* represents the regular language { candy!, candy!candy!, candy!candy!candy!, }

27 Regular Expressions, Formally The language of a regular expression is the language described by that regular expression. Formally: L(ε) = {ε} L(Ø) = Ø L(a) = {a} L(R1 R 2 ) = L( R 1 ) L( R 2 ) L(R1 R 2 ) = L( R 1 ) L( R 2 ) L(R*) = L( R)* L((R)) = L( R) Worthwhile Worthwhile activity: activity: Apply Apply this this recursive recursive definition definition to to a(b c)((d)) and and see see what what you you get. get.

28 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains 00 as a substring }

29 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains 00 as a substring } (0 1)*00(0 1)*

30 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains 00 as a substring } (0 1)*00(0 1)*

31 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains 00 as a substring } (0 1)*00(0 1)*

32 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains 00 as a substring } (0 1)*00(0 1)*

33 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains 00 as a substring } Σ*00Σ*

34 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 }

35 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 }

36 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 } The The length of of a string w is is denoted w w

37 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 }

38 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 } ΣΣΣΣ

39 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 } ΣΣΣΣ

40 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 } ΣΣΣΣ

41 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 } ΣΣΣΣ

42 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 } Σ

43 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w = 4 } Σ

44 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains at most one 0 }

45 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains at most one 0 } 1*(0 ε)1*

46 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains at most one 0 } 1*(0 ε)1*

47 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains at most one 0 } 1*(0 ε)1*

48 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains at most one 0 } 1*(0 ε)1*

49 Regular Expressions are Awesome Let Σ = {0, 1} Let L = { w Σ* w contains at most one 0 } 1*0?1*

50 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses:

51 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: aa*.aa* (.aa*)*

52 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: aa*.aa* (.aa*)* cs103@cs.stanford.edu first.middle.last@mail.site.org barack.obama@whitehouse.gov

53 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: aa*.aa* (.aa*)* cs103@cs.stanford.edu first.middle.last@mail.site.org barack.obama@whitehouse.gov

54 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: aa*.aa* (.aa*)* cs103@cs.stanford.edu first.middle.last@mail.site.org barack.obama@whitehouse.gov

55 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: aa*.aa* (.aa*)* cs103@cs.stanford.edu first.middle.last@mail.site.org barack.obama@whitehouse.gov

56 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: a + (.aa*)*@ aa*.aa* (.aa*)* cs103@cs.stanford.edu first.middle.last@mail.site.org barack.obama@whitehouse.gov

57 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: a + (.a + a +.a + (.a + )* cs103@cs.stanford.edu first.middle.last@mail.site.org barack.obama@whitehouse.gov

58 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: a + (.a + a +.a + (.a + )* cs103@cs.stanford.edu first.middle.last@mail.site.org barack.obama@whitehouse.gov

59 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: a + (.a + a + (.a + ) + cs103@cs.stanford.edu first.middle.last@mail.site.org barack.obama@whitehouse.gov

60 Regular Expressions are Awesome Let Σ = { }, where a represents some letter. Regular expression for addresses: a + (.a + )*@a + (.a + ) + cs103@cs.stanford.edu first.middle.last@mail.site.org barack.obama@whitehouse.gov

61 Regular Expressions are Awesome a + (.a + )*@a + (.a + ) q 2. a q 7. a q 0 a q q 3 a q 04. q 5 a q 6 a a a

62 Shorthand Summary R n is shorthand for RR R (n times). Σ is shorthand for any character in Σ. R? is shorthand for (R ε), meaning zero or one copies of R. R+ is shorthand for RR*, meaning one or more copies of R.

63 Time-Out for Announcements!

64 Upcoming Talk WiCS is hosting a talk by Yoky Matsuoka, VP of Technology at Nest Labs and cofounder of Google[x]. Before that, she was a professor of CS, neuroscience, and ME. Coming up next Thursday, November 6 at 4PM at Braun Auditorium. RSVP requested:

65 STEM Fellows Program [T]he Stanford Undergraduate STEM Fellows Program provides support to students who will promote the diversity (broadly defined) of the future professoriate. The program [ seeks] to increase the number of PhDs earned by under-represented groups in the areas of science, technology, engineering, and math. Deadline is December 8, but I'd encourage applying early. Details online at fellowships/fellowships-listing/stanford-undergraduate -stem-fellows-program

66 Problem Set Four Solutions PS4 solutions will be available outside of class today and in the filing cabinet after that. SCPD students: you should receive them soon. Want older solution sets? Pick them up soon before they get recycled!

67 Order in a World of Chaos Please keep the box of exams alphabetized. Everyone pays if even a small number of people scramble the exams.

68 Your Questions

69 I've noticed that you're very passionate about diversity in CS. What advice would you have for someone who is part of a minority and is about to have a job/internship in an environment that is not likely to be diverse?

70 In your opinion, what's the biggest number?

71 What do you do in your free time?

72 Why don't we have a class called Data Structures? Is 106B/X our equivalent of this? Recruiters and interviewers ask me why I haven't taken data structures all the time and I never know how to respond.

73 Back to CS103!

74 The Power of Regular Expressions Theorem: If R is a regular expression, then L( R) is regular. Proof idea: Show how to convert a regular expression into an NFA.

75 A Marvelous Construction The following theorem proves the language of any regular expression is regular: Theorem: For any regular expression R, there is an NFA N such that L(R) = L( N) N has exactly one accepting state. N has no transitions into its state. N has no transitions out of its accepting state.

76 A Marvelous Construction The following theorem proves the language of any regular expression is regular: Theorem: For any regular expression R, there is an NFA N such that L(R) = L( N) N has exactly one accepting state. N has no transitions into its state. N has no transitions out of its accepting state.

77 A Marvelous Construction The following theorem proves These the language of These are are stronger stronger any regular expression is regular: Theorem: For any regular expression R, there is an NFA N such that L(R) = L( N) N has exactly one accepting state. requirements requirements than than are are necessary necessary for for a a normal normal NFA. NFA. We We enforce enforce these these rules rules to to simplify simplify the the construction. construction. N has no transitions into its state. N has no transitions out of its accepting state.

78 Base Cases ε Automaton for ε Automaton for Ø a Automaton for single character a

79 Construction for R 1 R 2

80 Construction for R 1 R 2 Machine for R 1 Machine for R 2

81 Construction for R 1 R 2 Machine for R 1 Machine for R 2

82 Construction for R 1 R 2 ε Machine for R 1 Machine for R 2

83 Construction for R 1 R 2 ε Machine for R 1 Machine for R 2

84 Construction for R 1 R 2

85 Construction for R 1 R 2 Machine for R 1 Machine for R 2

86 Construction for R 1 R 2 Machine for R 1 Machine for R 2

87 Construction for R 1 R 2 ε Machine for R 1 ε Machine for R 2

88 Construction for R 1 R 2 ε Machine for R 1 ε Machine for R 2

89 Construction for R 1 R 2 ε ε Machine for R 1 ε ε Machine for R 2

90 Construction for R 1 R 2 ε ε Machine for R 1 ε ε Machine for R 2

91 Construction for R*

92 Construction for R* Machine for R

93 Construction for R* Machine for R

94 Construction for R* Machine for R ε

95 Construction for R* ε ε Machine for R ε

96 Construction for R* ε ε ε Machine for R ε

97 Construction for R* ε ε ε Machine for R ε

98 Why This Matters Many software tools work by matching regular expressions against text. One possible algorithm for doing so: Convert the regular expression to an NFA. (Optionally) Convert the NFA to a DFA using the subset construction. Run the text through the finite automaton and look for matches. Runs extremely quickly!

99 The Power of Regular Expressions Theorem: If L is a regular language, then there is a regular expression for L. This is not obvious! Proof idea: Show how to convert an arbitrary NFA into a regular expression.

100 From NFAs to Regular Expressions s 1, s 2,, s n

101 From NFAs to Regular Expressions s 1, s 2,, s n Regular expression: (s 1 s 2 s n )*

102 From NFAs to Regular Expressions s 1 s 2 s n Regular expression: (s 1 s 2 s n )*

103 From NFAs to Regular Expressions s 1 s 2 s n Regular expression: (s 1 s 2 s n )* Key Key idea: idea: Label Label transitions transitions with with arbitrary arbitrary regular regular expressions. expressions.

104 From NFAs to Regular Expressions

105 From NFAs to Regular Expressions R Regular expression: R

106 From NFAs to Regular Expressions R Regular expression: R Key Key idea: idea: If If we we can can convert convert any any NFA NFA into into something something that that looks looks like like this, this, we we can can easily easily read read off off the the regular regular expression. expression.

107 From NFAs to Regular Expressions R Regular expression: R s 1 s 2 s n

108 From NFAs to Regular Expressions R Regular expression: R (s 1 s 2 s n )*

109 From NFAs to Regular Expressions R Regular expression: R (s 1 s 2 s n )* Regular expression: (s 1 s 2 s n )*

110 From NFAs to Regular Expressions R Regular expression: R

111 From NFAs to Regular Expressions R Regular expression: R s 1 s 2 s n

112 From NFAs to Regular Expressions R Regular expression: R Ø

113 From NFAs to Regular Expressions R Regular expression: R Ø Regular expression: Ø

114 From NFAs to Regular Expressions R Regular expression: R

115 From NFAs to Regular Expressions R Regular expression: R R 11 R 22 R 12 R q 21 2 q 1

116 From NFAs to Regular Expressions R Regular expression: R R 11 * R 12 (R 22 R 21 R 11 *R 12 )* q 1 q 2

117 From NFAs to Regular Expressions R Regular expression: R R 11 * R 12 (R 22 R 21 R 11 *R 12 )* q 1 q 2

118 From NFAs to Regular Expressions R 11 R 22 R 12 q 1 R q 21 2

119 From NFAs to Regular Expressions R 11 R 22 R 12 q s q 1 q 2 R 21 q f

120 From NFAs to Regular Expressions R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f

121 From NFAs to Regular Expressions R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f

122 From NFAs to Regular Expressions R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f

123 From NFAs to Regular Expressions R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f Could Could we we eliminate this this state state from from the the NFA? NFA?

124 From NFAs to Regular Expressions R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f

125 From NFAs to Regular Expressions R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f

126 From NFAs to Regular Expressions ε R 11 * R 12 R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f Note: Note: We're We're using using concatenation concatenation and and Kleene Kleene closure closure in in order order to to skip skip this this state. state.

127 From NFAs to Regular Expressions ε R 11 * R 12 R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f

128 From NFAs to Regular Expressions ε R 11 * R 12 R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f

129 From NFAs to Regular Expressions ε R 11 * R 12 R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f

130 From NFAs to Regular Expressions ε R 11 * R 12 R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f R 21 R 11 * R 12

131 From NFAs to Regular Expressions ε R 11 * R 12 R 11 R 22 R 12 ε ε q s q 1 q 2 R 21 q f R 21 R 11 * R 12

132 From NFAs to Regular Expressions ε R 11 * R 12 R 22 q s q 2 ε q f R 21 R 11 * R 12

133 From NFAs to Regular Expressions R 11 * R 12 R 22 q s q 2 ε q f R 21 R 11 * R 12

134 From NFAs to Regular Expressions R 11 * R 12 q s q 2 ε q f R 22 R 21 R 11 * R 12 Note: Note: We're We're using using union union to to combine combine these these transitions transitions together. together.

135 From NFAs to Regular Expressions q s R 11 * R 12 q 2 ε q f R 22 R 21 R 11 * R 12

136 From NFAs to Regular Expressions q s R 11 * R 12 q 2 ε q f R 22 R 21 R 11 * R 12

137 From NFAs to Regular Expressions q s R 11 * R 12 q 2 ε q f R 22 R 21 R 11 * R 12

138 From NFAs to Regular Expressions q s R 11 * R 12 q 2 ε q f R 22 R 21 R 11 * R 12

139 From NFAs to Regular Expressions R 11 * R 12 (R 22 R 21 R 11 *R 12 )* ε q s R 11 * R 12 q 2 ε q f R 22 R 21 R 11 * R 12

140 From NFAs to Regular Expressions R 11 * R 12 (R 22 R 21 R 11 *R 12 )* ε q s R 11 * R 12 q 2 ε q f R 22 R 21 R 11 * R 12

141 From NFAs to Regular Expressions R 11 * R 12 (R 22 R 21 R 11 *R 12 )* ε q s q f

142 From NFAs to Regular Expressions R 11 * R 12 (R 22 R 21 R 11 *R 12 )* q s q f

143 From NFAs to Regular Expressions R 11 * R 12 (R 22 R 21 R 11 *R 12 )* q s q f

144 From NFAs to Regular Expressions R 11 * R 12 (R 22 R 21 R 11 *R 12 )* q s q f R 11 R 22 R 12 q 1 R q 21 2

145 The Construction at a Glance Start with an NFA for the language L. Add a new state qs and accept state q f to the NFA. Add ε-transitions from each original accepting state to q f, then mark them as not accepting. Repeatedly remove states other than qs and q f from the NFA by shortcutting them until only two states remain: q s and q f. The transition from qs to q f is then a regular expression for the NFA.

146 Our Transformations direct conversion state elimination DFA NFA Regexp subset construction recursive transform

147 Theorem: The following are all equivalent: L is a regular language. There is a DFA D such that L( D) = L. There is an NFA N such that L( N) = L. There is a regular expression R such that L( R) = L.

148 Next Time Applications of Regular Languages Answering so what? Intuiting Regular Languages What makes a language regular? The Myhill-Nerode Theorem The limits of regular languages.