Re: Defining a correct simulating halt decider

On 9/3/24 9:29 AM, olcott wrote:

On 9/3/2024 2:15 AM, Fred. Zwarts wrote:

Op 03.sep.2024 om 00:22 schreef olcott:

On 9/2/2024 12:52 PM, Fred. Zwarts wrote:

Op 02.sep.2024 om 18:38 schreef olcott:

A halt decider is a Turing machine that computes
the mapping from its finite string input to the
behavior that this finite string specifies.
>
If the finite string machine string machine
description specifies that it cannot possibly
reach its own final halt state then this machine
description specifies non-halting behavior.
>
A halt decider never ever computes the mapping
for the computation that itself is contained within.
>
Unless there is a pathological relationship between
the halt decider H and its input D the direct execution
of this input D will always have identical behavior to
D correctly simulated by simulating halt decider H.
>
*Simulating Termination Analyzer H Not Fooled by Pathological Input D*
https://www.researchgate.net/ publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>
A correct emulation of DDD by HHH only requires that HHH
emulate the instructions of DDD** including when DDD calls
HHH in recursive emulation such that HHH emulates itself
emulating DDD.

>
Indeed, it should simulate *itself* and not a hypothetical other HHH with different behaviour.
If HHH includes code to see a 'special condition' and aborts and halts, then it should also simulate the HHH that includes this same code and

>
>
DDD has itself and the emulated HHH stuck in recursive emulation.
>
void DDD()
{
   HHH(DDD);
   return;
}

>
It is not DDD. It is HHH that has the problem when trying to simulate itself.

 It does this correctly yet beyond your intellectual capacity.

But it gets the wrong answer, so wasn't correct.
Remember, to CORRECTLY SIMULATE, in means it gets the actual behavior of the machine it is emulating. HHH has decided that the HHH that DDD calls doesn't halt, but that is itself, so it decided that it doesn't halt, which (if it give that answer) isn't correct.

 _DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
 Instructions from machine address 00002172 through
machine address 0000217a are emulated.
 What instruction of DDD do you believe comes next?

000015d2
Since the HHH that DDD calls is part of it,
Or are you still trying to LIE about what the input is?