Logic 3003 Spring 2005 Notes on paradoxes and the limits of formal methods.
I.
The Liar:
Suppose we interpret our language as, in part, allowing us to talk about the language itself. In
fact, of course, this is something we do already in English & other natural languages: We describe the
vocabulary and the grammar of English sentences in English. We even use an English word to distinguish
the (declarative) sentences we are correct to endorse/accept/assert from those we would be wrong to take
these attitudes towards: The word is ‘true’.
Similarly, in a formal language such as Lq we might have predicates in the language that we
interpret as applying to all and only those things that are proper names, arbitrary names, variables and
predicate letters, unary connectives and binary connectives, etc. in the language. In this language we might
be able to write axioms expressing the rules of our grammar, so that we could build on these categories,
together with the theory of identity, to define the wffs of the language in the language. And we could go
still further, writing axioms describing sequences of wffs that follow our proof rules. At that point, the
language would be (on this interpretation) understood as giving an account of the formal system we have
been studying.
The question here is, how far can we go with this? In particular, if the language is powerful
enough to describe its own rules of grammar, its own wffs, and its rules for constructing proofs, we might
ask if the language could also include its own truth predicate, a predicate letter whose combination with a
nominal to form an atomic wff or propostional function, would be satisfied if and only if the nominal were
assigned to a true sentence in the language?
It seems that English contains such a predicate: “___ is true” intuitively holds if and only if we
replace ‘___’ with a name or pronoun referring to a true sentence in English. So in effect what we’re
asking is whether a formal language like our Lq could contain a predicate that could be interpreted as
meaning ‘___ is true in Lq’. The idea is to set the interpretation of T up so that it will accord with our
formal account of truth, i.e. satisfaction. That is, we will set things up so that, where m is assigned to name
a wff of Lq, Tm will be a wff in the language, and Tm will satisfied in M at  if and only if m is satisfied in
M at .
But the answer to our question is that we can’t have such a predicate (at least, not without
substantial modifications of our logical system). Consider the following sentence:
m is not true.
So far there’s nothing terribly wrong here. All we need to express this sentence is our truthpredicate, a negation, and a name. So if T is our special truth predicate, we could write this sentence as
Tm
Now, m is just a proper name; when our language is interpreted as being (at least in part) about the
language itself, a proper name like m may refer to a sentence. So on one hand, if m is not interpreted as
referring to a wff in our model, then Tm will be satisfied at every assignment in our model; i.e. M,  
Tm for all assignments . But if m is interpreted as naming a wff, then M,  Tm if and only if m
names a sentence in L that is not satisfied in M at , i.e. iff M,  I(m). (Recall that a model M = <D,I>,
an ordered pair of a domain and an interpretation, and I(m) is the member of the domain that the
interpretation assigns to the proper name m.)
Now we’re ready for a nasty turn. Suppose we have a model on which the wff that m names is the
very sentence ‘Tm’. There is nothing to prevent us having such a model—if m names a sentence, then
it’s easy to choose an interpretation on which that sentence is the very sentence that (on our interpretation)
says of m that it is not satisfied. But then M,   Tm if and only if M,  I(m), but I(m) = Tm, so M, 
  Tm if and only if M,  Tm. And this is a contradiction!
