Re: DDD correctly emulated by HHH is correctly rejected as non-halting.

On 7/10/24 11:03 AM, olcott wrote:

typedef void (*ptr)();
int HHH(ptr P);
 void DDD()
{
   HHH(DDD);
}
 int main()
{
   HHH(DDD);
}
 We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated by
each pure function x86 emulator HHH (of the infinite set
of every HHH that can possibly exist) then DDD cannot
possibly reach past its own machine address of 0000216b
and halt.

Except that you can't stipulate what is "corrrect" or what someone else means by the words they used, so all you are doing is proving you aren't working with the normal system.
So, you are just admitting you words are meaningless for computaiton theory.
Also, since the x86 programming language DEFINES (and you didn't stipulate it away) that the correct behavior of an x86 proggram is that it runs until it reaches an end, thus the only possible "correct emulation" is one that doesn't stop, you CAN'T have a finite emulation that didn't reach a final state, so the only HHH you are alllowed is the one that never aborts, and thus fails to answer.

 _DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
 *This algorithm is used by the simulating termination analyzers*
<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>

And the only behavior of "correct simulation" allowed here is the actual correct simulation that exactly reproduces the behavior of the program the input represents, which means it does not EVER abort.
If HHH ever aborts its simulation, it is NOT such a simulation, nor does it correctly predict the behavior of such a simulation, since if HHH(DED) aborts its emulation and returns, then the actual behavior of the input, is to return, thus HHH never was correct to use the second paragraph.

 Simulating termination analyzer HHH aborts its emulation of DDD
as soon as it correctly detects any non-halting behavior pattern.
At this point it aborts its emulation and returns 0 indicating
that it rejected this input as non-halting.
 

And thus fails to meet your stipulations, thus proving you to be a liar.
And it doesn't prove that the input, CALLING THAT SAME HHH, is non-halting, because by your stipuated defintion, the ONLY measure of the correct behavior of the input is by an actually correct emulation per the x86 languge specification (which isn't the one by HHH since it aborted) and when we give this input, that calls this HHH as defined, we see that it will halt when we simulate it FULLY.
You problem is you don't understand that you don't get to change HHH in the middle of the problem. If it does abort, it will always abort, and return, and thus it is never correct to say that it has correctly decided that it will never stop.
The fact that a DIFFERENT input, with the same code for the C function DDD but linked to a diffferent HHH (and thus is a different program represented by the input) behavies diffferently is irrelvent, as this DDD wasn't lonked to that over HHH.