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

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"
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.
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 you are going to stipulate an abnormal definition for a "simulation halting" to mean "simulate the input to a halting state".
In general, an operation (like you conditional simulation) is considered to have "halted' when the operation, by its own decision, has finished the work it is going to do. That is what you simulation did, so HH's simulation DID Halt, it just didn't simulate DD to a final state, so that doesn't prove that the DD that it was simulating would Halt, but it also doesn't prove that it doesn't

 Of All rocks weighing more that five pounds each rock weighs more
than five pounds.

But you have to first show that they ARE rocks of more than 5 poinds.
You have claimed that HH's partial simulation of DD will never reach a final state. That is NOT the same as showing that DD will never halt.
The fact that we have PROVEN that EVERY DD(DD) will halt if HH(DD,DD) returns 0, means you claim is just a reckless disregard for the truth, showing that you are an ignorant pathological liar.

 

>
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]
>
>

>