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

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:

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.

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

>
You are too stupid to know that a non-halting computation
cannot be emulated to completion because completion does
not exist.

>
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.
>

 typedef void (*ptr)();
int HHH(ptr P);
 void DDD()
{
   HHH(DDD);
}
 int main()
{
   DDD(DDD);
}
 When we understand that HHH is accountable for the behavior of
its input and not accountable for the behavior of the computation
that itself is contained within then we understand that HHH(DDD)
is necessarily correct to reject DDD as non-halting.
 

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.
Therefore, we see that HHH(DDD) is necessarily incorrect to reject DDD as non-halting, because HHH is known to halt after two cycles, after which also DDD halts.
The problem is that the simulated HHH runs one cycle behind the simulating HHH. When HHH aborts, it aborts the simulated halting HHH before it could halt, which makes the simulation incomplete and incorrect.
We see that 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.
Olcott does not bother to point to an error in this reasoning, because he does not have the mental intelligence to consider the possibility that he is wrong. Therefore he ignores it, using the excuse, without any evidence, that it is stupid or untrue.