2018-03-06

Applying Strawsonian Logic to

Computability
by X.Y. Newberry

1
In Strawsonian logic 1) vacuous sentences are considered ~(T v F). For example

(x)(x ≠ x --> x = x+1)

is ~(T v F).

*******

Gödel’s sentence is vacuous:

~(∃x)(∃z)( Prf(x,z) & Diag(k,z) ) (G)

Here Prf() is the proof predicate of PA, and Diag(k,z) is such that it is satisfied only by g =
the Gödel number of G 2). Then

~(∃x)( Prf(x,g) & Diag(k,g) )

is equivalent to

(x)( Prf(x,g) -> ~Diag(k,g) )

The above is vacuous since ~(Ex)Prf(x,g). Hence G is ~(T v F)! 3)

*******

What does this imply for computability? Consider the following two programs.

ProgPrf() {
x := 0
while(true) {
if ( Prf(x,g) ) then halt
x := x+1
}
}

ProgSelf() {
x := 0
while(true) {
if ( Prf(x,g) & Diag(k,g) ) then halt
x := x+1
}
}

1 Strawson (1952, pp. 163-179)

2 We are using a format similar to Suber (2002)
3 Newberry (2016)

2
It is false that ProgPrf() halts, but it is not true that ProgSelf() halts. False is a proper
subset of not true. The first result is stronger! Note that ProgSelf() is attempting to say
about itself that it does not halt, ProgPrf() is attempting to say about Prog_2() that it does
not halt.

*******

So we have the result that it is not true that either program halts, and it is also false that
ProgPrf() halts. Now we need to make some sense of this. Obviously none of the programs
halts. So we will take the natural language statement “program P does not halt on input
q” as “it is not true that P halts on q”. But how do we interpret false?

Observe that if ProgSelf() halted it would assert that it itself does not halt. So as long as
Prf() is consistent ProgSelf() will be stuck in an infinite loop. It is impossible to prove
directly that a self-referential, self-contradictory program such as ProgSelf(), does not
halt. However this restriction does not apply to ProgPrf(). Suppose there exists a
predicate Prf*() such that for any n

(∃x)Prf(x, n) & (∃x)Prf(x,n) is not vacuous 4) < --> (∃x)Prf*(x, n)

Suppose further that there is a predicate Prf+() such that for any n

(∃x)Prf*(x, n) --> (∃x)Prf+(x, n)

and in addition Prf+() also proves

~(∃x)Prf+(x, g+)

[but not ~(∃x)(∃z)( Prf+(x, z) & Diag(k+, z) ).] We have a direct proof that ProgPrf+() does
not halt. But is this a contradiction? Does the proof that ProgPrf+() does not halt imply
that ProgSelf+() does not halt? Not if we interpret the existence of a direct proof that
ProgPrf+() does not halt as the falsehood of “ProgPrf+() halts”. So this just what we will
do. We know what it means for a program to halt. But for the halt statement to be false
some other program must halt. You can think of it as a verification of the negation.

4 The second term of the conjunction is a presupposition. Strawson (1952, pp. 163-179).

3
 *******

Let us transpose the problem into “pure” computability domain. Assume that every
program can be converted into the following canonical form.

Prog_p(q) {
x := 0
while(true) {
if ( Predicate_p(x,q) ) return x
x := x+1
}
}

The predicate Prf() is rather a powerful determiner. 5) In many cases it can prove a
[classically] true formula of the type ~(Ex)Predicate_p(x,q), and in all the cases it can
prove a true formula of the type (Ex)Predicate_p(x,q). The first case corresponds to
proving that a program does not halt, the second to proving that a program does halt. Let
A(p,q) be a program 6) such that if it halts then ~(Ex)Predicate_p(x,q). In particular we
will define A() such that it halts iff Prf() proves ~(Ex)Predicate_p(x,q). Furthermore let
B(p,q) be a program that halts iff Prf() proves (Ex)Predicate_p(x,q). Actually B() is nothing
but an emulator. Executing A() and B() in parallel is equivalent to executing a determiner
based on Prf(). Symbolically we can express this as
H(p, q) = A(p, q) || B(p, q)

But we can do even better and postulate A+(p, q) such that it halts iff Prf+() proves
~(Ex)Predicate_p(x,q).

Let us now construct a program 7)

C_k(n) {
A+(q,q)
}
and

