Decidability | CS 139: Theory of Computation

<h1 id="decidability">Decidability</h1>

<hr />

<h2 id="transition-to-remote-teaching">Transition to Remote Teaching</h2>
<ul>
  <li>Classes be online for <strong>at least</strong> two weeks</li>
  <li>Using <strong>Blackboard Collaborate Ultra</strong> (<strong>BCU</strong>) for remote class meetings</li>
  <li>Using <strong>Slack</strong> as a primary remote communication tool</li>
  <li>All other aspects of the course will remain the same</li>
</ul>

<h2 id="getting-familiar-with">Getting Familiar with</h2>
<h1 id="bcu">BCU</h1>

<h2 id="sharing-video">Sharing Video</h2>
<ul>
  <li>You are encouraged to share your video <strong>turned on</strong> during class meetings</li>
  <li>To turn it on, click the “Share Video” on the bottom of the window</li>
  <li>Try turning it on now (if you are comfortable)</li>
</ul>

<h2 id="using-microphone">Using Microphone</h2>
<ul>
  <li>At the start of class, I will <strong>mute</strong> all of your microphones</li>
  <li class="fragment">…but I want you to be able to use your microphone</li>
  <li class="fragment">Let’s take a moment to test everyone’s microphone
    <ul>
      <li>One-by-one, I am going to call your name</li>
      <li class="fragment">When I do, unmute your microphone and say “Hello!”</li>
      <li class="fragment">To unmute, click the microphone button at the bottom of the screen</li>
    </ul>
  </li>
</ul>

<h2 id="raising-your-hand">Raising Your Hand</h2>
<ul>
  <li>If you have a question, there is a <strong>raise your hand</strong> button at the bottom
    <ul>
      <li>This will get my attention while I am teaching</li>
      <li class="fragment">When you do this, I’ll pause and let you ask a question over your microphone</li>
    </ul>
  </li>
  <li class="fragment">Please keep your microphone muted unless you are asking a question or we are doing a group activity</li>
</ul>

<h2 id="using-the-chat">Using the Chat</h2>
<ul>
  <li>On the lower-right-hand-side of the screen there is a pink arrow</li>
  <li>Clicking it will reveal some interactive tools in BCU</li>
  <li>One feature we will be using some is the <strong>chat</strong> which is the left-most tab</li>
  <li class="fragment">At the top of the chat box, there is an <strong>Everyone</strong> label
    <ul>
      <li>When this is visible, your messages will be <strong>public</strong></li>
    </ul>
  </li>
  <li class="fragment">You can click “Everyone” to change the chat box to send <strong>private</strong> messages to me</li>
</ul>

<h1 id="exercise-1">Exercise 1</h1>
<h2 id="private--public-chat">Private / Public Chat</h2>
<ul>
  <li>Send a <strong>private</strong> message to me:
    <ul>
      <li>What is your favorite color?</li>
    </ul>
  </li>
  <li>Send a <strong>public</strong> message to everyone:
    <ul>
      <li>If you were an animal, what would you be?</li>
    </ul>
  </li>
</ul>

<h1 id="exercise-2">Exercise 2</h1>
<h2 id="3-2-1-go">3-2-1 GO</h2>
<ul>
  <li><strong>Question:</strong> Which of the following are true?
    <ul>
      <li><strong>A</strong>: Every regular language is Turing recognizable</li>
      <li><strong>B</strong>: Every Turing recognizable language is decidable</li>
    </ul>
  </li>
</ul>

<hr />

<p>TYPE YOUR ANSWER BUT DO NOT PRESS ENTER UNTIL I TELL YOU TO</p>

<h1 id="exercise-3">Exercise 3</h1>
<h2 id="think-pair-share">Think-Pair-Share</h2>
<p><strong>Question</strong>: What are the pros/cons of remote teaching?</p>

<hr />

<ul>
  <li class="fragment"><strong>THINK:</strong> Take one minute and jot down your thoughts</li>
  <li class="fragment"><strong>PAIR:</strong> Share your thoughts in a breakout session</li>
  <li class="fragment"><strong>SHARE:</strong> Afterwards, we’ll discuss as a large group</li>
</ul>

