Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD

On 6/2/2024 4:43 PM, Richard Damon wrote:

On 6/2/24 5:25 PM, olcott wrote:

On 6/2/2024 3:58 PM, Richard Damon wrote:

On 6/2/24 4:50 PM, olcott wrote:

*We can see that the following DD cannot possibly halt*

>
Unless the HH(DD,DD) aborts its simulation and returns 0, then DD(DD) will ALWAYS halt when directly called, which is the definition of "Halting".
>
Not your LIE that it pertains to partial simulations.
>

*when correctly simulated by every HH that can possibly exist*

>
Except for EVERY HH that aborts its simulation and returns 0
>

>
This may be an ADD thing.
For every HH that aborts its simulation and returns 0
DD correctly simulated by this HH *DID NOT HALT AND NEVER WILL HALT*

 Except you mental problems are getting in YOUR way.
 You said that "DD Can not halt" NOT "the simulation by H of DD can not Halt"
 

*I said neither of those things so it may be an ADD problem*

Those are DIFFERENT statements.
 DD WILL Halt.
 Your claim, that I will neither confirm or deny (until you can show why I should), is that the simulation by H can never reach the statement after the call instruction.
 

*Still not quite what I said*

That is NOT a definition of "Halting", and any claim that is it is just a LIE.
 

>
Its either ADD thing in which case you salvation is not in any danger
or it is not a ADD thing.

 Nope, it is YORU STUPIDITY.
 I might suggest you talk to your oncologist, as your arguements seem to have decayed in the last year.
 DD(DD) Halts if HH(DD,DD) returns 0. PROVEN FACT.
 You can run it yourself to see.
 

>

So, I guess you are saying that NONE of your HH can EVER stop their simulation and return 0, so ALL your HH fail to be deciders by not returning any answer.
>
That, or you are just admitting to being the pathological liar that you have shown yourself to be.
>

>
When DD simulated by every HH that can possibly exist does not
halt this DOES PROVE THAT EACH DD SIMULATED BY HH DOES NOT HALT.

 If it is true that every HH that can possible exist can not simulate its ONE DD (not every on every, as you haven't shown that) to a final state, that doesn't even technically show the simulation doesn't halt, unless

Right and in this same way we cannot tell that every rock that
weighs more than five pounds weighs more than five pounds.
We may find some five pound rocks that only weigh three pounds.
*We can see that the following DD cannot possibly halt*
*when correctly simulated by every HH that can possibly exist*
typedef int (*ptr)();  // ptr is pointer to int function in C
00       int HH(ptr p, ptr i);
01       int DD(ptr p)
02       {
03         int Halt_Status = HH(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
_DD()
[00001c22] 55         push ebp
[00001c23] 8bec       mov ebp,esp
[00001c25] 51         push ecx
[00001c26] 8b4508     mov eax,[ebp+08]
[00001c29] 50         push eax        ; push DD 1c22
[00001c2a] 8b4d08     mov ecx,[ebp+08]
[00001c2d] 51         push ecx        ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342   ; call HH
[00001c33] 83c408     add esp,+08
[00001c36] 8945fc     mov [ebp-04],eax
[00001c39] 837dfc00   cmp dword [ebp-04],+00
[00001c3d] 7402       jz 00001c41
[00001c3f] ebfe       jmp 00001c3f
[00001c41] 8b45fc     mov eax,[ebp-04]
[00001c44] 8be5       mov esp,ebp
[00001c46] 5d         pop ebp
[00001c47] c3         ret
Size in bytes:(0038) [00001c47]
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer