The Timpson Lyceum · Computation Theory

Lecture 16 (Computation Theory) Decidability and Undecidability

Decidability and Undecidability – Lecture 16

Overview

This lecture establishes the boundary between what computers can and cannot do. It opens by recapping the many languages already shown decidable (the acceptance and emptiness problems for DFAs, NFAs, regular expressions, and context-free grammars), then pivots to a fundamentally different kind of argument: proving that some problems are undecidable or even unrecognizable. The central tools are cardinality and diagonalization — the idea that two sets have the same size exactly when a bijection exists between them. Using these, we show the real numbers are uncountable, that there are uncountably many languages but only countably many Turing machines, and finally that the acceptance problem for Turing machines ( $A_{TM}$ ) is undecidable. The punchline: there exist well-defined problems for which no algorithm can ever exist.

Key Concepts

Decidable vs. recognizable.

A language is decidable if some Turing machine halts on every input and correctly answers yes for strings in the language and no for strings not in it.
A language is (Turing-)recognizable if some Turing machine answers yes for every string in the language, but may loop forever (never halt) on strings not in it.
Every decidable language is recognizable; the converse fails.

Languages already known decidable (proved by constructing a deciding machine):

$A_{DFA}$ , $A_{NFA}$ , $A_{REX}$ — acceptance problems for DFAs, NFAs, and regular expressions.
$E_{DFA}$ (emptiness) and $EQ_{DFA}$ (equivalence of two DFAs).
$A_{CFG}$ (a grammar generates a string) and $E_{CFG}$ (emptiness); in fact every context-free language is decidable.

Same cardinality via bijection.

$|A| = |B|$ if and only if there exists a bijection $f : A \to B$ .
A bijection is one-to-one (injective: equal outputs force equal inputs) and onto (surjective: every element of $B$ is hit).
You need not count two sets to compare them — pairing their elements off suffices (e.g. left hands and right hands in a room).

Countable vs. uncountable.

A set is countable if its cardinality is $\le |\mathbb{N}|$ (finite, or in bijection with $\mathbb{N}$ ).
$\mathbb{N}$ , $\mathbb{Z}$ , and $\mathbb{Q}$ are all countable — even though each appears "bigger" than the last.
$\mathbb{R}$ (and even just the open interval $(0,1)$ ) is uncountable: no bijection from $\mathbb{N}$ exists.

Cantor diagonalization. To show $(0,1)$ is uncountable, assume a bijection $f : \mathbb{N} \to (0,1)$ exists and build a number $x = 0.d_1 d_2 d_3 \ldots$ that differs from $f(n)$ in the $n$ -th decimal place (e.g. add 1 to that digit, mapping 9 to 8). Then $x \neq f(n)$ for every $n$ , so $f$ is not onto — a contradiction. The same argument shows $\beta$ , the set of all infinite binary strings, is uncountable.

Counting Turing machines. Every Turing machine $M = (Q, \Sigma, \Gamma, \delta, q_0, q_{accept}, q_{reject})$ is built from finite sets, so each has a finite encoding $\langle M \rangle$ as a string. Listing all finite binary strings in order eventually lists every machine, so the set of Turing machines is countable.

An unrecognizable language must exist. Let $L$ be the set of all binary languages — equivalently the power set of $\Sigma^*$ . One can biject $L$ with $\beta$ (map each language to its characteristic sequence: the $i$ -th bit is 1 iff the $i$ -th string of $\Sigma^*$ is in the language). Since $\beta$ is uncountable, so is $L$ . There are only countably many Turing machines, each recognizing exactly one language, so some languages are recognized by no machine at all.

$A_{TM}$ is undecidable. $A_{TM} = \{\,\langle M, w\rangle \mid M \text{ is a TM that accepts } w\,\}$ . It is recognizable (simulate $M$ on $w$ and accept if $M$ does) but not decidable.

Problems = languages. A language is a computation theorist's encoding of a problem; "no Turing machine recognizes $L$ " means "no algorithm solves that problem." Practical consequences: no compiler/IDE can decide in general whether an arbitrary program crashes (the halting problem), and there is no general algorithm to decide whether an arbitrary Diophantine equation has an integer solution (recognizable but not decidable). The halting problem is the usual alternative starting point; its proof mirrors the one below.

Worked Example

Proving $A_{TM}$ is undecidable (diagonalization). Assume, for contradiction, that $A_{TM}$ is decidable, so some TM $H$ decides it:

\begin{aligned} H(\langle M, w\rangle) &= \texttt{accept} \iff M \text{ accepts } w \\ H(\langle M, w\rangle) &= \texttt{reject} \iff M \text{ does not accept } w \end{aligned}

Build a new machine $D$ that, on input $\langle M\rangle$ , runs $H$ on $M$ paired with its own encoding and then flips the answer:

\begin{aligned} D(\langle M\rangle) &= \texttt{accept} \iff H(\langle M, \langle M\rangle\rangle) = \texttt{reject} \\ &= \texttt{accept} \iff M \text{ does not accept } \langle M\rangle \end{aligned}

Now feed $D$ its own encoding $\langle D\rangle$ :

\begin{aligned} D \text{ accepts } \langle D\rangle &\iff D \text{ does not accept } \langle D\rangle \end{aligned}

This is a contradiction — $D$ both accepts and does not accept itself. Therefore $D$ cannot exist; but $D$ is easily built from $H$ , so $H$ cannot exist either. Hence no machine decides $A_{TM}$ , and $A_{TM}$ is undecidable. (Diagonally: list machines $M_1, M_2, \ldots$ down the rows and their encodings across the columns, filling each cell with $H$ 's verdict; $D$ is forced to be the opposite of the diagonal entry, so when the diagonal reaches $D$ 's own row it must differ from itself.)

Summary

Decidable means a TM halts and decides yes/no on every input; recognizable means it accepts every yes-instance but may loop on no-instances. Decidable $\subsetneq$ recognizable.
Two sets have equal cardinality exactly when a bijection (one-to-one and onto) connects them; this lets us compare infinite sets without counting.
$\mathbb{N}, \mathbb{Z}, \mathbb{Q}$ are countable; $\mathbb{R}$ , the interval $(0,1)$ , and the set $\beta$ of infinite binary strings are uncountable, proved by diagonalization.
Turing machines are countable (finite encodings), but the set of all languages is uncountable (it bijects with $\beta$ ), so unrecognizable languages must exist.
The acceptance problem $A_{TM}$ is recognizable but undecidable, proved by a self-referential machine $D$ that contradicts itself on its own encoding.
Languages model problems, so undecidability means there are genuinely unsolvable problems — e.g. detecting in general whether a program halts/crashes, or whether a Diophantine equation has a solution.