<h1 id="slack">Slack</h1>
<h2 id="for-remote-communication">for Remote Communication</h2>

<h2 id="slack-as-a-communication-tool">Slack as a Communication Tool</h2>
<ul>
  <li>Since we are remote, I want to be <strong>instantly available</strong> to all of you so that you can ask questions
    <ul>
      <li>Email is TERRIBLE for this</li>
    </ul>
  </li>
  <li class="fragment">Slack is a tool designed for remote collaborations, and we will be using it in the following ways</li>
</ul>

<hr />

<ol>
  <li class="fragment"><strong>General</strong> class questions in the <code class="language-plaintext highlighter-rouge">#general</code> channel</li>
  <li class="fragment"><strong>Assignment</strong> questions in the <code class="language-plaintext highlighter-rouge">#assignments</code> channel</li>
  <li class="fragment">Sending <strong>private</strong> messages to me</li>
  <li class="fragment">Sending <strong>private</strong> messages to your classmates</li>
</ol>

<h2 id="zoom-integrations-in-slack">Zoom Integrations in Slack</h2>
<ul>
  <li>A remote <strong>video conferencing tool</strong> is built into our Slack</li>
  <li>We can easily jump into a video chat if your question is complicated enough or if we need to share a whiteboard</li>
  <li class="fragment">You can also do this with your classmates!</li>
</ul>

<h2 id="office-hours-via-slack">Office Hours via Slack</h2>
<ul>
  <li>My office hours will now be <strong>Slack Hours</strong></li>
  <li>I will be available online at those times for instant communication and Zoom calls as necessary</li>
</ul>

<hr />

<ul>
  <li>Keep in mind that you may message me <strong>at any time</strong> via Slack, and I’ll still get back to you extremely quickly</li>
  <li>You can also make individual appointment meetings with me <strong>outside</strong> of Slack hours</li>
</ul>

<h1 id="recap">RECAP</h1>

<h2 id="models-of-computation">Models of Computation</h2>
<ul>
  <li>We’ve now seen many models of computation that can naturally be grouped into equivalence classes</li>
  <li class="fragment"><strong>Finite State Machines</strong>
    <ul>
      <li>DFAs, NFAs, Regex, …</li>
      <li>“Regular” languages</li>
    </ul>
  </li>
  <li class="fragment"><strong>Unlimited Memory Machines</strong>
    <ul>
      <li>Turing machines, lambda calculus, chemical reaction networks, tile self-assembly, …</li>
      <li>“Turing recognizable” languages</li>
      <li>“Turing decidable” languages</li>
    </ul>
  </li>
</ul>

<h2 id="turing-machines">Turing Machines</h2>
<p><img src="http://science.slc.edu/~jmarshall/courses/2006/spring/cs30/lectures/TMs/TuringMachine.gif" alt="Turing machine visualization" /></p>

<ul>
  <li>Can be described as a list of instructions of the form
    <ul>
      <li><code class="language-plaintext highlighter-rouge">$(q,a)\rightarrow (q',a',D)$</code></li>
      <li class="fragment">“If in state <code class="language-plaintext highlighter-rouge">$q$</code> while reading an <code class="language-plaintext highlighter-rouge">$a$</code> on the tape, then change to state <code class="language-plaintext highlighter-rouge">$q'$</code>, write an <code class="language-plaintext highlighter-rouge">$a'$</code> to the tape, and move the tape head in direction <code class="language-plaintext highlighter-rouge">$D\in\{L,R\}$</code>”</li>
    </ul>
  </li>
</ul>

<ul>
  <li><strong>Theorem</strong>: the regular languages are a <em>strict</em> subset of the decidable languages</li>
</ul>

<hr />

<ul>
  <li class="fragment">We proved this by converting an arbitrary DFA into an equivalent Turing machine
    <ul>
      <li>…and also showed that a non-regular language is Turing decidable</li>
    </ul>
  </li>
</ul>

<h2 id="low-level-turing-machines">“Low-Level” Turing Machines</h2>

<p><code class="language-plaintext highlighter-rouge">$$L = \{w\in\{0,1\}^\ast \mid \text{the second-to-last bit of }w\text{ is a 1}\}$$</code></p>

<hr />

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>start 0 _ R q0
start 1 _ R q1
start _ _ R halt-reject<br>
q0 0 _ R q00
q0 1 _ R q01
q0 _ _ R halt-reject<br>
q1 0 _ R q10
q1 1 _ R q11
q1 _ _ R halt-reject<br>
q00 0 _ R q00
q00 1 _ R q01
q00 _ _ R halt-reject<br>
q01 0 _ R q10
q01 1 _ R q11
q01 _ _ R halt-reject<br>
q10 0 _ R q00
q10 1 _ R q01
q10 _ _ R halt-accept<br>
q11 0 _ R q10
q11 1 _ R q11
q11 _ _ R halt-accept
</code></pre></div></div>

<h2 id="turing-machine-variants">Turing Machine Variants</h2>
<ul>
  <li>We also discussed how, surprisingly, every <strong>reasonable model</strong> of computation is <strong>no more powerful</strong> than a Turing machine
    <ul>
      <li class="fragment">Multiple tape Turing machines</li>
      <li class="fragment">Nondeterministic Turing machines</li>
      <li class="fragment">Enumerators</li>
      <li class="fragment">Python</li>
      <li class="fragment">Chemical reaction networks</li>
      <li class="fragment">Tile self-assembly</li>
    </ul>
  </li>
</ul>

<h2 id="high-level-turing-machines">“High-Level” Turing Machines</h2>
<p><code class="language-plaintext highlighter-rouge">$$L = \{\langle S, n\rangle \mid S\subseteq\mathbb{N}\text{ is finite and }n\in S\}$$</code></p>

<hr />

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>M = On input &lt;S,n&gt;,
  0. Check to see if &lt;S,n&gt; is properly formatted; if not,
     immediately REJECT
  1. For each element x in S
     a. Compare x to n
     b. If they are the same, then immediately ACCEPT; otherwise
        continue with the for-loop
  2. If we checked all elements of S and still did not find n,
     then REJECT
</code></pre></div></div>

<h2 id="common-mistake">Common Mistake</h2>
<p><code class="language-plaintext highlighter-rouge">$$L = \{\langle p\rangle \mid p\text{ is a polynomial with integral roots}\}$$</code></p>

<hr />

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>M = On input &lt;p&gt; where p is a polynomial over variables x1,...,xk,
  1. For each possible integral assignment of x1,...,xk:
     a. Evaluate the polynomial p with the current assignment
     b. If p evaluates to zero, then immediately ACCEPT
  2. If no assignment ever evaluates to zero, then REJECT
</code></pre></div></div>

<hr />

<ul>
  <li class="fragment">This machine <strong>does NOT</strong> decide <code class="language-plaintext highlighter-rouge">$L$</code> since the first step is</li>
  <li class="fragment">This machine <strong>does</strong> recognize <code class="language-plaintext highlighter-rouge">$L$</code> though</li>
</ul>

<h1 id="decidability-1">DECIDABILITY</h1>

<h2 id="decidability-2">Decidability</h2>
<ul>
  <li>From this point on, we will work almost exclusively with <strong>high-level</strong> Turing machines</li>
  <li class="fragment">We will explore the <strong>limits</strong> of Turing machines
    <ul>
      <li class="fragment">What they <strong>can compute</strong></li>
      <li class="fragment">What they <strong>cannot compute</strong></li>
    </ul>
  </li>
  <li class="fragment">As a result, we will explore more complicated languages of <strong>encoded objects</strong></li>
</ul>

<h2 id="deciding-string-encoded-dfas">Deciding String-Encoded DFAs</h2>
<p>Consider the following language
<code class="language-plaintext highlighter-rouge">$$A_\text{DFA} = \{\langle B,w\rangle \mid B\text{ is a DFA that accepts }w\}$$</code></p>

<hr />

<ul>
  <li class="fragment">For a Turing machine to decide this language it must
    <ul>
      <li class="fragment">Receive an arbitrary DFA <code class="language-plaintext highlighter-rouge">$B = (Q, \Sigma, \delta, q_0, F)$</code> and an arbitrary string <code class="language-plaintext highlighter-rouge">$w\in\Sigma^\ast$</code> as input</li>
      <li class="fragment">Check of <code class="language-plaintext highlighter-rouge">$B$</code> will accept the string <code class="language-plaintext highlighter-rouge">$w$</code></li>
    </ul>
  </li>
