First-order logic
The main theorem of last semester was that the set of logical consequences of any r.e. set of axioms is r.e.
Today we will prove that the set of logical truths(logical consequences of no axioms)in any sufficiently rich language is not decidable.
"Mathematicians will never be out of a job---since they can't be replaced by a machine."
(Last semester's result was that mathematicians can do their job: if it follows there
is a proof.)
As always, we shall prove that logical truth is hard by reducing it to the halting problem. That is, we shall show how, for any register machine

in the language

to produce (using a recursive procedure) a sentence of first-order logic

such that
Remarks: Let

be a program in the language

with instructions

. Let

be the smallest number such that all the registers occurring in

are among

. A
configuration is an

-tuple
with

The intended interpretation of a configuration is that the machine is executing instruction

and each register

has

strokes in it. We say that a configuration is the configuration of the machine after

steps if ... . In particular, the
initial configuration, that is, the configuration after 0 steps is

.
The only halt instruction is

, and so the machine halts if and only if the is some step

such that the configuration at step

is

for some numbers

.
If

halts, let

be the step at which it does.
Finally, let our symbol set be

, where

is an

-ary relation,

is binary,

is unary, and

is a constant symbol.
Motivation: For program

let

be an associated structure defined as follows:
-
does not halt. The domain of the structure
is
(the natural numbers).
is the obvious thing,
is 0,
is the successor function (+1).
holds if and only if ... .
-
halts. Let
be max
. The domain
of our structure will be
. < and
are interpreted as before: < is the obvious order, and
is 0.
has to get changed: it can't be the successor function because we've left out the successor of
. So, let
be the successor function except on
, and let
. Let
be interpreted as before.
The structures were just to help us see what we're doing, what we really need is a sentence, and we turn to that now.
We break the project up into parts.
First, we define

which describes what

does on the empty input. We'll have to add that

halts later.
We write

for

with

s.
Now, the heart of the proof, the instructions:
If

is an add instruction, say, L LET

, then
Subtract instructions are just the same.
PRINT instructions "do nothing." That's ok because for this problem we don't care about what gets printed.
Finally, jumps:
That completes

. Finally, the sentence we need,

is
That does it: Suppose

is a logical truth. Then, whenever

holds, that is, whenever we have a machine

computation, it reaches a halt instruction. Thus, if we could decide what sentences are logical truths, we could
decide the halting problem, and so the problem of deciding logical truth is also unsolvable.
-- ProfessorShaughanLavine? - 09 Feb 2005