*DD is merely D that calls HH instead of H*

int DD(void (*x)())
{ int Halt_Status = HH(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

*This was the most difficult code for me to write*
HH can correctly simulate itself simulating DD to an arbitrary
recursive depth.

Unless HH aborts its simulation of DD it will abnormally terminate
from stack overflow.

*This conclusively proves that DD simulated by HH DOES NOT HALT*

I had to make x86utm a full multi-tasking operating system with
each simulation having its own process context: {memory, stack,
virtual registers}

https://github.com/plolcott/x86utm/blob/master/Halt7.c

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

On 1/18/24 02:37, olcott wrote:
> *DD is merely D that calls HH instead of H*
>
> int DD(void (*x)())
> {
>   int Halt_Status = HH(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> *This was the most difficult code for me to write*
> HH can correctly simulate itself simulating DD to an arbitrary
> recursive depth.
>
> Unless HH aborts its simulation of DD it will abnormally terminate
> from stack overflow.
If HH aborts its simulation of DD then is not infinitely recursive so
the abort is incorrect.

>
> *This conclusively proves that DD simulated by HH DOES NOT HALT*
>
> I had to make x86utm a full multi-tasking operating system with
> each simulation having its own process context: {memory, stack,
> virtual registers}
>
> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>

On 1/18/2024 1:14 AM, immibis wrote:
> On 1/18/24 02:37, olcott wrote:
>> *DD is merely D that calls HH instead of H*
>>
>> int DD(void (*x)())
>> {
>>    int Halt_Status = HH(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> *This was the most difficult code for me to write*
>> HH can correctly simulate itself simulating DD to an arbitrary
>> recursive depth.
>>
>> Unless HH aborts its simulation of DD it will abnormally terminate
>> from stack overflow.
> If HH aborts its simulation of DD then is not infinitely recursive so
> the abort is incorrect.
>

MIT Professor Michael Sipser agreed that this verbatim paragraph is correct
(a) 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
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

>>
>> *This conclusively proves that DD simulated by HH DOES NOT HALT*
>>
>> I had to make x86utm a full multi-tasking operating system with
>> each simulation having its own process context: {memory, stack,
>> virtual registers}
>>
>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>
>

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

On 1/18/2024 1:14 AM, immibis wrote:
> On 1/18/24 02:37, olcott wrote:
>> *DD is merely D that calls HH instead of H*
>>
>> int DD(void (*x)())
>> {
>>    int Halt_Status = HH(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> *This was the most difficult code for me to write*
>> HH can correctly simulate itself simulating DD to an arbitrary
>> recursive depth.
>>
>> Unless HH aborts its simulation of DD it will abnormally terminate
>> from stack overflow.
> If HH aborts its simulation of DD then is not infinitely recursive so
> the abort is incorrect.
>

(a) If simulating termination analyzer H correctly determines that D
correctly simulated by H cannot possibly reach its own final state and
terminate normally then

(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

The ultimate measure [of a correct simulation] is the correct x86
emulation of the x86 instructions in the order that they are specified.
The alternative is incorrectly emulating the x86 instructions in some
other order than they are specified.

>>
>> *This conclusively proves that DD simulated by HH DOES NOT HALT*
>>
>> I had to make x86utm a full multi-tasking operating system with
>> each simulation having its own process context: {memory, stack,
>> virtual registers}
>>
>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>
>

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

On 1/18/24 15:05, olcott wrote:
> On 1/18/2024 1:14 AM, immibis wrote:
>> On 1/18/24 02:37, olcott wrote:
>>> *DD is merely D that calls HH instead of H*
>>>
>>> int DD(void (*x)())
>>> {
>>>    int Halt_Status = HH(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> *This was the most difficult code for me to write*
>>> HH can correctly simulate itself simulating DD to an arbitrary
>>> recursive depth.
>>>
>>> Unless HH aborts its simulation of DD it will abnormally terminate
>>> from stack overflow.
>> If HH aborts its simulation of DD then is not infinitely recursive so
>> the abort is incorrect.
>>
>
> MIT Professor Michael Sipser agreed that this verbatim paragraph is correct
> (a) 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
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>

The verbatim paragraph is correct. It has no relevance, because H is an
incorrect simulator.

On 1/18/24 17:13, immibis wrote:
> On 1/18/24 15:05, olcott wrote:
>> On 1/18/2024 1:14 AM, immibis wrote:
>>> On 1/18/24 02:37, olcott wrote:
>>>> *DD is merely D that calls HH instead of H*
>>>>
>>>> int DD(void (*x)())
>>>> {
>>>>    int Halt_Status = HH(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> *This was the most difficult code for me to write*
>>>> HH can correctly simulate itself simulating DD to an arbitrary
>>>> recursive depth.
>>>>
>>>> Unless HH aborts its simulation of DD it will abnormally terminate
>>>> from stack overflow.
>>> If HH aborts its simulation of DD then is not infinitely recursive so
>>> the abort is incorrect.
>>>
>>
>> MIT Professor Michael Sipser agreed that this verbatim paragraph is
>> correct
>> (a) 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
>> (b) H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>
> The verbatim paragraph is correct. It has no relevance, because H is an
> incorrect simulator.
>

Correction: Each instruction is simulated correctly. The abort decision
is incorrect. H incorrectly determines that its simulated D would never
stop running unless aborted.

On 1/18/24 9:35 AM, olcott wrote:
> On 1/18/2024 1:14 AM, immibis wrote:
>> On 1/18/24 02:37, olcott wrote:
>>> *DD is merely D that calls HH instead of H*
>>>
>>> int DD(void (*x)())
>>> {
>>>    int Halt_Status = HH(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> *This was the most difficult code for me to write*
>>> HH can correctly simulate itself simulating DD to an arbitrary
>>> recursive depth.
>>>
>>> Unless HH aborts its simulation of DD it will abnormally terminate
>>> from stack overflow.
>> If HH aborts its simulation of DD then is not infinitely recursive so
>> the abort is incorrect.
>>
>
> (a) If simulating termination analyzer H correctly determines that D
> correctly simulated by H cannot possibly reach its own final state and
> terminate normally then

WHich H doesn't do, but erroneously looks at the correct simulation of a
DIFFERENT input, which you decpetively try to give the same name.

>
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> The ultimate measure [of a correct simulation] is the correct x86
> emulation of the x86 instructions in the order that they are specified.
> The alternative is incorrectly emulating the x86 instructions in some
> other order than they are specified.

And since your simulation doesn't correctly determine what a call H(D,D)
does, it is incorrect.

>
>
>>>
>>> *This conclusively proves that DD simulated by HH DOES NOT HALT*
>>>
>>> I had to make x86utm a full multi-tasking operating system with
>>> each simulation having its own process context: {memory, stack,
>>> virtual registers}
>>>
>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>
>>
>

On 1/18/24 9:05 AM, olcott wrote:
> On 1/18/2024 1:14 AM, immibis wrote:
>> On 1/18/24 02:37, olcott wrote:
>>> *DD is merely D that calls HH instead of H*
>>>
>>> int DD(void (*x)())
>>> {
>>>    int Halt_Status = HH(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> *This was the most difficult code for me to write*
>>> HH can correctly simulate itself simulating DD to an arbitrary
>>> recursive depth.
>>>
>>> Unless HH aborts its simulation of DD it will abnormally terminate
>>> from stack overflow.
>> If HH aborts its simulation of DD then is not infinitely recursive so
>> the abort is incorrect.
>>
>
> MIT Professor Michael Sipser agreed that this verbatim paragraph is correct
> (a) 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
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
>

So, your H need to CORRECTLY DETERMINE that a CORRECT SIMULATION of THIS
input (the one built on THIS H, not the one that doesn't abort) would
not halt.

You can't look at a DIFFERENT D built on a DIFFERENT H that does correct
simulate this other D, as that is a different input.

Since you can't show that, (a) is not satisfied, so you can't use it to
justify (b).

>>>
>>> *This conclusively proves that DD simulated by HH DOES NOT HALT*
>>>
>>> I had to make x86utm a full multi-tasking operating system with
>>> each simulation having its own process context: {memory, stack,
>>> virtual registers}
>>>
>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>
>>
>