</ul>

<h2 id="exercise-think-pair-share">Exercise: Think-Pair-Share</h2>
<p>Suppose I asked you to write this function in Python:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">dfa_accepts</span><span class="p">(</span><span class="n">B</span><span class="p">,</span> <span class="n">w</span><span class="p">):</span>
  <span class="s">"""Returns True if the DFA B accepts w and False otherwise"""</span>
  <span class="p">...</span>
</code></pre></div></div>

<ul>
  <li><strong>Question 1</strong>: How would you encode the DFA <code class="language-plaintext highlighter-rouge">B</code>?</li>
  <li><strong>Question 2</strong>: How would you implement <code class="language-plaintext highlighter-rouge">dfa_accepts</code>?</li>
</ul>

<hr />

<h2 id="proof-sketch-for-a_textdfa">Proof Sketch for <code class="language-plaintext highlighter-rouge">$A_\text{DFA}$</code></h2>
<ul>
  <li>Suppose I have <code class="language-plaintext highlighter-rouge">$\langle B, w\rangle$</code> where
    <ul>
      <li><code class="language-plaintext highlighter-rouge">$B = (Q, \Sigma, \delta, q_0, F)$</code> and <code class="language-plaintext highlighter-rouge">$w\in\Sigma^\ast$</code></li>
    </ul>
  </li>
</ul>

<hr />

<div class="language-plaintext fragment highlighter-rouge"><div class="highlight"><pre class="highlight"><code>M = On input &lt;B,w&gt;
  1. Simulate B on w
  2. If B accepts, then ACCEPT
  3. If B rejects, then REJECT
</code></pre></div></div>

<hr />

<ul>
  <li class="fragment">Is <code class="language-plaintext highlighter-rouge">$M$</code> a reasonable high-level description?</li>
  <li class="fragment">Will it always halt?</li>
</ul>

<h2 id="another-example">Another Example</h2>
<p><code class="language-plaintext highlighter-rouge">$$ALL_\text{DFA} = \{\langle A\rangle \mid A\text{ is a DFA and }L(A)=\Sigma^\ast\}$$</code></p>

<hr />

<div class="language-plaintext fragment highlighter-rouge"><div class="highlight"><pre class="highlight"><code>M = On input &lt;A&gt; where A is a DFA
  1. Simulate the DFA A on all strings
  2. If it rejects any string, then REJECT
  3. If it accepts all strings, then ACCEPT
</code></pre></div></div>

<hr />

<ul>
  <li class="fragment">Notice a problem here?</li>
</ul>

<h2 id="exercise-think-pair-share-1">Exercise: Think-Pair-Share</h2>
<p>Again, I find it useful to think about Python:</p>

<div class="language-py highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">def</span> <span class="nf">dfa_accepts_everything</span><span class="p">(</span><span class="n">A</span><span class="p">):</span>
  <span class="s">"""Returns True if the DFA A accepts every string"""</span>
  <span class="p">...</span>
</code></pre></div></div>

<ul>
  <li><strong>Question</strong>: How would you implement this?</li>
</ul>

<hr />

<h2 id="proof-sketch-for-all_textdfa">Proof Sketch for <code class="language-plaintext highlighter-rouge">$ALL_\text{DFA}$</code></h2>
<ul>
  <li><strong>Idea</strong>: Check all the reachable states of <code class="language-plaintext highlighter-rouge">$A$</code> and make sure all of them are in <code class="language-plaintext highlighter-rouge">$F$</code></li>
</ul>

<div class="language-plaintext fragment highlighter-rouge"><div class="highlight"><pre class="highlight"><code>M = On input &lt;A&gt; where A is a DFA
  1. Mark the starting state of A
  2. Repeat until no more states can be marked this way:
     a. Iterate over each marked state and mark the states that are 
        immediately adjacent to it
  3. Check to see if every marked state is an accepting state,
     if so, ACCEPT, if not, REJECT
</code></pre></div></div>