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

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

On 6/2/2024 5:20 PM, Richard Damon wrote:

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*"
>

 *Deceitfully taking things out of context*
 On 6/2/2024 3:50 PM, olcott wrote:
 > *We can see that the following DD cannot possibly halt*
 > *when correctly simulated by every HH that can possibly exist*

But the second line doesn't change the meaning of the first line, as Halting ALWAYS (unless clearly modified) refers to the behavior of the machine.
It just qualifies which DD we might be talking about.
Just like the sentence:
We can see that the house was red when the ball went through the window.
The ball going through the window doesn't affect the color attribute of the house. It might qualify the WHEN (but Halting of a machine isn't dependent on time) or which house we are talking about (so it clearly makes it a DD that it paired to an HH), but it doesn't affect the color.
Just like the fact that you have given the description of this DD to HH, doesn't affect the behavior of that instance of DD, it only might indicate that it HAS been paired with such an HH and not some other thing.

 

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

 If you get my words 99.99999% perfectly then you screwed up
far too much, thus 80% is not in the ballpark.

So, if you ever slightm

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

Nope ABSOLUTE LIE.
Hlating is a property of the MACHINE  /  PROGRAM, not the simulation.
DD(DD) WILL HALT as long as HH(DD,DD) returns 0, and any HH(DD,DD) that doesn't return 0 fails to meet your requirement that HH be a decider, so we can automatically filter those out.
You not understanding what your words mean is YOUR problem.
And you are just proving that you have a reckless disregard for the truth, showing that you are just an ignorant pathologial liar.
You MIGHT be able to claim that the SIMULATION of DD when correctly performed by HH can never reach a final state. That is the claim you seem to be working on, which i will neither confirm nor deny until we handle this issue.,
Your statement about HALTING is just incorrect.
Try to PROVE your statement
Quote ACTULAL Definitions and accepted scholarly publish works in the field.
So far, it is just "Olcott says" and Olcott has been proven to LIE and is often mistaken, so not a reliable source.

 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]