<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then

H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game. PO really /has/ an H
(it's trivial to do for this one case) that correctly determines
that P(P) *would* never stop running *unless* aborted.

This was verified on the basis of the x86utm operating
system that provided an execution trace in the x86
language that was too difficult for anyone to understand. https://github.com/plolcott/x86utm
This took about one year of full time development effort.

*Updated words*
Simulating termination analyzer H simulates
N statements of D according to the semantics of
the C programming language. H does this until it
matches a correct non-halting behavior pattern.
This pattern conclusively proves that the simulated
D cannot possibly reach its own simulated "return"
statement final halt state for any value of N.

Then H aborts its simulation and returns 0 on the
basis that that its input D specifies a non-halting
sequence of instructions.

This is empirically proven by a C interpreter.
(Detailed design provided below)

int H(char* P);

int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

The above is assumed in in test.c

simulate.exe implements a C interpreter.

Command line invocation: simulate test.c

When this interpreter sees the call to H(D) it
calls itself with the text body of D. I intend
to make this generic for any named function.

The above proves that N instructions of D simulated
by H according to the semantics of the C programming
language cannot possibly reach its own "return"
statement final halt state.

It is estimated that the adaptation of an existing
C interpreter should take about one full time week.
I already found one that can call itself recursively.

The tricky part that might require YACC and LEX is
parsing the input file to recognize instances of H
that must be called with text strings of function bodies.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer


--- PyGate Linux v1.5
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)