PreprintPDF Available

Halting problem undecidability and infinitely nested simulation (V2)

Authors:
  • Pixels2Words
Preprints and early-stage research may not have been peer reviewed yet.

Abstract

The halting theorem counter-examples present infinitely nested simulation (non-halting) behavior to every simulating halt decider. Whenever the pure simulation of the input to simulating halt decider H(x,y) never stops running unless H aborts its simulation H correctly aborts this simulation and returns 0 for not halting.
Halting problem undecidability and infinitely nested simulation (V2)
The halting theorem counter-examples present infinitely nested simulation (non-halting)
behavior to every simulating halt decider. Whenever the pure simulation of the input to
simulating halt decider H(x,y) never stops running unless H aborts its simulation H correctly
aborts this simulation and returns 0 for not halting.
The pathological self-reference of the conventional halting problem proof counter-examples
is overcome. The halt status of these examples is correctly determined. A simulating halt
decider remains in pure simulation mode until after it determines that its input will never
reach its final state. This eliminates the conventional feedback loop where the behavior of
the halt decider effects the behavior of its input.
The x86utm operating system was created so that the halting problem could be examined
concretely in the high level language of C. H is a function written in C that analyzes the x86
machine language execution trace of other functions written in C. H recognizes simple cases
of infinite recursion and infinite loops. The conventional halting problem proof counter-
example template is shown to simply be an input that does not halt.
H simulates its input with an x86 emulator until it determines that its input would never halt.
As soon as H recognizes that its input would never halt it stops simulating this input and
returns 0. For inputs that do halt H acts exactly as if it was an x86 emulator and simply runs
its input to completion and then returns 1.
In theoretical computer science the random-access stored-program (RASP)
machine model is an abstract machine used for the purposes of algorithm
development and algorithm complexity theory. ...The RASP is closest of all
the abstract models to the common notion of computer.
https://en.wikipedia.org/wiki/Random-access_stored-program_machine
The C/x86 model of computation is known to be Turing equivalent on the basis that it maps
to the RASP model for all computations having all of the memory that they need. As long as
an C/x86 function is a pure function of its inputs the C/x86 model of computation can be
relied upon as a much higher level of abstraction of the behavior of actual Turing machines.
This criteria merely relies on the fact that the UTM simulation of a machine description of a
machine is computationally equivalent to the direct execution of this same machine:
halt decider (Olcott 2021)
A halt decider accepts or rejects inputs on the basis of the actual behavior specified by these
inputs. Whenever the direct execution or pure simulation of an input would never reach its
final state this input is correctly decided as not halting.
In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program
and an input, whether the program will finish running, or continue
to run forever. https://en.wikipedia.org/wiki/Halting_problem
---1--- 2021-12-05 09:45 AM
Because H only acts as a pure simulator of its input until after its halt status decision has
been made it has no behavior that can possibly effect the behavior of its input.
Pathological Input to a halt decider is stipulated to mean any input that was defined to do
the opposite of whatever its corresponding halt decider decides as Sipser describes:
Now we construct a new Turing machine D with H as a subroutine.
This new TM calls H to determine what M does when the input to M
is its own description M. Once D has determined this information,
it does the opposite. (Sipser:1997:165)
When D is invoked with input ⟨D⟩ we have pathological self-reference when D calls H with ⟨D⟩
and does the opposite of whatever H returns.
Does D halt on its own machine description ⟨D⟩ ?
This question can only be correctly answered after the pathology has been removed. When
a halt decider only acts as a pure simulator of its input until after its halt status decision is
made there is no feedback loop of back channel communication between the halt decider
and its input that can prevent a correct halt status decision. In this case the halt decider is
only examining the behavior of the input and has no behavior that can effect the behavior of
this input thus can ignore it own behavior.
The standard pseudo-code halting problem template "proved" that the halting problem could
never be solved on the basis that neither value of true (halting) nor false (not halting) could
be correctly returned from the halt decider to the confounding input.
// Simplified Linz(1990) Ĥ and Strachey(1965) P
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
This problem is overcome on the basis that a simulating halt decider would abort the
simulation of its input before ever returning any value to this input. It aborts the simulation of
its input on the basis that its input specifies what is essentially infinite recursion (infinitely
nested simulation) to any simulating halt decider.
Every input to a simulating halt decider that only stops running when its simulation is aborted
unequivocally specifies a computation that never halts. When input to a simulating halt
decider cannot possibly reach its final state then we know that this input never halts.
(¬∃N ∈ Z+ such that H(x,y) simulates N steps of x(y) and x stops running) ⊢ H(x,y)==0
A simulating halt decider H divides all of its input into:
(1) Those inputs that never halt unless H aborts their simulation (never halting).
H aborts its simulation of these inputs an returns 0 for never halting.
(2) Those inputs that halt while H remains a pure simulator (halting).
H waits for its simulation of this input to complete and then returns 1 halting.
---2--- 2021-12-05 09:45 AM
Simulating partial halt decider H correctly decides that P(P) never halts (V1)
#include <stdint.h>
typedef void (*ptr)();
int H(ptr x, ptr y)
{
x(y);
return 1;
}
// Simplified Linz(1990) Ĥ
// and Strachey(1965) P
void P(ptr x)
{
if (H(x, x))
HERE: goto HERE;
}
int main(void)
{
P(P);
}
A simulating halt decider acts as a pure simulator of its input until after its input halts on its
own or the behavior of this input conclusively proves that it will never halt on its own.
For inputs that never halt on their own H does not return to its caller until after H has
correctly matched non-halting behavior patterns such as infinite loop or infinite recursion.
This makes it impossible for a pathological input to thwart a correct halt status decision.
The pathological feedback loop between the halt decider and its input that otherwise makes
inputs like the above impossible for H(P,P) to decide has been eliminated.
Halt decider theorem Olcott 2021
When-so-ever simulating halt decider H(X,Y) determines that the behavior of a pure
simulation of its input correctly matches a infinite behavior pattern such that this input never
stops running unless its simulation is aborted: H correctly aborts this input and returns 0.
H is a computable function that accepts or rejects inputs in its domain on the basis that the
pure simulation of these inputs specify a sequence of configurations stop running without
being aborted.
X86 machine code and execution trace of {main, H, and P}
_H()
[00001a6e](01) 55 push ebp
[00001a6f](02) 8bec mov ebp,esp
[00001a71](03) 8b450c mov eax,[ebp+0c]
[00001a74](01) 50 push eax // push 2nd param
[00001a75](03) ff5508 call dword [ebp+08] // call 1st param with 2nd param
[00001a78](03) 83c404 add esp,+04
[00001a7b](05) b801000000 mov eax,00000001
[00001a80](01) 5d pop ebp
[00001a81](01) c3 ret
Size in bytes:(0020) [00001a81]
---3--- 2021-12-05 09:45 AM
_P()
[00001a8e](01) 55 push ebp
[00001a8f](02) 8bec mov ebp,esp
[00001a91](03) 8b4508 mov eax,[ebp+08]
[00001a94](01) 50 push eax // push 2nd param
[00001a95](03) 8b4d08 mov ecx,[ebp+08]
[00001a98](01) 51 push ecx // push 1st param
[00001a99](05) e8d0ffffff call 00001a6e // call H
[00001a9e](03) 83c408 add esp,+08
[00001aa1](02) 85c0 test eax,eax
[00001aa3](02) 7402 jz 00001aa7
[00001aa5](02) ebfe jmp 00001aa5
[00001aa7](01) 5d pop ebp
[00001aa8](01) c3 ret
Size in bytes:(0027) [00001aa8]
_main()
[00001aae](01) 55 push ebp
[00001aaf](02) 8bec mov ebp,esp
[00001ab1](05) 688e1a0000 push 00001a8e // push P
[00001ab6](05) e8d3ffffff call 00001a8e // call P
[00001abb](03) 83c404 add esp,+04
[00001abe](02) 33c0 xor eax,eax
[00001ac0](01) 5d pop ebp
[00001ac1](01) c3 ret
Size in bytes:(0020) [00001ac1]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
(01)[00001aae][00102ec9][00000000] 55 push ebp
(02)[00001aaf][00102ec9][00000000] 8bec mov ebp,esp
(03)[00001ab1][00102ec5][00001a8e] 688e1a0000 push 00001a8e // push P
(04)[00001ab6][00102ec1][00001abb] e8d3ffffff call 00001a8e // call P
(05)[00001a8e][00102ebd][00102ec9] 55 push ebp
(06)[00001a8f][00102ebd][00102ec9] 8bec mov ebp,esp
(07)[00001a91][00102ebd][00102ec9] 8b4508 mov eax,[ebp+08]
(08)[00001a94][00102eb9][00001a8e] 50 push eax // push P
(09)[00001a95][00102eb9][00001a8e] 8b4d08 mov ecx,[ebp+08]
(10)[00001a98][00102eb5][00001a8e] 51 push ecx // push P
(11)[00001a99][00102eb1][00001a9e] e8d0ffffff call 00001a6e // call H
(12)[00001a6e][00102ead][00102ebd] 55 push ebp
(13)[00001a6f][00102ead][00102ebd] 8bec mov ebp,esp
(14)[00001a71][00102ead][00102ebd] 8b450c mov eax,[ebp+0c]
(15)[00001a74][00102ea9][00001a8e] 50 push eax // push P
(16)[00001a75][00102ea5][00001a78] ff5508 call dword [ebp+08] // call P
(17)[00001a8e][00102ea1][00102ead] 55 push ebp
(18)[00001a8f][00102ea1][00102ead] 8bec mov ebp,esp
(19)[00001a91][00102ea1][00102ead] 8b4508 mov eax,[ebp+08]
(20)[00001a94][00102e9d][00001a8e] 50 push eax
(21)[00001a95][00102e9d][00001a8e] 8b4d08 mov ecx,[ebp+08]
(22)[00001a98][00102e99][00001a8e] 51 push ecx
(23)[00001a99][00102e95][00001a9e] e8d0ffffff call 00001a6e // call H
(24)[00001a6e][00102e91][00102ea1] 55 push ebp // push P
(25)[00001a6f][00102e91][00102ea1] 8bec mov ebp,esp
(26)[00001a71][00102e91][00102ea1] 8b450c mov eax,[ebp+0c]
(27)[00001a74][00102e8d][00001a8e] 50 push eax // push P
(28)[00001a75][00102e89][00001a78] ff5508 call dword [ebp+08] // call P
(29)[00001a8e][00102e85][00102e91] 55 push ebp
(30)[00001a8f][00102e85][00102e91] 8bec mov ebp,esp
(31)[00001a91][00102e85][00102e91] 8b4508 mov eax,[ebp+08]
(32)[00001a94][00102e81][00001a8e] 50 push eax
(33)[00001a95][00102e81][00001a8e] 8b4d08 mov ecx,[ebp+08]
(34)[00001a98][00102e7d][00001a8e] 51 push ecx
(35)[00001a99][00102e79][00001a9e] e8d0ffffff call 00001a6e // call H
(36)[00001a6e][00102e75][00102e85] 55 push ebp
(37)[00001a6f][00102e75][00102e85] 8bec mov ebp,esp
(38)[00001a71][00102e75][00102e85] 8b450c mov eax,[ebp+0c]
(39)[00001a74][00102e71][00001a8e] 50 push eax // push P
(40)[00001a75][00102e6d][00001a78] ff5508 call dword [ebp+08] // call P
(41)[00001a8e][00102e69][00102e75] 55 push ebp // push P
(42)[00001a8f][00102e69][00102e75] 8bec mov ebp,esp
(43)[00001a91][00102e69][00102e75] 8b4508 mov eax,[ebp+08]
(44)[00001a94][00102e65][00001a8e] 50 push eax // push P
(45)[00001a95][00102e65][00001a8e] 8b4d08 mov ecx,[ebp+08]
(46)[00001a98][00102e61][00001a8e] 51 push ecx // push P
(47)[00001a99][00102e5d][00001a9e] e8d0ffffff call 00001a6e // call H
(48)[00001a6e][00102e59][00102e69] 55 push ebp
(49)[00001a6f][00102e59][00102e69] 8bec mov ebp,esp
(50)[00001a71][00102e59][00102e69] 8b450c mov eax,[ebp+0c]
(51)[00001a74][00102e55][00001a8e] 50 push eax // push P
(52)[00001a75][00102e51][00001a78] ff5508 call dword [ebp+08] // call P
(53)[00001a8e][00102e4d][00102e59] 55 push ebp // push P
---4--- 2021-12-05 09:45 AM
Simulating partial halt decider H correctly decides that P(P) never halts (V2)
// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
int main()
{
Output("Input_Halts = ", H((u32)P, (u32)P));
}
_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]
_main()
[00000c56](01) 55 push ebp
[00000c57](02) 8bec mov ebp,esp
[00000c59](05) 68360c0000 push 00000c36 // push P
[00000c5e](05) 68360c0000 push 00000c36 // push P
[00000c63](05) e8fefcffff call 00000966 // call H(P,P)
[00000c68](03) 83c408 add esp,+08
[00000c6b](01) 50 push eax
[00000c6c](05) 6857030000 push 00000357
[00000c71](05) e810f7ffff call 00000386
[00000c76](03) 83c408 add esp,+08
[00000c79](02) 33c0 xor eax,eax
[00000c7b](01) 5d pop ebp
[00000c7c](01) c3 ret
Size in bytes:(0039) [00000c7c]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c56][0010172a][00000000] 55 push ebp
[00000c57][0010172a][00000000] 8bec mov ebp,esp
[00000c59][00101726][00000c36] 68360c0000 push 00000c36 // push P
[00000c5e][00101722][00000c36] 68360c0000 push 00000c36 // push P
[00000c63][0010171e][00000c68] e8fefcffff call 00000966 // call H(P,P)
Begin Local Halt Decider Simulation at Machine Address:c36
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
Same criteria as V1, H sees that it is called a second time with the same input.
---5--- 2021-12-05 09:45 AM
[00000c68][0010172a][00000000] 83c408 add esp,+08
[00000c6b][00101726][00000000] 50 push eax
[00000c6c][00101722][00000357] 6857030000 push 00000357
[00000c71][00101722][00000357] e810f7ffff call 00000386
Input_Halts = 0
[00000c76][0010172a][00000000] 83c408 add esp,+08
[00000c79][0010172a][00000000] 33c0 xor eax,eax
[00000c7b][0010172e][00100000] 5d pop ebp
[00000c7c][00101732][00000068] c3 ret
---6--- 2021-12-05 09:45 AM
The direct execution of P(P) halts (V3)
The execution trace of the x86 emulation of P(P) by simulating halt decider H conclusively
proves that P cannot possibly ever reach its final state of 0xc3f. This provides complete
proof that that the input to H never halts thus H(P,P)==0 is correct.
// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
int main()
{
P((u32)P);
}
_P()
[00000c25](01) 55 push ebp
[00000c26](02) 8bec mov ebp,esp
[00000c28](03) 8b4508 mov eax,[ebp+08]
[00000c2b](01) 50 push eax // 2nd Param
[00000c2c](03) 8b4d08 mov ecx,[ebp+08]
[00000c2f](01) 51 push ecx // 1st Param
[00000c30](05) e820fdffff call 00000955 // call H
[00000c35](03) 83c408 add esp,+08
[00000c38](02) 85c0 test eax,eax
[00000c3a](02) 7402 jz 00000c3e
[00000c3c](02) ebfe jmp 00000c3c
[00000c3e](01) 5d pop ebp
[00000c3f](01) c3 ret
Size in bytes:(0027) [00000c3f]
_main()
[00000c45](01) 55 push ebp
[00000c46](02) 8bec mov ebp,esp
[00000c48](05) 68250c0000 push 00000c25 // push P
[00000c4d](05) e8d3ffffff call 00000c25 // call P(P)
[00000c52](03) 83c404 add esp,+04
[00000c55](02) 33c0 xor eax,eax
[00000c57](01) 5d pop ebp
[00000c58](01) c3 ret
Size in bytes:(0020) [00000c58]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c45][001016d6][00000000] 55 push ebp
[00000c46][001016d6][00000000] 8bec mov ebp,esp
[00000c48][001016d2][00000c25] 68250c0000 push 00000c25 // push P
[00000c4d][001016ce][00000c52] e8d3ffffff call 00000c25 // call P(P)
[00000c25][001016ca][001016d6] 55 push ebp // P begins
[00000c26][001016ca][001016d6] 8bec mov ebp,esp
[00000c28][001016ca][001016d6] 8b4508 mov eax,[ebp+08]
[00000c2b][001016c6][00000c25] 50 push eax // push P
[00000c2c][001016c6][00000c25] 8b4d08 mov ecx,[ebp+08]
[00000c2f][001016c2][00000c25] 51 push ecx // push P
[00000c30][001016be][00000c35] e820fdffff call 00000955 // call H(P,P)
---7--- 2021-12-05 09:45 AM
Begin Local Halt Decider Simulation at Machine Address:c25
[00000c25][00211776][0021177a] 55 push ebp // P begins
[00000c26][00211776][0021177a] 8bec mov ebp,esp
[00000c28][00211776][0021177a] 8b4508 mov eax,[ebp+08]
[00000c2b][00211772][00000c25] 50 push eax // push P
[00000c2c][00211772][00000c25] 8b4d08 mov ecx,[ebp+08]
[00000c2f][0021176e][00000c25] 51 push ecx // push P
[00000c30][0021176a][00000c35] e820fdffff call 00000955 // call H(P,P)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
Same criteria as V2, H sees that it is called a second time with the same input.
[00000c35][001016ca][001016d6] 83c408 add esp,+08
[00000c38][001016ca][001016d6] 85c0 test eax,eax
[00000c3a][001016ca][001016d6] 7402 jz 00000c3e
[00000c3e][001016ce][00000c52] 5d pop ebp
[00000c3f][001016d2][00000c25] c3 ret
[00000c52][001016d6][00000000] 83c404 add esp,+04
[00000c55][001016d6][00000000] 33c0 xor eax,eax
[00000c57][001016da][00100000] 5d pop ebp
[00000c58][001016de][00000084] c3 ret
Number_of_User_Instructions(34)
Number of Instructions Executed(23729)
P(P) is conditional only on whatever H(P,P) returns. H(P,P) is conditional only on whatever
the simulation or execution of its input actually does. These are two entirely different
conditions that result in entirely different behavior.
Here are the divergent execution sequences at the C level:
int main(){ H(P,P); }
(1) main()
(2) calls H(P,P) that simulates the input to H(P,P)
(3) that calls H(P,P) which aborts its simulation of P(P) and returns 0 to
(4) main().
int main(){ P(P); }
(a) main() calls P(P) that
(b) calls H(P,P) that simulates the input to H(P,P)
(c) that calls H(P,P) which aborts its simulation of P(P) and returns 0 to
(d) P(P) that returns to main()
---8--- 2021-12-05 09:45 AM
Peter Linz Ĥ applied to the Turing machine description of itself: Ĥ
The following simplifies the syntax for the definition of the Linz Turing machine Ĥ, it is now a
single machine with a single start state. A simulating halt decider is embedded at .qxĤ. It has
been annotated so that it only shows Ĥ applied to ⟨ ⟩Ĥ, converting the variables to constants.
.q0 ⟨ ⟩ ⊢* .qx ⟨ ⟩ ⟨ ⟩ ⊢* .qy ∞ Ĥ Ĥ Ĥ Ĥ Ĥ Ĥ
If the UTM simulation of the input to .qx ⟨ ⟩ applied to ⟨ ⟩ reaches its own final state. Ĥ Ĥ Ĥ
.q0 ⟨ ⟩ ⊢* .qx ⟨ ⟩ ⟨ ⟩ ⊢* .qn Ĥ Ĥ Ĥ Ĥ Ĥ Ĥ
If the pure simulation of the input to qx ⟨ ⟩ ⟨ Ĥ Ĥ Ĥ would never reach its final state (whether or
not this simulation is aborted) then it is necessarily true that qxĤ transitions to .qnĤ correctly.
Figure 12.3 Turing Machine Ĥ applied to Ĥ
.q0Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then .qx ⟨Ĥ Ĥ0⟩ ⟨Ĥ1⟩ simulates its input
Ĥ0.q0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then Ĥ0.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ simulates its input.
Ĥ1.q0 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then Ĥ1.qx ⟨Ĥ2⟩ ⟨Ĥ3⟩ simulates its input.
Ĥ2.q0 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then Ĥ2.qx ⟨Ĥ3⟩ ⟨Ĥ4⟩ simulates its input.
.q0Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then .qx ⟨Ĥ Ĥ0⟩ ⟨Ĥ1⟩ simulates its input
Ĥ0.q0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then Ĥ0.qx ⟨Ĥ1⟩ ⟨Ĥ2
.qx detects that a copy of itself is about to be simulated with a copy of its inputs. Ĥ
If the simulating halt decider at Ĥ.qx never aborts its simulation of its input this input never
halts. If Ĥ.qx aborts its simulation of its input this input never reaches its final state and thus
never halts. In all cases for every simulating halt decider at Ĥ.qx its input never halts.
When the pure simulation of the actual input to .qx ⟨ ⟩ ⟨ Ĥ Ĥ Ĥ never reaches the final state of
this input then .qx Ĥtransitions to ⊢* .qnĤ is necessarily correct no matter what Ĥ Ĥ does. A
halt decider is only accountable for correctly deciding the halt status of its actual input.
When the original Linz H is applied to Ĥ Ĥ it sees that its input transitions to Ĥ.qn. This
provides the basis for H to transition to its final state of H.qy.
When Ĥ.qx is applied to Ĥ⟩ ⟨Ĥ it sees that none of the recursive simulations of its input ever
halt it aborts the simulation of its input and correctly transitions to its final state of Ĥ.qn.
---9--- 2021-12-05 09:45 AM
The Peter Linz conclusion (Linz:1990:320)
Now Ĥ is a Turing machine, so that it will have some description in Σ*, say ⟨ Ĥ. This string,
in addition to being the description of Ĥ can also be used as input string. We can therefore
legitimately ask what would happen if Ĥ is applied to ⟨ Ĥ.
.q0 ⟨ ⟩ ⊢* .qx ⟨ ⟩ ⟨ ⊢* .qy ∞Ĥ Ĥ Ĥ Ĥ Ĥ Ĥ
if applied to Ĥ⟨ ⟩Ĥ halts, and
.q0 ⟨ ⟩ ⊢* .qx ⟨ ⟩ ⟨ ⊢* .qn Ĥ Ĥ Ĥ Ĥ Ĥ Ĥ
if Ĥ applied to ⟨ Ĥ does not halt. This is clearly nonsense. The contradiction tells us that our
assumption of the existence of H, and hence the assumption of the decidability of the
halting problem, must be false.
My rebuttal to the Peter Linz Conclusion
This explicitly ignores the possibility that the input to .qx ⟨ ⟩ ⟨ ⟩ never halts and Ĥ Ĥ Ĥ Ĥ
transitions to .qn causing ⟩ to halt in exactly the same way that the input to H(P,P) Ĥ Ĥ Ĥ
never halts and H(P,P) returns 0 causing P(P) to halt.
A turing machine program consists of a list of 'quintuples', each one of which is a five-symbol
turing machine instruction. For example, the quintuple 'SCcsm' is executed by the machine if
it is in state 'S' and is reading the symbol 'C' on the tape. In that case, the instruction causes
the machine to make a transition to state 's' and to overwrite the symbol 'C' on the tape with
the symbol 'c'. The last operation it performs under this instruction is to move the tape
reading head one symbol to the left or right according to whether 'm' is 'l' or 'r'.
http://www.lns.mit.edu/~dsw/turing/doc/tm_manual.txt
Copyright 2016-2021 PL Olcott
Strachey, C 1965. An impossible program The Computer Journal, Volume 7, Issue 4,
January 1965, Page 313, https://doi.org/10.1093/comjnl/7.4.313
Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto:
D. C. Heath and Company. (318-320)
Sipser, Michael 1997. Introduction to the Theory of Computation. Boston: PWS Publishing
Company (165-167)
---10--- 2021-12-05 09:45 AM
Glossary of Terms
computation
The sequence of configurations leading to a halt state will be called a computation.
(Linz:1990:238)
computation that halts
A Turing machine is said to halt whenever it reaches a configuration for which δ is not
defined; … so the Turing machine will halt whenever it enters a final state. (Linz:1990:234)
computable function
Computable functions are the basic objects of study in computability theory. Computable
functions are the formalized analogue of the intuitive notion of algorithms, in the sense that a
function is computable if there exists an algorithm that can do the job of the function, i.e.
given an input of the function domain it can return the corresponding output.
https://en.wikipedia.org/wiki/Computable_function
computable function (Olcott 2021)
An algorithm is applied to an input deriving an output.
computer science decider
A decider is a machine that accepts or rejects inputs.
https://cs.stackexchange.com/questions/84433/what-is-decider
halt decider (Olcott 2021)
Function H maps finite string pairs (x,y) that specify a sequence of configurations to {0,1}
The input to H(x,y) is a finite string pair where x is a list of quintuples of Turing machine
instructions and y is a finite string.
The formal proof of the behavior of N steps of x applied to y is the sequence of
configurations derived when a UTM is applied to x on input y for N steps of configurations.
computer science decider
Intuitively, a decider should be a Turing machine that given an input, halts and either accepts
or rejects, relaying its answer in one of many equivalent ways, such as halting at an
ACCEPT or REJECT state, or leaving its answer on the output tape.
https://cs.stackexchange.com/questions/84433/what-is-decider
[**Halting problem undecidability and infinitely nested simulation V2**]
(https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_
infinitely_nested_simulation_V2)
[Olcott 2021 generic halt deciding principle] Whenever the pure simulation of the input to
simulating halt decider H(x,y) never stops running unless H aborts its simulation H correctly
aborts this simulation and returns 0 for not halting.
If there is no N in the set of positive integers such that H(x,y) simulates N steps of x(y) and x
stops running this proves H(x,y)==0.
---11--- 2021-12-05 09:45 AM
Strachey's Impossible Program
To the Editor,
The Computer Journal.
An impossible program
Sir,
A well-known piece of folk-lore among programmers
holds that it is impossible to write a program which can
examine any other program and tell, in every case, if it
will terminate or get into a closed loop when it is run.
I have never actually seen a proof of this in print, and
though Alan Turing once gave me a verbal proof (in a
railway carriage on the way to a Conference at the
NPL in 1953), I unfortunately and promptly forgot the
details. This left me with an uneasy feeling that the
proof must be long or complicated, but in fact it is so
short and simple that it may be of interest to casual
readers. The version below uses CPL, but not in any
essential way.
Suppose T[R] is a Boolean function taking a routine
(or program) R with no formal or free variables as its
argument and that for all R, T[R] — True if R terminates
if run and that T[R] = False if R does not terminate.
Consider the routine P defined as follows
rec routine P
§L:if T[P] go to L
Return §
If T[P] = True the routine P will loop, and it will
only terminate if T[P] = False. In each case T[P] has
exactly the wrong value, and this contradiction shows
that the function T cannot exist.
Yours faithfully,
C. STRACHEY.
Churchill College,
Cambridge.
Strachey, C 1965. An impossible program The Computer Journal, Volume 7, Issue 4,
January 1965, Page 313, https://doi.org/10.1093/comjnl/7.4.313
---12--- 2021-12-05 09:45 AM
ResearchGate has not been able to resolve any citations for this publication.
Article
Please don't be shy about sending even vague pointers to people who may have complete or partial resolutions of the problems mentioned in any of the open questions columns that have appeared as earlier complexity theory columns. Though I don't give a ...