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

On 6/2/24 11:20 PM, olcott wrote:

On 6/2/2024 10:13 PM, Richard Damon wrote:

On 6/2/24 10:54 PM, olcott wrote:

IT HAS ALWAYS BEEN ABOUT THE BEHAVIOR THAT THE INPUT SPECIFIES.
That you did get confused by the Linz text proves that you do
get confused. Previously it looked just like willful deception.

>
Which is, for a Halt Decider, exactly and only the behavior of the Turing Machine the input describes.
>
PERIOD.
>
Anything else is just a LIE.
>

>

You don't seem to understand that you can't just "redefine" the system to meet your desires.
>

>
Deciders compute the mapping FROM THEIR INPUTS.
DD correctly simulated by HH specifies NON-HALTING.

>
No, Running DD(DD) and seeing that it will never, after an unbounded number of steps, indicate it is non-halting.
>
DEFINITION.
>

>
Deciders compute the mapping FROM THEIR INPUTS.
DD correctly simulated by HH specifies NON-HALTING.

>
Right, and the input is a representation of a Turing Machine and its input, whose behavior the decider is to decide on.
>

>
Deciders compute the mapping FROM THEIR INPUTS.
DD correctly simulated by HH specifies NON-HALTING.
>

>
And that is the machine the input describes.
>
ANYTHING ELSE IS JUST A LIE.
>

You can't get away with implicitly saying that you
just don't "believe in" UTMs.

>
I do, and a UTM is DEFINED as a machine that exactly reproduces the behavior of the machine described by its input.
>

 *If that was true then you prove that this statement is false*
*We can see that the following DD cannot possibly halt when*
*correctly simulated by every HH that can possibly exist*

I have.
You keep of forgetting that the phrase "DD cannot possibly halt" means, and only mean, that the direct execution of DD can not possible reach a final state.
Thus, the subordinate clause "when correctly simulated by evry HH that can possible exist" doesn't change the base condition of what is being measured, but perhaps the time when you make that measurement (a non-sence concept as the property does change with time) or which DD we are looking at, which just means that we are looking at a DD that has been paired with an HH that does your correct partial simulation of DD.
So, given the requirement that your HH be a decider, we can remove from the set of HHs that we can use, those that never abort there simulation, and thus every HH in your set, when passed DD, has been show to ALWAY return 0.
Thus, the trace of DD(DD) shows that it will call HH(DD,DD), and that will run for some period of time, and then it will abort its "correct" (but partial) simulation of DD (which doesn't show DD to be non-halting, just didn't halt yet) and return 0 to DD which will then Halt.
Thus, we have DISPROVED your statement, YET AGAIN, proving you to be a liar that just doesn't understand what he is talking about.

 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]