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

Op 01.Jul.2024 OM 17:20 screech Wolcott:

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

But it does not correctly determine that the simulated D would never stop running. Your seem to be incompetent to understand that a C program, or x86 language that specifies N cycles of recursive simulation does stop after those cycles are all simulated, even when simulated correctly.

 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.
 

void Finite_Recursion (nit N) {
   if (N > 0) Finite_Recursion (N - 1);
}
HEH, aborting after N cycles of recursive simulation, when simulating itself, is equivalent to Finite_Recursion, not to Infinite_Recursion.