Re: DD correctly emulated by HHH --- Kicking the straw-man deception out on its ass

On 3/2/25 4:49 PM, olcott wrote:

On 3/2/2025 3:29 PM, Richard Damon wrote:

On 3/2/25 4:21 PM, olcott wrote:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]
>
DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

>
WHich only shows that HHH can not correctly emulate its input and give an answer.
>

 The fact that HHH does correctly determine that DD
emulated by HHH cannot possibly reach its own "ret"
instruction and terminate normally proves that your
claim is counter factual.

You say that, but it isn't true, at least not for the problem you claim to be working on, or any sanely defined variant.
Your first error is to assume that "DD emulated by HHH" can be a proper criteria for a decider, especially a "Halt" decider or Termination Analyser.
OF course, you first fall apart by the fact that you DD has never acutaly been a program, since you have explicitly made it clear that it is ONLY the code of the "C function" that is being look at, and since it is a non-leaf function, with the HHH it is calling excluded, it is not a program. PERIOD. And your claims are just stupid lies.
When we include HHH, then your arguement about changing HHH become invalid, as then we are no longer looking at the same input, and thus agian, your argumens just become blantant lies.

 You continue to stupidly insist that HHH cannot
possibly correctly determine the termination status
of DD in a finite number of emulated steps.
 

Sincd DD does the opposite of what the HHH it calls says, it is just a fact that that HHH, or any exact copy of it, can't do it.
TO say otherwise is to say there is a logical value to the liar's paradox.
The problem is that you have brainwashed yourself that your strawman definition of "termination status" makes sense, when it is just a lie.
The *ONLY* definition of what the termination status of a PROGRAM (and we can only talk about termination status of programs) is the behavior of what it does when run. Which will also exactly match the behavior shown by a correct simulation, since that is the definition of a "correct simulation".
The big problem is your input needs to be a PROGRAM, which means it includes ALL the code that is part of it, and thus the PROGRAM DD, includes the code of the HHH that it is designed to thwart. Since whatever answer the one and only program defined to be HHH at the time does, causes DD to do the opposite, it *IS* impossible for that HHH to correctly determine that behavior.