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

On 6/2/24 6:05 PM, olcott wrote:

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*

I guess your medication is making you blind.
Read the top line quoted from you on 6/2/24 4:50 PM
You said:
    "*We can see that the following DD cannot possibly halt*"
Remember, Halting is defined as the MACHINE reaching a fianl state, so trying to qualify it with a partial simulation is an irrelevent qualification.

 

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*

But you did in your message from 3:54 today earier in the thread:
   DD correctly emulated by HH with an x86 emulator cannot possibly
   reach past its own machine instruction [00001c2e]

 

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.

RED HERRING DIVERSION.
You are just admitting that you have run out of plausable lies.

 *We can see that the following DD cannot possibly halt*
*when correctly simulated by every HH that can possibly exist*

JUST NONSENSE WORDS AS AN ABORTED SIMULATION DOESN'T TALK ABOUT HALTING.
DD DOES Halt, as Halting talks about the behavior of the machine,
So, you are just proving your stupidity.

 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]