Re: HHH maps its input to the behavior specified by it --- never reaches its halt state ---

On 8/8/24 11:03 PM, olcott wrote:

On 8/8/2024 9:52 PM, Richard Damon wrote:

On 8/8/24 9:15 AM, olcott wrote:

>
void DDD()
{
   HHH(DDD);
   return;
}
>
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
>
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
>
There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.
>
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
>
>

>
Nope, it is a lie based on comfusing the behavior of DDD which is what "Halting" is.
>

 Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.
 You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.
 

Why do I need to agree to a LIE?

*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.
 

WRONG, as proven.
The SIMULATION BY HHH doesn't reach there, but DDD does, as DDD is the direct execution of DDD, and "halting" always refers to the direct exectuion or something that behaves identically to execution, like a COMPLETE correct emulaiton.

Until you agree to these two points I will continue to
point out that you are trying to disagree with a tautology.
 

Agaim, why do I need to agree to a LIE?
You are just proving that you are trying to be deceptive and misusing definitions.
When talking about halting:
"DDD correctly simulated by HHH" must either mean that HHH does a COMPLETE and correct simulation, which means it NEVER aborts its simulation, or, as the actual English implies, that it is refering to the behavior of DDD (which is its direct execution), with the DDD being qualified as one that is corrcorrectly simualte by HHHY.
And agian, "Correctly Emulated" normally means the complete and correct emulation, and thus one that never aborts.
Now, if you do mean correctly but PARTIALLY emulated by HHH, then we can show that such an HHH creates a DDD that will call it, it will simulate for a while, and then return to that DDD, and DDD will halt.
Thus, your "tautology" either means that HHH actually does a complete and correct emulaiton, and thus you HHH can never abort its emulation to give an answer, and thus it fails to be a decider, or you are using the streached definition, and we see that (b) is not met, so it isn't a tautology.
Thus, your claim it is a tautology is a stipulation that you HHH can NEVER EVER abort its emulation of DDD, and thus you HHH is just not a decider, and you have lied that it correctly answered when it, in fact, could never have answered, or you lied that you had a tautology.
You are just caught with you hand in the cookie jar having played a shell game with word meanings.
Sorry, your proof fails.