Re: People are still trying to get away with disagreeing with the semantics of the x86 language

On 7/3/2024 10:59 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 15:21 schreef olcott:

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

Op 02.jul.2024 om 21:48 schreef olcott:

On 7/2/2024 2:22 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 20:43 schreef olcott:

On 7/2/2024 1:59 AM, Mikko wrote:

On 2024-07-01 12:44:57 +0000, olcott said:

On 7/1/2024 1:05 AM, Mikko wrote:

On 2024-06-30 17:18:09 +0000, olcott said:

Richard thinks that he can get away with disagreeing with this
verified fact:
>
The call from DDD to HHH(DDD) when N steps of DDD are
correctly emulated by any pure function x86 emulator HHH
cannot possibly return.

>
It is your HHH so you should know whether it returns. Others
may have wrong impression about it if they have trusted your
lies.

>
I have never lied about this.

>
At least you have claimed more than proven.
>

DDD is correctly emulated by HHH which calls an emulated
HHH(DDD) to repeat the process until aborted.

>
The correctness remain unproven.
>
>

IT IS PROVEN BY THE SEMANTICS OF THE X86 LANGUAGE THAT YOU REMAIN
WILLFULLY IGNORANT OF SEMANTICS OF THE X86 LANGUAGE DOES NOT MEAN
IT HAS NOT BEEN PROVEN.
>
>

Please, point to the paragraph in the specification of the X86
language that says that a two cycle recursion should be aborted
after one cycle.
Claiming that the abort is related to the x86 language is
apparently wilfully incorrect.
>
>
>

I am not going to show you the trace of the Peano axioms that prove
the 2 + 3 = 5, if you disagree you are a liar or an ignoramus.
>
>

This change of subject does not hide that your claim that the x86
language proves your claim is incorrect as a verified fact.
>
>

So you opted for liar then:
>

DDD correctly emulated by HHH calls an emulated HHH(DDD)
that emulates DDD that calls an emulated HHH(DDD)
in a cycle that cannot end unless aborted.
>
>

HHH aborts after two cycles.

 
That is not what I said. I will make in more clear.
 
DDD is correctly emulated by HHH which calls an emulated HHH(DDD)
to repeat this process an endless number of times until aborted or
out-of-memory error.