cs 61a cs 98 52
play

CS 61A/CS 98-52 Mehrdad Niknami University of California, Berkeley - PowerPoint PPT Presentation

Mar 27, 2023 •1.01k likes •2.84k views

CS 61A/CS 98-52 Mehrdad Niknami University of California, Berkeley Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 1 / 23 Motivation How would you find a substring inside a string? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 2 / 23

  1. Formal Languages In formal language theory: Alphabet : any set (usually a character set , like English or ASCII) → Often denoted by Σ Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 23

  2. Formal Languages In formal language theory: Alphabet : any set (usually a character set , like English or ASCII) → Often denoted by Σ Letter : an element in the given alphabet , e.g. “ x ” Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 23

  3. Formal Languages In formal language theory: Alphabet : any set (usually a character set , like English or ASCII) → Often denoted by Σ Letter : an element in the given alphabet , e.g. “ x ” String (or word ): finite sequence of letters , e.g. “ hi ” Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 23

  4. Formal Languages In formal language theory: Alphabet : any set (usually a character set , like English or ASCII) → Often denoted by Σ Letter : an element in the given alphabet , e.g. “ x ” String (or word ): finite sequence of letters , e.g. “ hi ” Language : a set of strings , e.g. { “ a ”, “ aa ”, “ aaa ”, . . . } → Often denoted by L Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 23

  5. Formal Languages In formal language theory: Alphabet : any set (usually a character set , like English or ASCII) → Often denoted by Σ Letter : an element in the given alphabet , e.g. “ x ” String (or word ): finite sequence of letters , e.g. “ hi ” Language : a set of strings , e.g. { “ a ”, “ aa ”, “ aaa ”, . . . } → Often denoted by L We might omit the quotes/braces, so we’ll use the following denotations: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 23

  6. Formal Languages In formal language theory: Alphabet : any set (usually a character set , like English or ASCII) → Often denoted by Σ Letter : an element in the given alphabet , e.g. “ x ” String (or word ): finite sequence of letters , e.g. “ hi ” Language : a set of strings , e.g. { “ a ”, “ aa ”, “ aaa ”, . . . } → Often denoted by L We might omit the quotes/braces, so we’ll use the following denotations: ε : empty string (i.e., “”) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 23

  7. Formal Languages In formal language theory: Alphabet : any set (usually a character set , like English or ASCII) → Often denoted by Σ Letter : an element in the given alphabet , e.g. “ x ” String (or word ): finite sequence of letters , e.g. “ hi ” Language : a set of strings , e.g. { “ a ”, “ aa ”, “ aaa ”, . . . } → Often denoted by L We might omit the quotes/braces, so we’ll use the following denotations: ε : empty string (i.e., “”) ∅ : empty language (i.e., empty set {} ) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 5 / 23

  8. Formal Grammars Languages can be infinite, so we can’t always list all the strings in them. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 23

  9. Formal Grammars Languages can be infinite, so we can’t always list all the strings in them. We therefore use grammars to describe languages. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 23

  10. Formal Grammars Languages can be infinite, so we can’t always list all the strings in them. We therefore use grammars to describe languages. For example, this grammar describes L = { “”, “ hi ”, “ hihi ”, . . . } : S → T T → ε T → T "h" "i" Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 23

  11. Formal Grammars Languages can be infinite, so we can’t always list all the strings in them. We therefore use grammars to describe languages. For example, this grammar describes L = { “”, “ hi ”, “ hihi ”, . . . } : S → T T → ε T → T "h" "i" We call S a nonterminal symbol and “ h ” a terminal symbol (i.e., letter). Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 23

  12. Formal Grammars Languages can be infinite, so we can’t always list all the strings in them. We therefore use grammars to describe languages. For example, this grammar describes L = { “”, “ hi ”, “ hihi ”, . . . } : S → T T → ε T → T "h" "i" We call S a nonterminal symbol and “ h ” a terminal symbol (i.e., letter). Each line is a production rule , producing a sentential form on the right. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 23

  13. Formal Grammars Languages can be infinite, so we can’t always list all the strings in them. We therefore use grammars to describe languages. For example, this grammar describes L = { “”, “ hi ”, “ hihi ”, . . . } : S → T T → ε T → T "h" "i" We call S a nonterminal symbol and “ h ” a terminal symbol (i.e., letter). Each line is a production rule , producing a sentential form on the right. To make life easier, we’ll denote these by uppercase and lowercase respectively, omitting quotes and spaces when convenient. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 23

  14. Formal Grammars Languages can be infinite, so we can’t always list all the strings in them. We therefore use grammars to describe languages. For example, this grammar describes L = { “”, “ hi ”, “ hihi ”, . . . } : S → T T → ε T → T "h" "i" We call S a nonterminal symbol and “ h ” a terminal symbol (i.e., letter). Each line is a production rule , producing a sentential form on the right. To make life easier, we’ll denote these by uppercase and lowercase respectively, omitting quotes and spaces when convenient. We then merge and simplify rules via the pipe (OR) symbol: S → S hi | ε Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 6 / 23

  15. Regular Languages Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  16. Regular Languages The following are regular languages over the alphabet Σ: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  17. Regular Languages The following are regular languages over the alphabet Σ: ∅ Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  18. Regular Languages The following are regular languages over the alphabet Σ: ∅ { ε } Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  19. Regular Languages The following are regular languages over the alphabet Σ: ∅ { ε } { σ } ∀ σ ∈ Σ Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  20. Regular Languages The following are regular languages over the alphabet Σ: ∅ { ε } { σ } ∀ σ ∈ Σ The union A ∪ B of any regular languages A and B over Σ Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  21. Regular Languages The following are regular languages over the alphabet Σ: ∅ { ε } { σ } ∀ σ ∈ Σ The union A ∪ B of any regular languages A and B over Σ The concatenation AB of any regular languages A and B over Σ Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  22. Regular Languages The following are regular languages over the alphabet Σ: ∅ { ε } { σ } ∀ σ ∈ Σ The union A ∪ B of any regular languages A and B over Σ The concatenation AB of any regular languages A and B over Σ The repetition (Kleene star) A ∗ of any regular language A over Σ A ∗ = { ε } ∪ A ∪ AA ∪ AAA ∪ . . . Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  23. Regular Languages The following are regular languages over the alphabet Σ: ∅ { ε } { σ } ∀ σ ∈ Σ The union A ∪ B of any regular languages A and B over Σ The concatenation AB of any regular languages A and B over Σ The repetition (Kleene star) A ∗ of any regular language A over Σ A ∗ = { ε } ∪ A ∪ AA ∪ AAA ∪ . . . Notice that all finite languages are regular, but not all infinite languages. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  24. Regular Languages The following are regular languages over the alphabet Σ: ∅ { ε } { σ } ∀ σ ∈ Σ The union A ∪ B of any regular languages A and B over Σ The concatenation AB of any regular languages A and B over Σ The repetition (Kleene star) A ∗ of any regular language A over Σ A ∗ = { ε } ∪ A ∪ AA ∪ AAA ∪ . . . Notice that all finite languages are regular, but not all infinite languages. Regular languages do not allow arbitrary “nesting” (e.g. parens). Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 7 / 23

  25. Regular Grammars Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 8 / 23

  26. Regular Grammars A regular grammar is a grammar in which all productions have at most one nonterminal symbol, all of which appear on either the left or the right. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 8 / 23

  27. Regular Grammars A regular grammar is a grammar in which all productions have at most one nonterminal symbol, all of which appear on either the left or the right. In other words, this is a regular grammar: S → A b c A → S a | ε Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 8 / 23

  28. Regular Grammars A regular grammar is a grammar in which all productions have at most one nonterminal symbol, all of which appear on either the left or the right. In other words, this is a regular grammar: S → A b c A → S a | ε This is not a regular grammar (but it is linear and context-free ): S → A b c A → a S | ε Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 8 / 23

  29. Regular Grammars A regular grammar is a grammar in which all productions have at most one nonterminal symbol, all of which appear on either the left or the right. In other words, this is a regular grammar: S → A b c A → S a | ε This is not a regular grammar (but it is linear and context-free ): S → A b c A → a S | ε and neither is this (it is context-sensitive ): S → S s | ε S s → S t Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 8 / 23

  30. Regular Grammars A regular grammar is a grammar in which all productions have at most one nonterminal symbol, all of which appear on either the left or the right. In other words, this is a regular grammar: S → A b c A → S a | ε This is not a regular grammar (but it is linear and context-free ): S → A b c A → a S | ε and neither is this (it is context-sensitive ): S → S s | ε S s → S t A language is regular iff it can be described by a regular grammar. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 8 / 23

  31. Regular Expressions Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  32. Regular Expressions A regular expression is an easier way to describe a regular language. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  33. Regular Expressions A regular expression is an easier way to describe a regular language. It’s essentially a pattern for describing a regular language. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  34. Regular Expressions A regular expression is an easier way to describe a regular language. It’s essentially a pattern for describing a regular language. For example, in [abcw-z] * (1+2|3)?4 \ ? , we have: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  35. Regular Expressions A regular expression is an easier way to describe a regular language. It’s essentially a pattern for describing a regular language. For example, in [abcw-z] * (1+2|3)?4 \ ? , we have: [abcw-z] (a character set ) means “either a , b , c , w , x , y , or z ”. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  36. Regular Expressions A regular expression is an easier way to describe a regular language. It’s essentially a pattern for describing a regular language. For example, in [abcw-z] * (1+2|3)?4 \ ? , we have: [abcw-z] (a character set ) means “either a , b , c , w , x , y , or z ”. Asterisk (a.k.a. “Kleene star”, a quantifier ) means “zero or more” Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  37. Regular Expressions A regular expression is an easier way to describe a regular language. It’s essentially a pattern for describing a regular language. For example, in [abcw-z] * (1+2|3)?4 \ ? , we have: [abcw-z] (a character set ) means “either a , b , c , w , x , y , or z ”. Asterisk (a.k.a. “Kleene star”, a quantifier ) means “zero or more” Plus (another quantifier) means “one or more” Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  38. Regular Expressions A regular expression is an easier way to describe a regular language. It’s essentially a pattern for describing a regular language. For example, in [abcw-z] * (1+2|3)?4 \ ? , we have: [abcw-z] (a character set ) means “either a , b , c , w , x , y , or z ”. Asterisk (a.k.a. “Kleene star”, a quantifier ) means “zero or more” Plus (another quantifier) means “one or more” Question mark (another quantifier) means “at most one” Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  39. Regular Expressions A regular expression is an easier way to describe a regular language. It’s essentially a pattern for describing a regular language. For example, in [abcw-z] * (1+2|3)?4 \ ? , we have: [abcw-z] (a character set ) means “either a , b , c , w , x , y , or z ”. Asterisk (a.k.a. “Kleene star”, a quantifier ) means “zero or more” Plus (another quantifier) means “one or more” Question mark (another quantifier) means “at most one” Backslash (“escape”) before a special character means that character Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  40. Regular Expressions A regular expression is an easier way to describe a regular language. It’s essentially a pattern for describing a regular language. For example, in [abcw-z] * (1+2|3)?4 \ ? , we have: [abcw-z] (a character set ) means “either a , b , c , w , x , y , or z ”. Asterisk (a.k.a. “Kleene star”, a quantifier ) means “zero or more” Plus (another quantifier) means “one or more” Question mark (another quantifier) means “at most one” Backslash (“escape”) before a special character means that character Pipe (the OR symbol | ) means “either”, and parentheses group Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  41. Regular Expressions A regular expression is an easier way to describe a regular language. It’s essentially a pattern for describing a regular language. For example, in [abcw-z] * (1+2|3)?4 \ ? , we have: [abcw-z] (a character set ) means “either a , b , c , w , x , y , or z ”. Asterisk (a.k.a. “Kleene star”, a quantifier ) means “zero or more” Plus (another quantifier) means “one or more” Question mark (another quantifier) means “at most one” Backslash (“escape”) before a special character means that character Pipe (the OR symbol | ) means “either”, and parentheses group So this matches zero or more of a, b, c, w, x, y, z, followed by either nothing or by 3 or by 1’s followed by 2, followed by 4 and a question mark. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 9 / 23

  42. Regular Expressions 1 If you’ve seen backreferences: those are not technically valid in regexes. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 10 / 23

  43. Regular Expressions Regular expressions ( regexes ) are equivalent to regular grammars 1 , e.g. Y � �� � [abcw-z] * 4 \ ? (1+ 2|3)? � �� � X � �� � Z 1 If you’ve seen backreferences: those are not technically valid in regexes. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 10 / 23

  44. Regular Expressions Regular expressions ( regexes ) are equivalent to regular grammars 1 , e.g. Y � �� � [abcw-z] * 4 \ ? (1+ 2|3)? � �� � X � �� � Z is equivalent to S → Z 4 ? Z → Y 2 | X 3 | ε Y → Y 1 | X 1 X → X a | X b | X c | X w | X x | X y | X z | ε 1 If you’ve seen backreferences: those are not technically valid in regexes. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 10 / 23

  45. Regular Expressions Regular expressions ( regexes ) are equivalent to regular grammars 1 , e.g. Y � �� � [abcw-z] * 4 \ ? (1+ 2|3)? � �� � X � �� � Z is equivalent to S → Z 4 ? Z → Y 2 | X 3 | ε Y → Y 1 | X 1 X → X a | X b | X c | X w | X x | X y | X z | ε Here, the regex is more compact. Sometimes, the grammar is smaller. 1 If you’ve seen backreferences: those are not technically valid in regexes. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 10 / 23

  46. Regular Expressions Python has a regex engine to find text matching a regex: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 23

  47. Regular Expressions Python has a regex engine to find text matching a regex: >>> import re >>> m = re.match('.* ([a-z0-9._-]+)@([a-z0-9._-]+)', 'hello cs61a@berkeley.edu cs98-52') >>> m <re.Match object; span=( 0 , 24 ), match='hello cs61a@berkeley.edu'> >>> m.groups() ('cs61a', 'berkeley.edu') Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 23

  48. Regular Expressions Python has a regex engine to find text matching a regex: >>> import re >>> m = re.match('.* ([a-z0-9._-]+)@([a-z0-9._-]+)', 'hello cs61a@berkeley.edu cs98-52') >>> m <re.Match object; span=( 0 , 24 ), match='hello cs61a@berkeley.edu'> >>> m.groups() ('cs61a', 'berkeley.edu') Notice that these could all be handled by re.match : Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 23

  49. Regular Expressions Python has a regex engine to find text matching a regex: >>> import re >>> m = re.match('.* ([a-z0-9._-]+)@([a-z0-9._-]+)', 'hello cs61a@berkeley.edu cs98-52') >>> m <re.Match object; span=( 0 , 24 ), match='hello cs61a@berkeley.edu'> >>> m.groups() ('cs61a', 'berkeley.edu') Notice that these could all be handled by re.match : Substring search ( str.find ) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 23

  50. Regular Expressions Python has a regex engine to find text matching a regex: >>> import re >>> m = re.match('.* ([a-z0-9._-]+)@([a-z0-9._-]+)', 'hello cs61a@berkeley.edu cs98-52') >>> m <re.Match object; span=( 0 , 24 ), match='hello cs61a@berkeley.edu'> >>> m.groups() ('cs61a', 'berkeley.edu') Notice that these could all be handled by re.match : Substring search ( str.find ) Subsequence search ( re.match(".*b.*b", "abbc") ) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 23

  51. Regular Expressions Python has a regex engine to find text matching a regex: >>> import re >>> m = re.match('.* ([a-z0-9._-]+)@([a-z0-9._-]+)', 'hello cs61a@berkeley.edu cs98-52') >>> m <re.Match object; span=( 0 , 24 ), match='hello cs61a@berkeley.edu'> >>> m.groups() ('cs61a', 'berkeley.edu') Notice that these could all be handled by re.match : Substring search ( str.find ) Subsequence search ( re.match(".*b.*b", "abbc") ) The grep tool (from ed ’s g/re/p = global/regex/print ) does this for files. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 11 / 23

  52. Regular Expressions Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  53. Regular Expressions Million-dollar question: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  54. Regular Expressions Million-dollar question: How do you find text matching a regex? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  55. Regular Expressions Million-dollar question: How do you find text matching a regex? Two steps: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  56. Regular Expressions Million-dollar question: How do you find text matching a regex? Two steps: 1 Parse the regex (pattern) to “understand” its structure Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  57. Regular Expressions Million-dollar question: How do you find text matching a regex? Two steps: 1 Parse the regex (pattern) to “understand” its structure 2 Use the regex to parse the actual text (corpus) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  58. Regular Expressions Million-dollar question: How do you find text matching a regex? Two steps: 1 Parse the regex (pattern) to “understand” its structure 2 Use the regex to parse the actual text (corpus) It turns out that: Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  59. Regular Expressions Million-dollar question: How do you find text matching a regex? Two steps: 1 Parse the regex (pattern) to “understand” its structure 2 Use the regex to parse the actual text (corpus) It turns out that: 1 Step 1 is theoretically harder, but practically easier. (This can be done similarly to how you parsed Scheme.) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  60. Regular Expressions Million-dollar question: How do you find text matching a regex? Two steps: 1 Parse the regex (pattern) to “understand” its structure 2 Use the regex to parse the actual text (corpus) It turns out that: 1 Step 1 is theoretically harder, but practically easier. (This can be done similarly to how you parsed Scheme.) 2 Step 2 is theoretically easier, but practically harder. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  61. Regular Expressions Million-dollar question: How do you find text matching a regex? Two steps: 1 Parse the regex (pattern) to “understand” its structure 2 Use the regex to parse the actual text (corpus) It turns out that: 1 Step 1 is theoretically harder, but practically easier. (This can be done similarly to how you parsed Scheme.) 2 Step 2 is theoretically easier, but practically harder. This is because we need parsing the corpus to be fast . Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 12 / 23

  62. Regular Expressions Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 23

  63. Regular Expressions How do you solve each step? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 23

  64. Regular Expressions How do you solve each step? Both steps are often done using “recursive-descent”—similarly to how your Scheme parser parsed its input. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 23

  65. Regular Expressions How do you solve each step? Both steps are often done using “recursive-descent”—similarly to how your Scheme parser parsed its input. Basically: try every possibility recursively. “Backtrack” on failure to try something else. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 23

  66. Regular Expressions How do you solve each step? Both steps are often done using “recursive-descent”—similarly to how your Scheme parser parsed its input. Basically: try every possibility recursively. “Backtrack” on failure to try something else. Problem: Recursive-descent can take exponential time ! Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 23

  67. Regular Expressions How do you solve each step? Both steps are often done using “recursive-descent”—similarly to how your Scheme parser parsed its input. Basically: try every possibility recursively. “Backtrack” on failure to try something else. Problem: Recursive-descent can take exponential time ! Example (where “ a { 3 } ” is shorthand for “ aaa ”): Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 23

  68. Regular Expressions How do you solve each step? Both steps are often done using “recursive-descent”—similarly to how your Scheme parser parsed its input. Basically: try every possibility recursively. “Backtrack” on failure to try something else. Problem: Recursive-descent can take exponential time ! Example (where “ a { 3 } ” is shorthand for “ aaa ”): >>> re.match("(a?){25}a{25}", "a" * 25 ) Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 23

  69. Regular Expressions How do you solve each step? Both steps are often done using “recursive-descent”—similarly to how your Scheme parser parsed its input. Basically: try every possibility recursively. “Backtrack” on failure to try something else. Problem: Recursive-descent can take exponential time ! Example (where “ a { 3 } ” is shorthand for “ aaa ”): >>> re.match("(a?){25}a{25}", "a" * 25 ) Can we hope to parse corpora in time linear to their lengths? Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 23

  70. Regular Expressions How do you solve each step? Both steps are often done using “recursive-descent”—similarly to how your Scheme parser parsed its input. Basically: try every possibility recursively. “Backtrack” on failure to try something else. Problem: Recursive-descent can take exponential time ! Example (where “ a { 3 } ” is shorthand for “ aaa ”): >>> re.match("(a?){25}a{25}", "a" * 25 ) Can we hope to parse corpora in time linear to their lengths? Yes , using finite automata. Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 13 / 23

  71. Finite Automata A finite automaton (FA) consists of the following (example below) 2 : 2 Note that an FA is not quite the same thing as a finite-state machine (FSM). Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 23

  72. Finite Automata A finite automaton (FA) consists of the following (example below) 2 : An input alphabet Σ ( { 0 , 1 } here) 2 Note that an FA is not quite the same thing as a finite-state machine (FSM). Mehrdad Niknami (UC Berkeley) CS 61A/CS 98-52 14 / 23

Download Presentation
Download Policy: The content available on the website is offered to you 'AS IS' for your personal information and use only. It cannot be commercialized, licensed, or distributed on other websites without prior consent from the author. To download a presentation, simply click this link. If you encounter any difficulties during the download process, it's possible that the publisher has removed the file from their server.

Recommend

Equivalence of NFAs and DFAs, plus Intro to regular expressions 9/27/19 Administrivia HW 2

Equivalence of NFAs and DFAs, plus Intro to regular expressions 9/27/19 Administrivia HW 2

Equivalence of NFAs and DFAs, plus Intro to regular expressions 9/27/19 Administrivia HW 2 (mystery DFA + NFAs) due Wednesday Read Chapter 7 for Monday Can also read 6.3-6.5, which we cover today Recall: NFAs Automata

508 views • 38 slides
Timed Pattern Matching FORMATS14 gan Ulus 1 ere 1 Eugene Asarin 2 Oded Maler 1 Do Thomas

Timed Pattern Matching FORMATS14 gan Ulus 1 ere 1 Eugene Asarin 2 Oded Maler 1 Do Thomas

Timed Pattern Matching FORMATS14 gan Ulus 1 ere 1 Eugene Asarin 2 Oded Maler 1 Do Thomas Ferr` 1 VERIMAG, CNRS and the University of Grenoble-Alpes 2 LIAFA, University of Paris Diderot / CNRS September 10, 2014 Timed Pattern Matching

762 views • 37 slides
System Modelling Introduction Finite State Machines Petri Nets Untimed Model of Computation

System Modelling Introduction Finite State Machines Petri Nets Untimed Model of Computation

System Modelling Introduction Finite State Machines Petri Nets Untimed Model of Computation Synchronous Model of Computation Timed Model of Computation Integration of Computational Models Tightly Coupled Process Networks System Modelling,

657 views • 38 slides
SASE: Complex Event Processing Over Streams Daniel Gyllstrom, Eugene Wu, Hee-Jin Chae, Yanlei

SASE: Complex Event Processing Over Streams Daniel Gyllstrom, Eugene Wu, Hee-Jin Chae, Yanlei

SASE: Complex Event Processing Over Streams Daniel Gyllstrom, Eugene Wu, Hee-Jin Chae, Yanlei Diao, Gordon Anderson, and Patrick Stahlberg Computer Science Department Complex Event Processing High-volume event streams Sensing devices

109 views • 9 slides
Tracing the Decision Procedure of Regular Expressions Equality Beno t Razet &amp; Bodhayan

Tracing the Decision Procedure of Regular Expressions Equality Beno t Razet &amp; Bodhayan

Axiomatisations Implementation Tracing the Decision Procedure of Regular Expressions Equality Beno t Razet &amp; Bodhayan Roy TIFR Automata, Concurrency and Timed Systems (ACTS) 2011 CMI, Chennai, India 2011-01-29 Axiomatisations

484 views • 20 slides
Concurrent Kleene Algebra Tobias Kapp e University College London BCTCS 2018 What is Kleene

Concurrent Kleene Algebra Tobias Kapp e University College London BCTCS 2018 What is Kleene

Concurrent Kleene Algebra Tobias Kapp e University College London BCTCS 2018 What is Kleene Algebra? Kleene Algebra describes program behavior T. Kapp e Concurrent Kleene Algebra BCTCS 2018 2 16 What is Kleene Algebra? Kleene

677 views • 52 slides
Syntactic Theory Introduction Yi Zhang &amp; Antske Fokkens Department of Computational

Syntactic Theory Introduction Yi Zhang &amp; Antske Fokkens Department of Computational

Syntactic Theory Introduction Yi Zhang &amp; Antske Fokkens Department of Computational Linguistics Saarland University October 15, 2009 Syntax: What does it mean? We can view syntax/syntactic theory in a number of ways, two of which are the

703 views • 27 slides
MA/CSSE 474 Theory of Computation CFL Hierarchy CFL Decision Problems Your Questions?

MA/CSSE 474 Theory of Computation CFL Hierarchy CFL Decision Problems Your Questions?

4/26/2018 MA/CSSE 474 Theory of Computation CFL Hierarchy CFL Decision Problems Your Questions? Previous class days' material I have included some Reading Assignments slides online that we will not have time to do in HW 12 or

559 views • 39 slides
Verifying Hybrid Systems with Interactive Theorem Provers Jonathan Juli an Huerta y Munive

Verifying Hybrid Systems with Interactive Theorem Provers Jonathan Juli an Huerta y Munive

Verifying Hybrid Systems with Interactive Theorem Provers Jonathan Juli an Huerta y Munive Georg Struth University of Sheffield, UK Algebras for Program Verification Kleene algebras modal Kleene algebras (MKAs) concurrent Kleene

701 views • 44 slides
Fun With String Lenses Benjamin C. Pierce University of Pennsylvania WG 2.8, July 2007 My usual

Fun With String Lenses Benjamin C. Pierce University of Pennsylvania WG 2.8, July 2007 My usual

Fun With String Lenses Benjamin C. Pierce University of Pennsylvania WG 2.8, July 2007 My usual obsession... The View Update Problem We transform source structure C to target structure A C A The View Update Problem We transform

686 views • 30 slides
Scanners and parsers COMP 520 Fall 2010 Scanners and Parsers (2) A scanner or lexer transforms a

Scanners and parsers COMP 520 Fall 2010 Scanners and Parsers (2) A scanner or lexer transforms a

COMP 520 Fall 2010 Scanners and Parsers (1) Scanners and parsers COMP 520 Fall 2010 Scanners and Parsers (2) A scanner or lexer transforms a string of characters into a string of tokens: uses a combination of deterministic finite automata

1.08k views • 53 slides
Type Systems Lecture 2 Oct. 27th, 2004 Sebastian Maneth

Type Systems Lecture 2 Oct. 27th, 2004 Sebastian Maneth

Type Systems Lecture 2 Oct. 27th, 2004 Sebastian Maneth http://lampwww.epfl.ch/teaching/typeSystems/2004 Today 1. What is the Lambda Calculus? 2. Its Syntax and Semantics 3. Church Booleans and Church Numerals 4. Lazy vs. Eager

889 views • 72 slides
The Suppression Task Steffen H olldobler International Center for Computational Logic

The Suppression Task Steffen H olldobler International Center for Computational Logic

The Suppression Task Steffen H olldobler International Center for Computational Logic Technische Universit at Dresden Germany The Suppression Task Part I Three-Valued ukasiewicz Logic Logic Programs Completion

718 views • 61 slides
Language Evolution, Metasyntactically First International Workshop on Bidirectional

Language Evolution, Metasyntactically First International Workshop on Bidirectional

Language Evolution, Metasyntactically First International Workshop on Bidirectional Transformations (BX 2012) Vadim Zaytsev, SWAT, CWI 2012 Introduction Every language document employs its own notation We focus on metalanguage

486 views • 37 slides
Computations and Interaction Jos Baeten Systems Engineering (Dept. of Mech. Eng.) and Theory of

Computations and Interaction Jos Baeten Systems Engineering (Dept. of Mech. Eng.) and Theory of

2 Computations and Interaction Jos Baeten Systems Engineering (Dept. of Mech. Eng.) and Theory of Computing (Dept. of Math. &amp; Comp. Sci.) Joint work with Bas Luttik and Paul van Tilburg March 4, 2011 What is a computation? 3 My

922 views • 67 slides
Computational Logic Abstract Interpretation of Logic Programs 1 Introduction [Material partly

Computational Logic Abstract Interpretation of Logic Programs 1 Introduction [Material partly

Computational Logic Abstract Interpretation of Logic Programs 1 Introduction [Material partly from Cousot, Nielson, Gallagher, Sondergaard, Bruynooghe, and others] Many CS problems related to program analysis / synthesis Prove that some

915 views • 50 slides
600.405 Finite-State Methods in NLP Assignment 3: HMMs and Formal Power Series Prof. J.

600.405 Finite-State Methods in NLP Assignment 3: HMMs and Formal Power Series Prof. J.

600.405 Finite-State Methods in NLP Assignment 3: HMMs and Formal Power Series Prof. J. Eisner Fall 2000 Handed out: Sat., Dec. 2, 2000 Due date: Try to do problem 1 by the Dec. 5 lecture, so that youll understand the lecture.

155 views • 13 slides
Compressibility and probabilistic proofs alexander.shen@lirmm.fr, www.lirmm.fr/~ashen LIRMM CNRS

Compressibility and probabilistic proofs alexander.shen@lirmm.fr, www.lirmm.fr/~ashen LIRMM CNRS

Compressibility and probabilistic proofs alexander.shen@lirmm.fr, www.lirmm.fr/~ashen LIRMM CNRS &amp; University of Montpellier CiE 2017 alexander.shen@lirmm.fr, www.lirmm.fr/~ashen Compressibility and probabilistic proofs Probabilistic

1.73k views • 150 slides
Lecture 14: Sequential Circuits, FSM Todays topics: Sequential circuits Finite

Lecture 14: Sequential Circuits, FSM Todays topics: Sequential circuits Finite

Lecture 14: Sequential Circuits, FSM Todays topics: Sequential circuits Finite state machines 1 Sequential Circuits Until now, circuits were combinational when inputs change, the outputs change after a while (time = logic

435 views • 19 slides
https://images-na.ssl-images-amazon.com/images/I/A1w4iP5ov-L._SY879_.jpg Translate this table to a

https://images-na.ssl-images-amazon.com/images/I/A1w4iP5ov-L._SY879_.jpg Translate this table to a

https://images-na.ssl-images-amazon.com/images/I/A1w4iP5ov-L._SY879_.jpg Translate this table to a circuit input output fill me in! x y a b c d 0 0 1 0 0 0 0 1 0 1 0 0 1 0 0 0 1 0 1 1 0 0 0 1 Full name Th. 9/20

371 views • 23 slides
WRAC'H 2019 Analysis of Mixed PUF-TRNG Circuit Based on SR-Latches in FD-SOI Technology Jean-Luc

WRAC'H 2019 Analysis of Mixed PUF-TRNG Circuit Based on SR-Latches in FD-SOI Technology Jean-Luc

WRAC'H 2019 Analysis of Mixed PUF-TRNG Circuit Based on SR-Latches in FD-SOI Technology Jean-Luc DANGER , Tlcom ParisTech In collaboration with: Risa Yashiro, Kazuo Sakiyama (UEC) Noriyuki Miura, Makoto Nagata (Kobe University) Yves Mathieu,

628 views • 26 slides
Old English Alphabet 05.23.13 || English 2322: British Literature: Anglo-Saxon Mid 18th Century

Old English Alphabet 05.23.13 || English 2322: British Literature: Anglo-Saxon Mid 18th Century

Old English Alphabet 05.23.13 || English 2322: British Literature: Anglo-Saxon Mid 18th Century || D. Glen Smith, instructor Old English Alphabet Majuscule forms (uppercase) A B C D E F G H I L M N O P R S T U /W X Y Minuscule

344 views • 3 slides
The Same is Not The Same Postcorrection of Alphabet Confusion Errors in Mixed-Alphabet OCR

The Same is Not The Same Postcorrection of Alphabet Confusion Errors in Mixed-Alphabet OCR

The Same is Not The Same Postcorrection of Alphabet Confusion Errors in Mixed-Alphabet OCR Recognition by Jonas Hempel Bulgerian-German to English In English: Ivan plowed the field. 'opa' is German word for 'grandfather' Alphabet Similarities

541 views • 9 slides
Feedback: Journal 1 1 Exercise 1: Quiz You were not expected to know the answers. It was

Feedback: Journal 1 1 Exercise 1: Quiz You were not expected to know the answers. It was

Feedback: Journal 1 1 Exercise 1: Quiz You were not expected to know the answers. It was part of the introduction to give you an idea about what information you will learn during this semester. Exercise 2: binary subtraction and

782 views • 38 slides

More recommend