Re: Because Olcott has made this error 500 times in the last three years...

Op 26.jul.2024 om 21:23 schreef olcott:

On 7/26/2024 2:16 PM, joes wrote:

Am Fri, 26 Jul 2024 11:02:45 -0500 schrieb olcott:

On 7/26/2024 10:30 AM, Fred. Zwarts wrote:

Op 26.jul.2024 om 16:16 schreef olcott:

On 7/26/2024 8:53 AM, Fred. Zwarts wrote:

Op 26.jul.2024 om 15:22 schreef olcott:

On 7/26/2024 1:53 AM, Fred. Zwarts wrote:

Op 26.jul.2024 om 03:49 schreef olcott:

>

We understand it perfectly. HHH cannot possibly simulate itself
correctly.

>

The non-halting behaviour is only in your dreams. It is irrelevant,
because HHH halts when it aborts. Remember, HHH is simulating
*itself*, a halting program, not another non-halting simulator that
does not abort and does not halt.

>

We see that the only thing DDD does is calling HHH. So, HHH is fully
accountable for the behaviour of DDD and its code is included in the
program that must be simulated, otherwise the call from DDD to HHH
would result in an error.

>
No decider is ever accountable for the behavior of the computation that
itself is contained within.
HHH(DDD) is accountable for the behavior of its input and is not
accountable for the behavior of the computation that itself is contained
within: the directly executed DDD();

 

And those happen to be the same.
>

 This all goes back to you refusing to acknowledge
that you understand what infinite recursion is,
thus failing to recognize the infinite recursion
behavior pattern.

You still keep saying that two equals infinite.
There is no infinite recursion.
HHH is simply unable to decide about 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.

 _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
 *That also occurs below*
 typedef void (*ptr)();
int HHH(ptr P);
 void DDD()
{
   HHH(DDD);
}
 int main()
{
   DDD();
}
 HHH(DDD) is accountable for the behavior of its input and is
not accountable for the behavior of the computation that itself
is contained within: the directly executed DDD();
 _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] e8d8ffffff       call 00002177 ; call DDD
[0000219f] 33c0             xor eax,eax
[000021a1] 5d               pop ebp
[000021a2] c3               ret
Size in bytes:(0012) [000021a2]
   machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002197][001037e9][00000000] 55         push ebp
[00002198][001037e9][00000000] 8bec       mov ebp,esp
[0000219a][001037e5][0000219f] e8d8ffffff call 00002177 ; call DDD
[00002177][001037e1][001037e9] 55         push ebp
[00002178][001037e1][001037e9] 8bec       mov ebp,esp
[0000217a][001037dd][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][001037d9][00002184] e853f4ffff call 000015d7 ; call HHH
 // executed HHH emulates 1st instance of DDD
New slave_stack at:10388d
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895
[00002177][00113885][00113889] 55         push ebp
[00002178][00113885][00113889] 8bec       mov ebp,esp
[0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
 // emulated HHH emulates 2nd instance of DDD
New slave_stack at:14e2b5
[00002177][0015e2ad][0015e2b1] 55         push ebp
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp
[0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Incorrect message programmed after two recursions.
So, either HHH is simulating *itself* and the simulated HHH would abort and return one cycle later,
or you illegally modified the simulated HHH to be different from the simulating HHH, so that it does not abort, as we have seen recently.

 [00002184][001037e1][001037e9] 83c404     add esp,+04
[00002187][001037e5][0000219f] 5d         pop ebp
[00002188][001037e9][00000000] c3         ret
[0000219f][001037e9][00000000] 33c0       xor eax,eax
[000021a1][001037ed][00000018] 5d         pop ebp
[000021a2][001037f1][00000000] c3         ret
Number of Instructions Executed(10071) == 150 Pages