Re: HHH maps its input to the behavior specified by it --- reaches its halt state --- Which DDD does if HHH(DDD) returns and answer, which it does since it is a decider.

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

On 8/9/2024 6:15 AM, Richard Damon wrote:

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

On 8/8/2024 10:54 PM, Richard Damon wrote:

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

On 8/8/2024 10:34 PM, Richard Damon wrote:

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,

Now you have to agree with (a).
>

>
Why? since you statement was proven false, the accuracy of one of the terms doesn't matter.
>
I guess you don't understand how logic works, you have already shown that there is a lie in your proof, and therefore it is wrong.

>
you changed the subject and found no lie.
>

>
Nope, since HHH is being asked about HALTING, and the definition of Halting is about the behavior of the PROGRAM,

 I will not discuss that with you until after you agree
to these two tautologies proving that you intend to be honest.
 (a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.

I have shown that your (b) is NOT a tautology, unless you stipulate that your HHH NEVER aborts its emulation and return EVER.

 You agreed with (b). No more head games about correct simulation.

No, I didn't, not unless you agree that no HHH ever aborts its emulation and returns.

 _DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
 It is also a fact that the above machine code has one
halt state at machine address 00002183.
 Until you agree with that statement that is true by
definition you remain stuck in a circle of trollish
head games. It won't take long before I quit looking
at anything you say.
 

And it WILL reach that instruction if HHH(DDD) EVER aborts its simulation and returns.
So, you have to decide, do you want you (b) and HHH isn't a decider, or is HHH a decider and you don't get your (b).
You can't have them both, so you "proof" is just wrong and based on the lying shell game of changing definitions.
Sorry, the jig is up and you have been exposed.
You have been lying for years, and there is nothing you can do to refute that, as you have admittted by not providing a shread of evidence to support your claims, just your bluster.