Regular Expressions | CS 139: Theory of Computation

<h1 id="regular-expressions">Regular Expressions</h1>

<hr />

<h2 id="administrivia">Administrivia</h2>
<ul>
  <li>CS Candidate Research Talks
    <ul>
      <li><strong>Software Authorship Identification</strong>
        <ul>
          <li>9-10am, Friday, February 14th</li>
          <li>C-S 235</li>
        </ul>
      </li>
      <li><strong>Title TBA</strong>
        <ul>
          <li>4-5pm, Friday, February 14th</li>
          <li>C-S 235</li>
        </ul>
      </li>
    </ul>
  </li>
  <li class="fragment">Moved problem 4 to assignment 4</li>
  <li class="fragment">Minor change to schedule (added extra day to prove some interesting properties of regular languages</li>
</ul>

<h1 id="assignment-3-questions">Assignment 3 Questions?</h1>

<h1 id="nfa-recap">NFA Recap</h1>

<h2 id="what-are-nfas-again">What are NFAs Again?</h2>

</div>

<hr />

<ul>
  <li>Nondeterministic Finite Automata (NFAs) are basically  DFAs with some <strong>extra conveniences</strong>
    <ul>
      <li>Supports zero or more transitions with a symbol</li>
      <li><code class="language-plaintext highlighter-rouge">$\epsilon$</code>-transitions</li>
    </ul>
  </li>
  <li>An NFA “accepts” if <strong>there exists a path</strong> from <code class="language-plaintext highlighter-rouge">$q_0$</code> to a state <code class="language-plaintext highlighter-rouge">$s\in F$</code> using every symbol of the input</li>
</ul>

<h2 id="formal-definition-of-nfas">Formal Definition of NFAs</h2>
<p>A <strong>nondeterministic finite automaton</strong> (<strong>NFA</strong>) is a 5-tuple:
<code class="language-plaintext highlighter-rouge">$$M = (Q, \Sigma, \delta, q_0, F)$$</code></p>

<hr />

<ul>
  <li><code class="language-plaintext highlighter-rouge">$Q$</code> is a finite set of <strong>states</strong></li>
  <li><code class="language-plaintext highlighter-rouge">$\Sigma$</code> is an <strong>alphabet</strong> (finite set of symbols)</li>
  <li><code class="language-plaintext highlighter-rouge">$q_0\in Q$</code> is the <strong>start state</strong></li>
  <li><code class="language-plaintext highlighter-rouge">$F\subseteq Q$</code> is the set of <strong>accepting states</strong></li>
</ul>

<h2 id="formal-definition-of-nfas-1">Formal Definition of NFAs</h2>

<p><code class="language-plaintext highlighter-rouge">$$M = (Q, \Sigma, \delta, q_0, F)$$</code></p>

<hr />

<ul>
  <li><code class="language-plaintext highlighter-rouge">$\delta:Q\times\Sigma_\epsilon\rightarrow\mathbb{P}(Q)$</code> is the <strong>transition function</strong></li>
  <li><code class="language-plaintext highlighter-rouge">$\Sigma_\epsilon = \Sigma \cup \{\epsilon\}$</code> allows <code class="language-plaintext highlighter-rouge">$\epsilon$</code>’s on transitions</li>
  <li><code class="language-plaintext highlighter-rouge">$\mathbb{P}(Q)$</code> is the <strong>powerset</strong> of <code class="language-plaintext highlighter-rouge">$Q$</code>
    <ul>
      <li>Allows for <strong>multiple</strong> arrows with the <strong>same symbol</strong> coming out of the same state</li>
    </ul>
  </li>
</ul>

<h2 id="formal-definition-of-nfas-2">Formal Definition of NFAs</h2>

</div>

<hr />

`$Q = \{q_0, q_1, q_2, q_3, r_1, r_2, r_3, s\}\quad$`<br />
`$\Sigma = \{0,1\}$`<br />
`$q_0 = q_0$`<br />
`$F = \{q_0\}$`

</div>
<div>

`$\delta(q_0, 0) = \emptyset$`<br />
`$\delta(q_0, 1) = \emptyset$`<br />
`$\delta(q_0, \epsilon) = \{q_1, r_1\}$`<br />
`$\delta(q_1, 0) = \{q_2\}$`<br />
`$\delta(q_1, 1) = \emptyset$`<br />
`$\delta(q_1, \epsilon) = \emptyset$`<br />
`$\ldots$`

</div>
</div>

<h2 id="nfa-exercise-1">NFA Exercise 1</h2>

<p><code class="language-plaintext highlighter-rouge">$L(M) = \{w\in\{0,1\}^\ast\mid\text{ the length of }w\text{ is 4} \}$</code></p>

<hr />

</div>

<h2 id="exercise-2">Exercise 2</h2>
<p><code class="language-plaintext highlighter-rouge">$L(M) = \{w\mid w\text{ starts with a 0 or ends with a 1}\}$</code></p>

<hr />

</div>

<h2 id="exercise-3">Exercise 3</h2>

<p><code class="language-plaintext highlighter-rouge">$L(M) = \{w\mid w\text{ contains the substring }\texttt{abba}\}$</code></p>

<hr />

</div>

<hr />

</div>

<h2 id="equivalence-of-nfas-and-dfas">Equivalence of NFAs and DFAs</h2>

<ul>
  <li><strong>Definition</strong>: A language <strong>regular</strong> if and only if it is recognized by some DFA</li>
  <li class="fragment"><strong>Theorem</strong>: A language is regular if and only if it is recognized by some <strong>NFA</strong>
    <ul>
      <li class="fragment">In other words, DFAs and NFAs have the same <strong>computational power</strong></li>
    </ul>
  </li>
</ul>

<h2 id="equivalence-of-nfas-and-dfas-1">Equivalence of NFAs and DFAs</h2>
<p><code class="language-plaintext highlighter-rouge">$L$</code> is regular <code class="language-plaintext highlighter-rouge">$\iff$</code> there is an NFA with <code class="language-plaintext highlighter-rouge">$L(M) = L$</code></p>

<hr />

<ul>
  <li>How do we prove something like this? What are the parts of the statement?
    <ol>
      <li class="fragment">If <code class="language-plaintext highlighter-rouge">$L$</code> is regular, then there is an NFA with <code class="language-plaintext highlighter-rouge">$L(M) = L$</code></li>
      <li class="fragment">If there is an NFA with <code class="language-plaintext highlighter-rouge">$L(M) = L$</code>, then <code class="language-plaintext highlighter-rouge">$L$</code> is regular</li>
    </ol>
  </li>
</ul>

<h2 id="equivalence-of-nfas-and-dfas-2">Equivalence of NFAs and DFAs</h2>
<p><code class="language-plaintext highlighter-rouge">$L$</code> is regular <code class="language-plaintext highlighter-rouge">$\iff$</code> there is an NFA with <code class="language-plaintext highlighter-rouge">$L(M) = L$</code></p>

<hr />

<ul>
  <li><strong>Proof</strong> of the forward direction (<code class="language-plaintext highlighter-rouge">$\implies$</code>):
    <ol>
      <li>Assume that <code class="language-plaintext highlighter-rouge">$L$</code> is regular</li>
      <li class="fragment">There there is a DFA <code class="language-plaintext highlighter-rouge">$M$</code> that recognizes it</li>
      <li class="fragment">A DFA <strong>is also an NFA</strong>—it just doesn’t use any of the fancy nondeterminism powers!</li>
      <li>Therefore there is an NFA, <code class="language-plaintext highlighter-rouge">$M$</code>, satisfying <code class="language-plaintext highlighter-rouge">$L(M) = L$</code></li>
    </ol>
  </li>
</ul>

<h2 id="equivalence-of-nfas-and-dfas-3">Equivalence of NFAs and DFAs</h2>
<p><code class="language-plaintext highlighter-rouge">$L$</code> is regular <code class="language-plaintext highlighter-rouge">$\iff$</code> there is an NFA with <code class="language-plaintext highlighter-rouge">$L(M) = L$</code></p>

<hr />

<ul>
  <li><strong>Proof Sketch</strong> of the backward direction (<code class="language-plaintext highlighter-rouge">$\Longleftarrow$</code>):
    <ol>
      <li>Assume there is an NFA <code class="language-plaintext highlighter-rouge">$M = (Q, \Sigma, \delta, q_0, F)$</code> that recognizes <code class="language-plaintext highlighter-rouge">$L$</code></li>
      <li class="fragment">Need to build a DFA <code class="language-plaintext highlighter-rouge">$\widehat{M}$</code> from <code class="language-plaintext highlighter-rouge">$M$</code> that also recognizes <code class="language-plaintext highlighter-rouge">$L$</code> without using any fancy NFA powers</li>
      <li class="fragment">The existence of such a DFA would mean that <code class="language-plaintext highlighter-rouge">$L$</code> is regular, so we’d be done</li>
    </ol>
  </li>
</ul>

<h2 id="subset-construction">Subset Construction</h2>
<ul>
  <li>Given an NFA <code class="language-plaintext highlighter-rouge">$M = (Q, \Sigma, \delta, q_0, F)$</code>, how can we build a DFA that is equivalent to it?</li>
  <li class="fragment">The DFA would need to simulate <strong>all possible paths</strong> through <code class="language-plaintext highlighter-rouge">$M$</code> <strong>simultaneously</strong></li>
  <li class="fragment">Main idea: make the states of the DFA be the <strong>powerset</strong> <code class="language-plaintext highlighter-rouge">$\mathbb{P}(Q)$</code> of the NFA states</li>
  <li class="fragment">In other words, the DFA can, in a sense, be in <em>multiple</em> states <strong>at the same time</strong></li>
</ul>

<h2 id="subset-construction-1">Subset Construction</h2>
<ul>
  <li>Consider the following NFA</li>
  <li>Let’s construct a DFA that is equivalent to it</li>
</ul>

<hr />

</div>

<h2 id="subset-construction-2">Subset Construction</h2>

</div>

<hr />

</div>

<h1 id="regular-expressions-1">Regular Expressions</h1>

<h2 id="regular-expressions-2">Regular Expressions</h2>
<ul>
  <li>You may of heard of regular expressions before—they are used everywhere for <strong>searching text</strong></li>
</ul>

<hr />

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// Java Example</span>
<span class="nc">Pattern</span> <span class="n">p</span> <span class="o">=</span> <span class="nc">Pattern</span><span class="o">.</span><span class="na">compile</span><span class="o">(</span><span class="s">"[abc]*[0-9]"</span><span class="o">);</span>
<span class="nc">Matcher</span> <span class="n">m</span> <span class="o">=</span> <span class="n">p</span><span class="o">.</span><span class="na">matcher</span><span class="o">(</span><span class="s">"abbaccac9"</span><span class="o">)</span>
<span class="kt">boolean</span> <span class="n">b</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="na">matches</span><span class="o">();</span>
</code></pre></div></div>

<hr />

<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c"># grep example</span>
egrep <span class="s1">'(abc|123)*'</span> /home/username/Documents/my_file.txt
</code></pre></div></div>

<h2 id="regular-expressions-3">Regular Expressions</h2>
<ul>
  <li>There are many <strong>equivalent notions</strong> of regular expressions with slightly different syntactical sugars</li>
  <li class="fragment">In this class, we will be studying a minimalistic definition of regular expressions</li>
  <li class="fragment">This will allow us to easily see that they are <strong>equivalent</strong> to DFAs and NFAs in expressiveness</li>
</ul>

<h2 id="formal-definition-of-regex">Formal Definition of RegEx</h2>
<p><code class="language-plaintext highlighter-rouge">$R$</code> is a <strong>regular expression</strong> if it is in the form:</p>

<hr />

<ol>
  <li><code class="language-plaintext highlighter-rouge">$a$</code> for some symbol <code class="language-plaintext highlighter-rouge">$a\in\Sigma$</code></li>
  <li><code class="language-plaintext highlighter-rouge">$\epsilon$</code></li>
  <li><code class="language-plaintext highlighter-rouge">$\emptyset$</code></li>
  <li><code class="language-plaintext highlighter-rouge">$(R_1\cup R_2)$</code> where <code class="language-plaintext highlighter-rouge">$R_1$</code> and <code class="language-plaintext highlighter-rouge">$R_2$</code> are regular expressions</li>
  <li><code class="language-plaintext highlighter-rouge">$(R_1\circ R_2)$</code> where <code class="language-plaintext highlighter-rouge">$R_1$</code> and <code class="language-plaintext highlighter-rouge">$R_2$</code> are regular expressions</li>
  <li><code class="language-plaintext highlighter-rouge">$(R_1)^\ast$</code> where <code class="language-plaintext highlighter-rouge">$R_1$</code> is a regular expression</li>
</ol>

<h2 id="regex-examples">Regex Examples</h2>
<p>Write the corresponding <strong>language</strong> that each of the following regular expressions express</p>

<hr />

<ol>
  <li><code class="language-plaintext highlighter-rouge">$0\cup 1$</code></li>
  <li><code class="language-plaintext highlighter-rouge">$01$</code></li>
  <li><code class="language-plaintext highlighter-rouge">$01$</code></li>
  <li><code class="language-plaintext highlighter-rouge">$01\cup\epsilon$</code></li>
</ol>

<h2 id="regex-examples-1">Regex Examples</h2>
<p>Write the corresponding <strong>language</strong> that each of the following regular expressions express</p>

<hr />

<ol start="5">
  <li><code class="language-plaintext highlighter-rouge">$\texttt{ab}\cup\emptyset$</code></li>
  <li><code class="language-plaintext highlighter-rouge">$(0\cup 1)^\ast$</code></li>
  <li><code class="language-plaintext highlighter-rouge">$0^\ast\cup 1$</code></li>
  <li><code class="language-plaintext highlighter-rouge">$0(0\cup 1)^\ast \cup (0\cup 1)^\ast 1$</code></li>
</ol>

<h2 id="regex-exercises">Regex Exercises</h2>
<p>Let <code class="language-plaintext highlighter-rouge">$\Sigma = \{\texttt{a}, \ldots, \texttt{z}\}\cup \{\texttt{/}, \texttt{N}, \texttt{*}\}$</code> be an alphabet</p>

<hr />

<ol>
  <li>Construct a regex that recognizes all the strings of the form <code class="language-plaintext highlighter-rouge">$\texttt{//}\ldots \texttt{N}$</code></li>
  <li class="fragment">Construct a regex that recognizes all the strings of the form <code class="language-plaintext highlighter-rouge">$\texttt{/*}\ldots \texttt{*/}$</code>
    <ul>
      <li class="fragment">Note that we should not match strings of the form <code class="language-plaintext highlighter-rouge">$\texttt{/*abc*/def*/}$</code> because of the two closing <code class="language-plaintext highlighter-rouge">$\texttt{*/}$</code>’s</li>
    </ul>
  </li>
</ol>

<h2 id="the-regularity-of-regex">The “Regularity” of RegEx</h2>
<ul>
  <li><strong>Theorem</strong>: A language <code class="language-plaintext highlighter-rouge">$L$</code> is regular if and only if there is a regular expression that expresses it</li>
</ul>

<h2 id="the-regularity-of-regex-1">The “Regularity” of RegEx</h2>
<p><code class="language-plaintext highlighter-rouge">$L$</code> is regular <code class="language-plaintext highlighter-rouge">$\iff$</code> there is a regex with <code class="language-plaintext highlighter-rouge">$L(R) = L$</code></p>

<hr />

<ul>
  <li><strong>Proof Sketch</strong> of the backward direction (<code class="language-plaintext highlighter-rouge">$\Longleftarrow$</code>):
    <ol>
      <li>Given some regex <code class="language-plaintext highlighter-rouge">$R$</code></li>
      <li>Construct an NFA <code class="language-plaintext highlighter-rouge">$M$</code> with <code class="language-plaintext highlighter-rouge">$L(M) = L(R)$</code></li>
      <li>Having an NFA that recognizes it means <code class="language-plaintext highlighter-rouge">$L$</code> is regular</li>
    </ol>
  </li>
</ul>

<h2 id="the-regularity-of-regex-2">The “Regularity” of RegEx</h2>
<p><code class="language-plaintext highlighter-rouge">$L$</code> is regular <code class="language-plaintext highlighter-rouge">$\iff$</code> there is a regex with <code class="language-plaintext highlighter-rouge">$L(R) = L$</code></p>

<hr />

<ul>
  <li><strong>Proof Sketch</strong> of the forward direction (<code class="language-plaintext highlighter-rouge">$\implies$</code>):
    <ol>
      <li>Assume  that <code class="language-plaintext highlighter-rouge">$L$</code> is regular, therefore there is some DFA <code class="language-plaintext highlighter-rouge">$M$</code> that recognizes it</li>
      <li>Convert <code class="language-plaintext highlighter-rouge">$M$</code> into a regular expression <code class="language-plaintext highlighter-rouge">$R$</code> by using a clever trick using <strong>generalized nondeterministic finite automata</strong> (<strong>GNFAs</strong>)</li>
    </ol>
  </li>
</ul>