If our language can be interpreted as including its own truth predicate and names for all of its
sentences, then it will allow us to construct a wff which can be interpreted (in some model, assignment pair
M, ) as saying of itself that it is not true (simply by interpreting the name m as referring to the wff
constructed by applying the negation of the ‘truth’ predicate to m). But such a sentence will be satisfied in
M at  if and only if it is not satisfied in M at . That is, we cannot consistently suppose either that it is
satisfied or that it is not satisfied.
We have carefully set up our rules for models and assignments so that each and every sentence in
the language is either satisfied or not satisfied for any well-characterized model, assignment pair. So there
is no class of model, assignment pairs M,  that is
1.
Closed under simple re-interpretions of the proper names for Lq, and that
2.
Always assigns to the extension of T (or any predicate letter of Lq) all and only the wffs of Lq
satisfied in M, .
If there were such a class of model, assignment pairs, then we can see that there would be a model,
assignment pair that assigned m as the name of the wff ‘Tm’, and in that model-assignment pair it’s clear
that T can not have all and only the satisfied sentences in its extension. The key reason for this difficulty is
that which wffs involving this ‘truth’ predicate should be satisfied in the model at that assignment depends
on which wffs are satisfied in the model at the assignment, and we can use ‘’ to tangle this dependence
into a contradictory knot.
II.
Gödel.
Kurt Gödel’s first incompleteness result is very closely related to this informal puzzle about truth.
But Gödel’s work was far more thorough and formal. Gödel showed that a first-order theory of arithmetic
(i.e. a first-order language supplemented by axioms allowing us to define numbers and basic operations on
numbers) would have enough expressive power to have predicates interpretable as picking out the wffs of
the language, as separating the sequences of wffs that are proofs from those that are not, and as
distinguishing the wffs that are theorems from the wffs that are not. Gödel’s method was to arithmetize the
language and the rules of the language, and show that arithmetic could then be used to draw these lines.
Gödel then posed a very closely related question: Could such a first-order theory of arithmetic be
complete? You might think that we’ve already answered that question here, by showing that whenever 
A holds in our first-order language, A. But Gödel has a different notion of completeness in mind—
completeness in his sense is a matter of capturing all the truths of arithmetic, that is, all the truths we can
intuitively prove in arithmetic. So the fact that every wff satisfied in all the models that satisfy the axioms
of this first order theory of arithmetic is provable from the axioms of our theory is not enough for Gödel.
His question is, is this class of models the intended class of models, i.e. the models of arithmetic, or is it
some larger class that includes models of arithmetic along with models of other theories that are not models
of arithmetic at all? That is, can we completely axiomatize arithmetic (using a finite number of axioms or
axiom schemata)?
What Gödel’s first incompleteness result shows is that for any such axiomatization there is a
sentence that is intuitively true, but which cannot be proven unless the entire system is inconsistent (and an
inconsistent system has no model at all, let alone a model that is a model of arithmetic). Rather than focus
on truth, Gödel focused on provability. As I said above, a language in which we can define numbers and
certain (recursive) operations on numbers will be strong enough to express the provability predicate of the
system, i.e. to distinguish the wffs that are theorems from those that are not. But Gödel showed that such a
language will be strong enough to ensure that there is a sentence that can be interpreted as saying, of itself,
that it is not provable. And for such a sentence there are two possibilities. If it is provable after all, then
the system is inconsistent and every sentence is provable. But if it is not provable, then what we have
interpreted it as saying, is a true claim in the language of arithmetic. So either our theory of arithmetic is
inconsistent, or it is incomplete.
A second Gödelian incompleteness result shows something a little more general, and very
startling indeed: If we can prove that our theory of arithmetic is consistent—which is equivalent to proving
that there is at least one sentence that cannot be proven in the system given the axioms—then our theory
must be inconsistent. The reason for this is a bit subtle, but we can draw on what we’ve already said to
motivate it. Consider the Gödel sentence, G. G can be interpreted as saying of itself that it is unprovable.
Obviously, if our system of arithmetic is inconsistent, G is provable (along with every other sentence), and
so (on our interpretation) G is false. On the other hand, if our system of arithmetic is consistent, we won’t
be able to prove G. But if we could prove that we can’t prove it, we will have proven it after all: After all,
G says that G is unproveable, so a proof that G is unproveable is a proof of G! The unprovability of the
Gödel sentence follows from the assumption of consistency. Therefore, if we could prove consistency, we
could prove the Gödel sentence. But that would prove the inconsistency of the system. So if the system is
consistent, we won’t be able to prove its consistency. If the system is inconsistent, of course, we can
‘prove’ in the system a sentence that we interpret as saying that it is consistent—but that proof is worthless,
since it’s conducted in a system that allows us to prove anything at all.
The lesson here is fundamental: Once a system gets strong enough to express the key ideas of
arithmetic, it cannot, on pain of inconsistency, prove its own consistency. Hilbert’s ideal of a selfcontained, provably consistent system in which we can capture the basic mathematics of arithmetic is a
will-of-the-wisp, an impossibility.
III.
Turing and the halting problem.
Alan Turing was one of the great pioneers of computing. His ‘Turing machine’ is still one of the
most fundamental approaches to describing what can be ‘calculated’ by a well-defined procedure. He too
encountered paradoxical limitations on what can be calculated or computed by a Turing machine. The
problem at the heart of Turing’s puzzle is the so-called halting problem, the problem of determining, for a
given program (computational procedure) and a given input to that program, whether the program will ever
finish its computation, or whether it will get stuck in an infinite loop somewhere.
This problem is very closely related to Gödel’s first incompleteness result, since it turns out that
any procedure that would settle any question of arithmetic (i.e. any question about the natural numbers)
could be translated into a procedure for determining if a given algorithm could be completed given a certain
input.
The problem is also closely related to Godel’s incompleteness result in the way that it’s generated.
The argument is a reductio. Suppose we have a procedure (algorithm) that decides, for any given
algorithm, input pair, whether the algorithm will halt (finish its calculation) or not. The input for this
supposed algorithm is any pair of an algorithm with some input to that algorithm. If this algorithm works,
then it will eventually produce either the answer ‘true’ if the algorithm, input pair will indeed halt, or the
answer ‘false’ if it won’t. We call the halting algorithm ‘halt’.
Now consider a troublesome algorithm s:
function trouble(string s)
if halt(s, s) = false
return true
else
loop forever
(Source: Wikipedia.)
So our troublesome algorithm s halts if and only if, given itself as input, our halt algorithm says
that it doesn’t halt. We can easily write this algorithm if we have the halt algorithm in hand. But it’s
contradictory to suppose that an algorithm, input pair halts if and only if it doesn’t halt! We cannot have a
halting algorithm, on pain of contradiction.
All these puzzles and paradoxes rely on using a kind of inversion, in which a sentence says of
itself that it’s false, or that it’s unproveable, or an algorithm, input pair is designed so that it will halt if and
only if it is determined not to halt by our supposed ‘halting’ algorithm. In each case, contradictory results
are easy to obtain, once we assume that we have a ‘truth’ predicate in our language, or that we can prove
every truth of arithmetic, or that we can produce an algorithm that determines, for any algorithm, input pair,
whether the resulting computation terminates.
There is lots more to say about these puzzles and philosophers’ and mathematicians’ responses to
them – the liar paradox goes back to the ancient Greeks, and logicians today still wrestle with how best to
deal with it. My own view is that it should be seen as a lesson about the expressive power of language and
the limits of certain idealizations about language. A language with great expressive power—enough power
to express our ideas about mathematics—can be interpreted in the formal way we have assumed in our
account of models and assignments. But only if we restrict the language (or what we expect the system to
do) in some way. It must be incomplete (in the sense that we cannot prove either A or A for every
sentence A—though of course we can prove the disjunction A  A). And it must not include a ‘truth’
predicate. And it cannot provide a general procedure for determining which procedures come to a halt and
which loop infinitely.