5 The emphasis is on the ability to determine halting; not necessarily implying that it occurs in all cases..
6 This idea is due to Penrose (1994, pp. 73-75)
7 Newberry (2017)

4
C_s() {
C_k(s)
}

C_k() is analogical to ProgPrf+() and C_s() is analogical to ProgSelf+(), except that the
former ones indicate only that a program does not halt. Program A+() might be
implemented as follows.
A+(p,q) {
if (p == s) C_s() [infinite recursion]
if (p == k && q == s) halt [“C_k(s) halts” is false]
A*(p,q)
}

It indicates that “C_k(s) halts” is false, and it does not say anything about C_s() [A+() goes
into infinite recursion.] But.“C_k(s) halts” being false indicates that A+() cannot prove
that C_s() does not halt 8), that is, it is not true that C_s() does not halts. In other words, it
is not false that C_s() halts. So we have

F(C_k(s)↓) & ~F(C_s()↓)

Is this a contradiction? 9) If you look at C_s() and C_k(s) they are doing exactly the same
thing! True, none of them halts, i.e. it is not true that any one of them halts. We still have

~T(C_k(s)↓) & ~T(C_s()↓)

Being false simply means that there exists a direct proof of non-halting. Nothing more,
nothing less. There is such a proof for the former but not for the latter. It is not about the
behavior of the determinee, it is about the behavior of the determiner!

In classical logic the falsehood of C_k(s) halting implies the falsehood of C_s() halting. But
in a non-bivalent logic this is not the case. Nothing forces our determiner to declare
F(C_s()↓) just because it has determined that F(C_k(s)↓). In fact it is trivial to distinguish
the two cases. The contradiction is merely “logical”, but it does not exist in a non-bivalent
logic. One way to think about this scenario is that a program can “say” something only if it
8 This does not violate Gödel’s second theorem. In Strawson’s logic proving a contradiction does not imply
proving everything. [Nor is it clear for that matter that the theorem applies to the system under
consideration.]
9 The down arrow ‘↓‘ indicates halting.

5
halts. And since C_k(s) does not halt it cannot possibly indicate anything about C_s(), in
particular it cannot say that C_s() does not halt.

Objective Introspective
A+(k,s) halts A+(s,*) halts
“C_k(s) halts” is false “C_s() halts” is false
“C_k(s) halts” is not true “C_s() halts” is not true

Table 1

Our determiner ought not to determine that C_s() does halt either. That is, we ought to
have F[ B(s,*)↓ ], and ~T[ C_s()↓ ], but not F[ C_s()↓ ]. It may seem odd at first that an
emulator does not do the same thing as the program it emulates. You could argue that
there must be one-to-one correspondence between the states of the emulator and the
emulee. So if one never reaches a dead end neither will the other. Absolutely true! If it is
not true that one reaches a halt state it is not true that the other will reach it either. All we
are saying is that there is a direct proof of not halting for the emulator [that is what false
means], but no direct proof of not halting for the emulee. The fact that “B(s,*)↓” is false
implies that “B(s,*)↓” is not true. This, by the aforementioned one-to-one correspondence,
implies “C_s()↓” is not true. But from this we cannot conclude “C_s()↓” is false.

Objective Introspective
A+(b,s) halts A+(s,*) halts
“B(s,*) halts” is false “C_s() halts” is false
“B(s,*) halts” is not true “C_s() halts” is not true

Table 2

Whether this result contradicts the Halting Theorem is a matter of interpretation. The fact
remains that there is no program that for any inputs p, q will say yes or no. Yet somehow
we managed to determine if a given program p halts on input q.

6
Bibliography
Newberry, X.Y. (2016) The Diagonal Lemma Fails in Aristotelian Logic, The
Reasoner Volume 10, Number 1, http://arxiv.org/abs/1510.04393

Newberry, X.Y. (2017) Getting around the Halting Problem,

https://arxiv.org/abs/1706.03392

Penrose, R. (1994) Shadows of the Mind, Oxford, Oxford University Press

Strawson, P.F. (1952) Introduction to Logical Theory, London, Methuen

Suber, P. (2002) Gödel's Proof, Earlham College,

https://legacy.earlham.edu/~peters/courses/logsys/g-proof.htm

Copyright © X.Y. Newberry 2018

For non-commercial purposes this article may be freely copied and distributed.