Content uploaded by PL Olcott

Author content

All content in this area was uploaded by PL Olcott on Dec 05, 2021

Content may be subject to copyright.

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