Re: Because I have repeated this same point 500 times in the last three years...

Op 27.jul.2024 om 16:15 schreef olcott:

On 7/27/2024 2:42 AM, Mikko wrote:

On 2024-07-26 13:17:19 +0000, olcott said:
>

On 7/26/2024 3:42 AM, Mikko wrote:

On 2024-07-26 01:49:46 +0000, olcott said:
>

If you understand the x86 language and can't tell how DDD
emulated by HHH differs from DDD emulated by HHH1 by the
following then you are probably lying about understanding
the x86 language.

>
Any emulation of DDD that differs from DDD is wrong.
>

 OK so you are lying about knowing the x86 language
or don't bother to study the execution trace well enough.
 _Infinite_Recursion()
[0000215a] 55               push ebp
[0000215b] 8bec             mov ebp,esp
[0000215d] e8f8ffffff       call 0000215a ; recursive call
[00002162] 5d               pop ebp
[00002163] c3               ret
Size in bytes:(0010) [00002163]
 Begin Local Halt Decider Simulation   Execution Trace Stored at:113934
Decide_Halting_HH:1
[0000215a][00113924][00113928] 55               push ebp
[0000215b][00113924][00113928] 8bec             mov ebp,esp
[0000215d][00113920][00002162] e8f8ffffff       call 0000215a
[0000215a][0011391c][00113924] 55               push ebp
[0000215b][0011391c][00113924] 8bec             mov ebp,esp
[0000215d][00113918][00002162] e8f8ffffff       call 0000215a
Local Halt Decider: *Infinite Recursion Detected Simulation Stopped*

 If you can't understand how the above proves infinite recursion
you won't be able to understand how DDD correctly emulated by HHH
proves recursive simulation. It is the same non-halting behavior
pattern in both cases.
 Since HHH does not know that DDD is calling itself HHH only
sees infinite recursion and not does not recursive simulation.
 _DDD()
[00002177] 55         push ebp
[00002178] 8bec       mov ebp,esp
[0000217a] 6877210000 push 00002177 ; push DDD
[0000217f] e853f4ffff call 000015d7 ; call HHH
[00002184] 83c404     add esp,+04
[00002187] 5d         pop ebp
[00002188] c3         ret
Size in bytes:(0018) [00002188]
 _main()
[00002197] 55         push ebp
[00002198] 8bec       mov ebp,esp
[0000219a] 6877210000 push 00002177 ' push DDD
[0000219f] e863f3ffff call 00001507 ; call HH1
[000021a4] 83c404     add esp,+04
[000021a7] 33c0       xor eax,eax
[000021a9] 5d         pop ebp
[000021aa] c3         ret
Size in bytes:(0020) [000021aa]
   machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002197][001037fb][00000000] 55         push ebp
[00002198][001037fb][00000000] 8bec       mov ebp,esp
[0000219a][001037f7][00002177] 6877210000 push 00002177 ; push DDD
[0000219f][001037f3][000021a4] e863f3ffff call 00001507 ; call HHH1
New slave_stack at:10389f
 // emulates 1st instance of DDD that calls HHH(DDD)
Begin Local Halt Decider Simulation   Execution Trace Stored at:1138a7
[00002177][00113897][0011389b] 55         push ebp
[00002178][00113897][0011389b] 8bec       mov ebp,esp
[0000217a][00113893][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011388f][00002184] e853f4ffff call 000015d7 ; call HHH
New slave_stack at:14e2c7
 // emulates 2nd instance of DDD that calls HHH(DDD)
Begin Local Halt Decider Simulation   Execution Trace Stored at:15e2cf
[00002177][0015e2bf][0015e2c3] 55         push ebp
[00002178][0015e2bf][0015e2c3] 8bec       mov ebp,esp
[0000217a][0015e2bb][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2b7][00002184] e853f4ffff call 000015d7 ; call HHH
New slave_stack at:198cef
 // emulates 3rd instance of DDD that calls HHH(DDD)
[00002177][001a8ce7][001a8ceb] 55         push ebp
[00002178][001a8ce7][001a8ceb] 8bec       mov ebp,esp
[0000217a][001a8ce3][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][001a8cdf][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: *Infinite Recursion Detected Simulation Stopped*

The programmer made this HHH to print an invalid message. It seems that the programmer does not understand the difference between two recursions and an infinite recursion.
HHH is simply unable to decide about comparable finite recursions.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
It decides after N recursions that there is an infinite recursion, which is incorrect.
HHH is coded to abort after two recursions, so there is no infinite recursion. It is only olcott dreaming of an infinite recursion in another HHH.

 // returns to 1st instance of DDD emulated by HHH1
[00002184][00113897][0011389b] 83c404     add esp,+04
[00002187][0011389b][000015bc] 5d         pop ebp
[00002188][0011389f][0003a980] c3         ret
 // return to main
[000021a4][001037fb][00000000] 83c404     add esp,+04
[000021a7][001037fb][00000000] 33c0       xor eax,eax
[000021a9][001037ff][00000018] 5d         pop ebp
[000021aa][00103803][00000000] c3         ret
Number of Instructions Executed(352831) == 5266 Pages
    This is the exact same pattern with Infinite_Recursion()
where there are no conditional branch instructions that
would prevent the first three instructions of
Infinite_Recursion() from endlessly repeating.

No, it is the same as
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
The conditional branch instructions are in HHH, which aborts after two recursions.
DDD is a misleading and unneeded complication. It is easy to eliminate DDD:
        int main() {
          return HHH(main);
        }
This has the same problem. This proves that the problem is not in DDD, but in HHH, which halts when it aborts the simulation, but it decides that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.