# [FOM] Diagonalization Does Not Deliver Self-Reference

Sandy Hodges SandyHodges at attbi.com
Sat Dec 28 15:40:15 EST 2002

```If we want to write in an informal way the sentence used in the Gödel
proof, it would not be:

(1)   Sentence 1 is not provable.

but

(2) "Yields an unprovable sentence when applied to its own quotation"
yields an unprovable sentence when applied to its own quotation.

The difference between (1) and (2) is that (1) uses a noun phrase
"Sentence 1" that refers to a sentence, while (2) uses "its own" which
acts as a duplication operator.   These two methods can be considered
alternative ways of getting around the same problem, which is shown in
this sentence:

(3)  ~ Provable(N)

We can imagine searching for some N, such that when its digital
representation was put in for "N" in sentence (3), the result would be a
sentence whose Gödel number was N.   Of course no such N exists.
Another version of the problem arises with reference by quotation:

(3b) "______" is not provable.

We can imagine searching for some text, which can be put in for the
blank in (3b), such that the whole of the resulting sentence is just the
text we put in the blank.   But of course no such text exists.   Names
for sentences provide one way around this problem, because the name can
be shorter than the sentence itself.   An "its own" operation provides
another way around.

If a version of Gödel's proof was based on sentence (1), the result
would be less general.   Instead of a proof about any language that can
do basic arithmetic, it would only be a proof about any language that
can name its own sentences.   But it would be a valid proof; there is
nothing inherently informal or imprecise about a language having noun
phrases that can designate objects, nor any reason those objects can't
be the language's own sentences.

Professor Heck says: "We naturally speak of the Gödel sentence G for PA,
say, 'saying of itself' that it is not provable. But, in fact, the
sentence says, in the strict sense, no such thing. It too is simply
provably equivalent to a sentence that says of G that it is not
provable."    It is indeed true that G does not refer to itself by name.

Consider:

(4) "Was not spoken" yields an unprovable sentence when applied to its
own quotation.

(5) "Was not spoken" was not spoken.

(6) Sentence (5) is not provable.

(7)  "'Was not spoken' was not spoken." is not provable.

(8) Sentence (2) is not provable.

Does (4) say of (5) that it is not provable?   If yes, then (2) says of
(2) that it is not provable.   But if not, then (2) is merely provably
equivalent to (8), which does say of (2) that it is not provable.    But
(8) can say something about (2) only because I  established a convention
of using "(2)" as a name.   (7) has the best claim to say directly of
(5) that it is not provable, because it relies on neither a name
convention nor an "its own" operator.    (4) refers to (5) in an oblique
way - you have to apply the "its own" operator to the subject of (4), to
generate the thing that (4) is calling unprovable.    But (6) also
refers to (5) in an oblique way, you have to know the meaning I assigned
to "(5)". in order to learn what thing it is, that (6) is calling
unprovable.   I would say (4) has as good a claim to say of (5) that it
is not provable, as (6) does.
-----
If (2) does refer to itself (even if in a different way than (1) does),
does the formal version of (2) refer to itself also?

Let Prov(n) be a predicate of natural numbers,
Let Gn(x) be a mapping from symbol-strings to a subset of numbers,
Let digit(n) map number n to a string whose reference in the standard
interpretation is n,
Define: concat(x,y,z) to be the Gn of the concatenation of the 3 strings
of which x, y, and z are the Gn's

Define: diag(x) =def  concat(x, Gn(digit(x)), "))" )

Define: j =def  Gn( "~ Prov(diag(" )

Define: M to be the string that results from concatenating these three
strings: "~ Prov( diag(", digit(j), and "))".

[ For example, in one numbering, j is 1974917691.    So M would be "~
Prov( diag(1974917691) )" ]

To work out what number it is, that M is calling not Prov, you must
expand the "diag".   The result is that M is calling not Prov, this
number:

concat(   Gn( "~ Prov( diag(" ),   Gn(digit(j)),   Gn( "))" )  )

which is the Gn of M.    But does M say of itself that it has a Gn that
is not Prov?

Suppose Gn("0=1") = 801181.    Clearly "~ Prov(801181)" says of 801181
that it is not Prov.    It seems reasonable to say that "~ Prov(801181)"
says of "0=1" that its Gn is not Prov.    But what about
"~Prov(801100+81)"?  Does it say of "0=1" that its Gn is not Prov?
It is not so direct as  "~ Prov(801181)", admittedly.    But consider:

(A)  Define: a =def  801181
(B)   ~ Prov(a)

Does (B) say of "0=1" that its Gn is not Prov?    It seems to me odd to
assert that (B) says of "0=1" that its Gn is not Prov, while denying
that "~Prov(801100+81)" says this.

If  "~Prov(801100+81)" says of "0=1" that its Gn is not Prov, then "~
Prov( diag(1974917691) )" says of M, that its Gn is not Prov.

Thus I conclude that diagonalization does deliver self-reference that is
as good as self-reference by name.
-----

Heck's example:

(H1)     The right-hand side of (H1) is true iff 2+2=4.

corresponds to an "its own" based sentence:

(9)    "When applied to its own quotation, the rhs of sentence of the
sentence that results, is true if, and only if, 2+2=4" when applied to
its own quotation, the rhs of sentence of the sentence that results, is
true if, and only if, 2+2=4.

------- -- ---- - --- -- --------- -----
Sandy Hodges / Alameda,  California,   USA
mail to SandyHodges at attbi.com will reach me.

```