Mapping Reducibility | CS 139: Theory of Computation

<h1 id="mapping-reducibility">Mapping Reducibility</h1>

<hr />

<h2 id="administrivia">Administrivia</h2>
<ul>
  <li>Assignment 7 is released (2 problems)
    <ul>
      <li>Due Tuesday at 11:59 PM</li>
    </ul>
  </li>
</ul>

<h2 id="administrivia-1">Administrivia</h2>
<ul>
  <li><strong>Exam 2</strong> is one week from today
    <ul>
      <li><strong>Open</strong> notes, <strong>open</strong> text, 75 minute exam</li>
      <li>Covers Sipser chapters 1, 3, 4, and parts of 5</li>
    </ul>
  </li>
  <li class="fragment">Exam procedures:
    <ul>
      <li class="fragment">I will release the exam at 11:00 AM CDT on Gradescope</li>
      <li class="fragment">From that time, you will have <strong>120 minutes</strong> to complete the exam and upload your solutions to gradescope (extra time for scanning and uploading)</li>
      <li class="fragment">You may <strong>not</strong> use Google or receive help from another other source other than your notes and the text</li>
    </ul>
  </li>
</ul>

<h2 id="administrivia-2">Administrivia</h2>
<ul>
  <li>Practice problems from Sipser:
    <ul>
      <li><strong>Chapter 1</strong>: 2, 6, 7, 11, 12, 14, 18, 20, 22, 29, 30, 31, 38, 40, 43, 46</li>
      <li><strong>Chapter 3</strong>: 7, 8, 15, 16</li>
      <li><strong>Chapter 4</strong>: 2, 3, 4, 5, 10, 12, 13, 21</li>
      <li><strong>Chapter 5</strong>: 4, 5, 6, 7</li>
    </ul>
  </li>
  <li><strong>Tuesday, April 7</strong> will be dedicated to review / practice problems for the exam</li>
</ul>

<h1 id="questions">Questions</h1>
<h2 id="about-anything">…about anything?</h2>

<h2 id="what-weve-learned-so-far">What We’ve Learned So Far</h2>
<ul>
  <li>We’ve been exploring what <strong>computing</strong> really is</li>
  <li class="fragment">We want to understand what problems are <strong>computable</strong>, which are not, and how they are related to one another</li>
  <li class="fragment">We’ve finally converged on the appropriate model for computation—the <strong>Turing machine</strong></li>
  <li class="fragment">We’ve also proven that some useful problems such as the <strong>halting problem</strong> are undecidable</li>
  <li class="fragment">Currently we are exploring a new technique for discovering undecidable problems—namely <strong>reductions</strong></li>
</ul>

<h1 id="reductions">Reductions</h1>

<h2 id="reductions-1">Reductions</h2>
<ul>
  <li>We use reductions <strong>all the time</strong> and don’t even realize it</li>
