Re: Sequence of sequence, selection and iteration matters

Op 09.jul.2024 om 19:02 schreef olcott:

On 7/9/2024 11:51 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 18:44 schreef olcott:

On 7/9/2024 10:21 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 16:46 schreef olcott:

On 7/9/2024 9:38 AM, Fred. Zwarts wrote:

Indeed, no such HHH exists. This proves that HHH cannot possibly simulate itself correctly.

>
"Correctly" means must do whatever the x86 code specifies.

>
And since the x86 code never specifies an abort, it is incorrect to abort halfway a simulation that would halt. We know it would halt, because other simulators show that it halts when HHH is correctly simulated.
If you want to deny this truth, point to the specification of the x86 language where it says that a program must be aborted. It is irrational to defend an unneeded abort with a reference to the x86 specifications.
>

You are in psychological denial causing you to be irrational.

>
Illogical and irrelevant remarks ignored. I know olcott has problems to recognize the truth, so I do not feel offended.
>

>

>
_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]
>
*When DDD is correctly emulated by any pure function*
*HHH x86 emulator that can possibly exist* which calls
an emulated HHH(DDD) to repeat this process until the
emulated DDD is aborted.

>

>
And the fact *that* it aborts, makes the simulation incorrect (as Sipser would agree with), because the X86 code does not specify an abort at that point. Therefore, the only conclusion must be: No such HHH exists.

>
HHH is fully operational in the x86utm operating system.
>
_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]
>
When DDD is correctly emulated by any pure function x86
emulator HHH calls an emulated HHH(DDD) this call cannot
possibly return.

>
HHH cannot possibly simulate itself to the end and return, which shows that

 the simulation is correct because that is what the x86
code means when it says that DDD correctly emulated by HHH
is stuck in recursive emulation.
 That people not sufficiently understanding the semantics
of the x86 language say otherwise merely proves that their
understanding is insufficient.
 

You understand x86 insufficiently, because you think that a two cycle recursion means an infinite recursion.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
HHH, therefore, is programmed incorrectly, so that after two cycles it aborts.
But it aborts when the simulated HHH is programmed to go for one other cycle and then also abort and return. Therefore, the simulation is aborted too soon, which makes it incorrect.
Maybe you should study x86, so that you see that no abort is needed for a simulation of a halting program. The x86 language does not allow to abort a halting program.
A simulator that correctly interprets the x86 code of HHH shows that it halts.
Only HHH cannot possibly simulate itself correctly.