Comparing incompleteness arguments

Our informal incompletability results, Theorems 6.3 and 7.2, aren't the same as Gödel's own theorems. But they are close cousins, and they seem quite terrific results to arrive at so very quickly.

Or are they? Everything depends, for a start, on whether the ideas of a ‘sufficiently expressive’ arithmetic language and a ‘sufficiently strong’ theory of arithmetic are in good order. Still, as we've already briefly indicated in Section 3.1, there are a number of standard, well-understood, ways of formally refining the intuitive notions of effective computability and effective decidability, ways that turn out to specify the same entirely definite and well-defined class of numerical functions and properties. Hence the ideas of a ‘sufficiently expressive’ language (which expresses all computable one-place functions) and a ‘sufficiently strong’ theory (which captures all decidable properties of numbers) can in fact also be made perfectly determinate.

But, by itself, that claim doesn't take us very far. For it leaves wide open the possibility that a language expressing all computable functions or a theory that captures all decidable properties has to be very rich indeed. However, we announced right back in Section 1.2 that Gödel's own arguments rule out complete theories even of the truths of basic arithmetic. Hence, if our easy Theorems are to have the full reach of Gödel's work, we'll really have to show (for starters) that the language of basic arithmetic is already sufficiently expressive, and that a theory built in that language can be sufficiently strong.

Our first main theorem in this chapter establishes the ‘recursive unsolvability of the self-halting problem’ for Turing machines. This is one of those pivotal results like the Diagonalization Lemma which at first sight can seem just an oddity but which entails a whole raft of important results. We use this theorem to establish (or re-establish) various claims about incompleteness and decidability.

We also prove a version of Kleene's Normal Form Theorem: this leads to yet another proof of incompleteness.

Two simple results about Turing programs

(a) As a preliminary, let's note

Proof sketch Use some system for Gödel-numbering sets of i-quadruples. For example, use powers of primes to code up single i-quadruples; then form the super g.n. of a sequence of codes-for-quadruples by using powers of primes again.

Now run through numbers e = 0, 1, 2, …. For each e, take prime factors of e, then prime factors of their exponents. If this reveals that e is the super g.n. of a set of i-quadruples, then check that it is a consistent set and hence a Turing program (that is an effective procedure, and the search is bounded by the size of the set of i-quadruples). If e is the super g.n. of some Turing program Π, put Πe = Π; otherwise put Πe = Π* (where Π* is some default favourite program). Then Π0, Π1, Π2, … is an effectively generated list of all possible Turing programs (with many repetitions).

We are not going to write any more programs to show, case by case, that this or that particular function is Turing-computable, not just because it gets painfully tedious, but because we can now fairly easily establish that every μ-recursive function is Turing-computable and, conversely, every Turing-computable function is μ-recursive. This equivalence between our two different characterizations of computable functions is of key importance, and we'll be seeing its significance in the remaining chapters.

μ-Recursiveness entails Turing computability

Every μ-recursive function can be evaluated ‘by hand’, using pen and paper, prescinding from issues about the size of the computation. But we have tried to build into the idea of a Turing computation the essentials of any hand-computation. So we should certainly hope and expect to be able to prove:

Proof sketch We'll say that a Turing program is dextral (i.e. ‘right-handed’) if

1. i. in executing the program – starting by scanning the leftmost of some block(s) of digits – we never have to write in any cell to the left of the initial scanned cell (or scan any cell more than one to the left of that initial cell); and

2. ii. if and when the program halts, the final scanned cell is the same cell as the initial scanned cell.

In this chapter, we note two different ways in which our incompleteness proofs can readily be extended in scope. First, the requirement for p.r. axiomatization can be weakened: the incompleteness theorems will apply to any effectively formalized theory. Second, we show how to get the theorems to apply to certain theories which aren't initially about arithmetic at all.

The second extension is much more important than the first. Formalized-butnot- p.r.-axiomatized theories are mostly strange beasts of little intrinsic interest, though we do extract a neat result by considering them. On the other hand, there is immediate interest in the claim that e.g. set theory – although not natively about numbers – must also be incomplete for Gödelian reasons.

Generalizing beyond p.r. axiomatized theories

(a) Our intuitive characterization of a properly formalized theory T requires various properties like that of being an axiom of T to be effectively decidable. Given a sensible Gödel numbering scheme, that means that the characteristic functions of numerical properties like that of numbering a T-axiom should be effectively computable (see Sections 4.3 and 14.6). But we now know that not all computable functions are p.r. (Section 14.5). Hence we could in principle have an effectively axiomatized theory which isn't primitive-recursively axiomatized (in the sense of Section 22.1). Does this give us wriggle room to get around the Gödelian incompleteness theorems in the last chapter? Could there for example be a consistent effectively formalized theory of arithmetic containing Q which was complete because not p.r. axiomatized?

Well, as we noted in Section 23.1, a theory T that is effectively axiomatized but not p.r. axiomatized will be a rather peculiar beast; checking that a putative T-proof is a proof will then have to involve a non-p.r. open-ended search, which will make T very unlike the usual kind of axiomatized theory. Still, you might say, an oddly axiomatized arithmetic which is complete would still be a lot better than no complete formal theory at all. However, we can’t get even that.

(b) …

I can't resist briefly noting here some rather striking results about the length of proofs. And it is indeed worth getting to understand what the theorems say, even if some of the proofs in this chapter are perhaps just for enthusiasts.

The length of proofs

We might expect that, as a general tendency, the longer a wff, the longer its proof (if it has one). But can there be any tidy order in this relationship in the case of nice theories?

We will say that a proof for φ is f-bounded, for a given function f, if the proof's g.n. is less than f(φ). Then it would indeed be rather tidy if, for some theory T, there were some corresponding p.r. function fT which puts a general bound on the size of T-proofs – meaning that, for any φ, if it is a provable at all, it has an fT -bounded proof. However, unfortunately,

Proof sketch Suppose the theorem is false. That is, suppose that there is a p.r. bounding function fT such that for any φ, if it is T-provable at all, it has a fT-bounded proof. Then there would be a p.r. procedure for testing whether φ has a proof in T. Just calculate fT(φ), and do a bounded search using a ‘for’ loop to run through all the possible proofs up to that size to see if one of them is in fact a proof of φ.

In the main part of this chapter, we introduce Gödel's simple but wonderfully powerful idea of associating the expressions of a formal theory with code numbers. In particular, we will fix on a scheme for assigning code numbers first to expressions of LA and then to proof-like sequences of such expressions. This coding scheme will correlate various syntactic properties with purely numerical properties – in a phrase, the scheme arithmetizes syntax.

For example, take the syntactic property of being a term of LA. We can define a corresponding numerical property Term, where Term(n) holds just when n codes for a term. Likewise, we can define Atom(n), Wff (n), and Sent(n) which hold just when n codes for an atomic wff, a wff, or a closed wff (sentence) respectively. It will be easy to see – at least informally – that these numerical properties are primitive recursive ones.

More excitingly, we can define the numerical relation Prf (m, n) which holds just when m is the code number in our scheme of a PA-derivation of the sentence with number n. It will also be easy to see – still in an informal way – that this relation too is primitive recursive.

The short second part of the chapter introduces the idea of the diagonalization of a wff. This is basically the idea of taking a wff φ(y), and substituting (the numeral for) its own code number in place of the free variable. We can think of a code number as a way of referring to a wff.