</ul>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">is_even</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="s">"""Checks whether the integer n is even"""</span>
    <span class="k">return</span> <span class="n">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span>
</code></pre></div></div>

<ul>
  <li>Here we <strong>reduced</strong> an instance of one problem to another
    <ol>
      <li>Checking if <code class="language-plaintext highlighter-rouge">n</code> is even</li>
      <li>Checking if <code class="language-plaintext highlighter-rouge">n % d == r</code></li>
    </ol>
  </li>
</ul>

<h2 id="reductions-2">Reductions</h2>
<ul>
  <li>Since we solved an instance of <code class="language-plaintext highlighter-rouge">$A$</code> by converting it to an instance of <code class="language-plaintext highlighter-rouge">$B$</code>, we say that we <code class="language-plaintext highlighter-rouge">$A$</code> <strong>is reducible to</strong> <code class="language-plaintext highlighter-rouge">$B$</code></li>
  <li>From this reduction, we can deduce a few things:
    <ol>
      <li class="fragment">If <code class="language-plaintext highlighter-rouge">$B$</code> is decidable, then <code class="language-plaintext highlighter-rouge">$A$</code> is also decidable</li>
      <li class="fragment">If <code class="language-plaintext highlighter-rouge">$B$</code> is Turing recognizable, then <code class="language-plaintext highlighter-rouge">$A$</code> is also Turing recognizable</li>
    </ol>
  </li>
</ul>

<hr />

<ul>
  <li class="fragment">The contrapositive of 1 is:
    <ol>
      <li>If <code class="language-plaintext highlighter-rouge">$A$</code> is undecidable, then <code class="language-plaintext highlighter-rouge">$B$</code> is also undecidable</li>
    </ol>
  </li>
  <li class="fragment">This will be our primary tool to prove that languages are <strong>undecidable</strong></li>
</ul>

<h2 id="another-example">Another Example</h2>
<p><strong>Claim:</strong> the following language is undecidable
 <code class="language-plaintext highlighter-rouge">$$T = \{\langle M \rangle \mid M\text{ is a TM that accepts }w^R\\
 \text{whenever it accepts }w\}$$</code></p>

<hr />

<ul>
  <li class="fragment"><strong>3-2-1-GO:</strong> Do you think this is true or false?</li>
</ul>

<h2 id="scratch-paper">Scratch Paper</h2>
<p><code class="language-plaintext highlighter-rouge">$$T = \{\langle M \rangle \mid M\text{ is a TM that accepts }w^R\\
 \text{whenever it accepts }w\}$$</code></p>

<hr />

<ul>
  <li class="fragment">To prove that it is undecidable, we could use a <strong>reduction</strong></li>
  <li class="fragment">If we can reduce a language we <strong>already know is undecidable</strong> to it, then we’re done
    <ul>
      <li class="fragment">Some good first candidates to try are <code class="language-plaintext highlighter-rouge">$A_\text{TM}$</code> or <code class="language-plaintext highlighter-rouge">$HALT$</code></li>
    </ul>
  </li>
</ul>

<h2 id="scratch-paper-1">Scratch Paper</h2>
<p><code class="language-plaintext highlighter-rouge">$$T = \{\langle M \rangle \mid M\text{ is a TM that accepts }w^R\\
 \text{whenever it accepts }w\}$$</code></p>

<hr />

<ul>
  <li class="fragment">Let’s try to reduce <code class="language-plaintext highlighter-rouge">$A_\text{TM}$</code> to <code class="language-plaintext highlighter-rouge">$T$</code>
    <ul>
      <li><code class="language-plaintext highlighter-rouge">$A_\text{TM} = \{\langle M,w\rangle \mid M\text{ is a TM that accepts }w\}$</code></li>
    </ul>
  </li>
  <li class="fragment">This means that <strong>given an algorithm for</strong> <code class="language-plaintext highlighter-rouge">$T$</code>, we need to come up with an algorithm for <code class="language-plaintext highlighter-rouge">$A_\text{TM}$</code></li>
  <li class="fragment">Thus we need to come up with a way of converting an input of <code class="language-plaintext highlighter-rouge">$A_\text{TM}$</code> to an input of type <code class="language-plaintext highlighter-rouge">$T$</code></li>
</ul>

<h2 id="proof-by-contradiction">Proof (by contradiction)</h2>
<ul>
  <li>Let <code class="language-plaintext highlighter-rouge">$R$</code> be a Turing machine that decides <code class="language-plaintext highlighter-rouge">$T$</code></li>
  <li class="fragment">It suffices to construct a decider <code class="language-plaintext highlighter-rouge">$S$</code> for <code class="language-plaintext highlighter-rouge">$A_\text{TM}$</code> using <code class="language-plaintext highlighter-rouge">$R$</code></li>
</ul>

<div class="language-plaintext fragment highlighter-rouge"><div class="highlight"><pre class="highlight"><code>S = "On input &lt;M,w&gt;,
   1. Using M and w, construct a new TM named M_w
   2. Run R on &lt;M_w&gt
   3. If R accepts, then ACCEPT; otherwise REJECT
</code></pre></div></div>

<ul>
  <li class="fragment">If we construct <code class="language-plaintext highlighter-rouge">$M_w$</code> right, then <code class="language-plaintext highlighter-rouge">$R$</code> will tell us the answer</li>
</ul>

<h2 id="finishing-the-proof">Finishing the Proof</h2>
<ul>
  <li>All we need now is to construct a machine <code class="language-plaintext highlighter-rouge">$M_w$</code> so that the following holds:
    <ul>
      <li><code class="language-plaintext highlighter-rouge">$\langle M_w\rangle \in T$</code> if and only if <code class="language-plaintext highlighter-rouge">$\langle M, w\rangle \in A_\text{TM}$</code></li>
    </ul>
  </li>
</ul>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>M_w = "On input x,
  1. If x = 01, then ACCEPT
  2. Else if x = 10, then
     a. Run M on w
     b. If it accepts, then ACCEPT; otherwise REJECT
  3. Else REJECT
</code></pre></div></div>

<ul>
  <li class="fragment">If <code class="language-plaintext highlighter-rouge">$M$</code> accepts <code class="language-plaintext highlighter-rouge">$w$</code>, then <code class="language-plaintext highlighter-rouge">$L(M_w)=\{01, 10\}$</code></li>
  <li class="fragment">If <code class="language-plaintext highlighter-rouge">$M$</code> does not accept <code class="language-plaintext highlighter-rouge">$w$</code>, then <code class="language-plaintext highlighter-rouge">$L(M_w)=\{01\}$</code></li>
  <li class="fragment">Thus running <code class="language-plaintext highlighter-rouge">$R$</code> on <code class="language-plaintext highlighter-rouge">$\langle M_w\rangle$</code> will tell us whether or not <code class="language-plaintext highlighter-rouge">$M$</code> accepts <code class="language-plaintext highlighter-rouge">$w$</code>—so <code class="language-plaintext highlighter-rouge">$S$</code> is a decider for <code class="language-plaintext highlighter-rouge">$A_\text{TM}$</code>—a contradiction</li>
</ul>

<h1 id="mapping-reductions">Mapping Reductions</h1>

<h2 id="computable-functions">Computable Functions</h2>
<ul>
  <li>A function <code class="language-plaintext highlighter-rouge">$f:\Sigma^\ast\rightarrow\Sigma^\ast$</code> is a <strong>computable</strong> if there exists a Turing machine <code class="language-plaintext highlighter-rouge">$M_f$</code> such that on every string <code class="language-plaintext highlighter-rouge">$w\in\Sigma^\ast$</code>, running <code class="language-plaintext highlighter-rouge">$M_f$</code> on <code class="language-plaintext highlighter-rouge">$w$</code> results in <code class="language-plaintext highlighter-rouge">$M_f$</code> halting with <code class="language-plaintext highlighter-rouge">$f(w)$</code> written on its tape.</li>
  <li class="fragment">Examples:
    <ul>
      <li>Multiplying by two: <code class="language-plaintext highlighter-rouge">$f(101) = 1010$</code></li>
      <li class="fragment">Bit flips: <code class="language-plaintext highlighter-rouge">$f(0110) = 1001$</code></li>
      <li class="fragment">All basic arithmetical functions are computable</li>
    </ul>
  </li>
</ul>

<h2 id="mapping-reductions-1">Mapping Reductions</h2>
<ul>
  <li>Language <code class="language-plaintext highlighter-rouge">$A$</code> is <strong>mapping reducible</strong> to <code class="language-plaintext highlighter-rouge">$B$</code> if there is a computable function <code class="language-plaintext highlighter-rouge">$f$</code>, where for every <code class="language-plaintext highlighter-rouge">$w\in\Sigma^\ast$</code>:
    <ul>
      <li><code class="language-plaintext highlighter-rouge">$w\in A$</code> if and only if <code class="language-plaintext highlighter-rouge">$f(w) \in B$</code></li>
    </ul>
  </li>
  <li class="fragment"><code class="language-plaintext highlighter-rouge">$f$</code> is called a <strong>reduction</strong> from <code class="language-plaintext highlighter-rouge">$A$</code> to <code class="language-plaintext highlighter-rouge">$B$</code></li>
  <li class="fragment">We also write <code class="language-plaintext highlighter-rouge">$A\le_m B$</code> if <code class="language-plaintext highlighter-rouge">$A$</code> is mapping reducible to <code class="language-plaintext highlighter-rouge">$B$</code></li>
</ul>

<h2 id="mapping-reductions-2">Mapping Reductions</h2>
<ul>
  <li>Recall that we previously reduced <code class="language-plaintext highlighter-rouge">$A$</code> to <code class="language-plaintext highlighter-rouge">$B$</code> where:
<code class="language-plaintext highlighter-rouge">$$A = \{\langle n\rangle \mid n\in\mathbb{Z}\text{ is even}\}$$</code>
<code class="language-plaintext highlighter-rouge">$$B = \{\langle n,d,r\rangle \mid n//d\text{ has remainder }r\}$$</code></li>
  <li class="fragment"><strong>3-2-1-GO:</strong> What <strong>reduction</strong> did we use?
    <ul>
      <li class="fragment"><code class="language-plaintext highlighter-rouge">$f(\langle n\rangle) = \langle n, 2, 0\rangle$</code></li>
    </ul>
  </li>
</ul>

<h2 id="mapping-reductions-3">Mapping Reductions</h2>
<ul>
  <li><strong>Important Note</strong>: If <code class="language-plaintext highlighter-rouge">$A \le_m B$</code> by <code class="language-plaintext highlighter-rouge">$f$</code>, then
    <ul>
      <li><code class="language-plaintext highlighter-rouge">$w\in A \iff f(w) \in B$</code></li>
      <li class="fragment">This if and only if has <strong>two directions</strong></li>
      <li class="fragment">if <code class="language-plaintext highlighter-rouge">$w\in A$</code>, then <code class="language-plaintext highlighter-rouge">$f(w)\in B$</code></li>
      <li class="fragment">if <code class="language-plaintext highlighter-rouge">$w\not\in A$</code>, then <code class="language-plaintext highlighter-rouge">$f(w)\not\in B$</code></li>
    </ul>
  </li>
</ul>

<h2 id="mapping-reductions-4">Mapping Reductions</h2>
<ul>
  <li><strong>Theorem:</strong> If <code class="language-plaintext highlighter-rouge">$A\le_m B$</code> and <code class="language-plaintext highlighter-rouge">$B$</code> is decidable, then <code class="language-plaintext highlighter-rouge">$A$</code> is also decidable</li>
</ul>

<div class="language-plaintext fragment highlighter-rouge"><div class="highlight"><pre class="highlight"><code>M_A = " On input w,
  1. Compute f(w)
  2. Run M_B on f(w) and output whatever it does"
</code></pre></div></div>

<ul>
  <li class="fragment"><strong>Corollary:</strong> If <code class="language-plaintext highlighter-rouge">$A\le_m B$</code> and <code class="language-plaintext highlighter-rouge">$A$</code> is undecidable, then <code class="language-plaintext highlighter-rouge">$B$</code> is undecidable.</li>
</ul>

<h2 id="using-mapping-reductions">Using Mapping Reductions</h2>
<ul>
  <li>Previously we showed that <code class="language-plaintext highlighter-rouge">$T$</code> is undecidable where:
<code class="language-plaintext highlighter-rouge">$$T = \{\langle M \rangle \mid M\text{ is a TM that accepts }w^R\\
 \text{whenever it accepts }w\}$$</code></li>
  <li class="fragment">We did this by reducing <code class="language-plaintext highlighter-rouge">$A_\text{TM}$</code> to <code class="language-plaintext highlighter-rouge">$T$</code></li>
  <li class="fragment">How could we formalize this as a mapping reduction?
    <ul>
      <li class="fragment">Construct a computable function <code class="language-plaintext highlighter-rouge">$f(\langle M,w\rangle) = \langle M_w\rangle$</code> such that</li>
      <li class="fragment"><code class="language-plaintext highlighter-rouge">$\langle M,w\rangle\in A_\text{TM}$</code> if and only if <code class="language-plaintext highlighter-rouge">$\langle M_w\rangle \in T$</code></li>
    </ul>
  </li>
</ul>

<h2 id="using-mapping-reductions-1">Using Mapping Reductions</h2>
<ul>
  <li>What we did before could be formalized this way:</li>
</ul>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>M_f = On input &lt;M, w&gt;
  1. Construct a Turing machine description M_w by:
       M_w = "On input x,
         1. If x = 01, then ACCEPT
         2. Else if x = 10, then
            a. Run M on w
            b. If it accepts, then ACCEPT; otherwise REJECT"
  2. Return &lt;M_w&gt;"
</code></pre></div></div>

<ul>
  <li class="fragment">Notice that <code class="language-plaintext highlighter-rouge">$M_f$</code> only takes a finite number of steps</li>
  <li class="fragment">And earlier we showed that <code class="language-plaintext highlighter-rouge">$\langle M,w\rangle \in A_\text{TM}$</code> if and only if <code class="language-plaintext highlighter-rouge">$\langle M_w\rangle \in T$</code>—therefore it proves that <code class="language-plaintext highlighter-rouge">$A_\text{TM} \le_m T$</code></li>
</ul>

<h2 id="mapping-reduction-exercise">Mapping Reduction Exercise</h2>
<p><code class="language-plaintext highlighter-rouge">$$\text{REGULAR}_\text{TM} = \{\langle M\rangle \mid L(M)\text{ is regular}\}$$</code></p>

<p class="fragment"><strong>Claim:</strong> <code class="language-plaintext highlighter-rouge">$A_\text{TM}\le_m \text{REGULAR}_\text{TM}$</code></p>

<hr />

<ul>
  <li class="fragment">Need to define a computable function <code class="language-plaintext highlighter-rouge">$f$</code> that:
    <ul>
      <li class="fragment"><code class="language-plaintext highlighter-rouge">$f(\langle M, w\rangle) = \langle \widehat{M}\rangle$</code></li>
      <li class="fragment"><code class="language-plaintext highlighter-rouge">$M$</code> accepts <code class="language-plaintext highlighter-rouge">w</code> if and only if <code class="language-plaintext highlighter-rouge">$L(\widehat{M})$</code> is regular</li>
    </ul>
  </li>
</ul>

<h2 id="mapping-reduction-properties">Mapping Reduction Properties</h2>
<ul>
  <li><strong>Theorem:</strong> If <code class="language-plaintext highlighter-rouge">$A\le_m B$</code> and <code class="language-plaintext highlighter-rouge">$B$</code> is Turing recognizable, then <code class="language-plaintext highlighter-rouge">$A$</code> is also Turing recognizable</li>
  <li class="fragment"><strong>Corollary:</strong> If <code class="language-plaintext highlighter-rouge">$A\le_m B$</code> and <code class="language-plaintext highlighter-rouge">$A$</code> is not Turing recognizable, then <code class="language-plaintext highlighter-rouge">$B$</code> is also not Turing recognizable</li>
  <li class="fragment">A language <code class="language-plaintext highlighter-rouge">$A$</code> is called <strong>co-Turing recognizable</strong> if <code class="language-plaintext highlighter-rouge">$\overline{A}$</code> is Turing recognizable</li>
  <li class="fragment"><strong>Theorem:</strong> A language is decidable if and only if it is both Turing recognizable and co-Turing recognizable</li>
</ul>

<h2 id="another-example-1">Another Example</h2>
<ul>
  <li><strong>Claim:</strong> The following language is nether Turing recognizable nor co-Turing recognizable</li>
</ul>

<p><code class="language-plaintext highlighter-rouge">$$EQ_\text{TM} = \{\langle M_1, M_2\rangle \mid M_1, M_2\text{ are TMs}\\
\text{ and }L(M_1)=L(M_2)\}$$</code></p>

<hr />

<ul>
  <li class="fragment">How do we approach proving this?</li>
</ul>