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

On 7/1/2024 10:12 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 16:50 schreef olcott:

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

Op 01.jul.2024 om 14:46 schreef olcott:

On 7/1/2024 3:32 AM, Fred. Zwarts wrote:
>
_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
>
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
Once aborted the DDD emulated by HHH immediately stops.
>
At no point in this emulation does the call from DDD
correctly emulated by HHH to HHH(DDD) ever return.
>
You can understand this or fail to understand this
disagreement is flat out incorrect.

>
I understand it, but that does not contradict that the abort is one cycle too soon, which makes it incorrect.

>
On 7/1/2024 9:27 AM, Fred. Zwarts wrote:
 > Not aborting will loop infinitely.
>
That you disagree with your own self proves that you are wrong.

 I did not disagree with myself. It is only you inability to understand simple facts that :
It is not: Either aborting or not-aborting is incorrect,
but: Both aborting and not-aborting are incorrect.
Therefore, proving that not-aborting is incorrect does not prove that aborting is correct.
You never found an error in this reasoning, but only repeat that not-aborting is incorrect.
 Somehow you seem to think that from "not-aborting is incorrect" it follows that "aborting is correct".
 Try to think a little bit. Both are incorrect.
 

>
If it is ever the case that
 > Not aborting will loop infinitely.
THIS PROVES THAT ABORTING IS NECESSARILY CORRECT
>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then
>
IT IS 100% COMPLETELY CORRECT TO ABORT
>

 It must abort to terminate the loop if the simulated HHH would not terminate, but this simulated HHH does return after N+1 cycles and therefore DDD will return, so here no abort is needed.
Abort is only needed if simulating an infinite recursion, not a N-cycle recursion.
 

You are simply not bright enough to sufficiently understand this
criteria.
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then
void Infinite_Loop()
{
   HERE: goto HERE;
}
void Infinite_Recursion()
{
   Infinite_Recursion();
}
void DDD()
{
   HHH(DDD);
}
int main()
{
   HHH(Infinite_Loop);
   HHH(Infinite_Recursion);
   HHH(DDD);
}
HHH is correct to abort all three.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer