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 8:52 PM, olcott wrote:

On 8/9/2024 6:46 PM, Richard Damon wrote:

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

 One thing good about you being stuck in rebuttal mode
it that this keeps making my words get clearer and clearer.

No, you are stuck in LYING MODE.

 When we look at every HHH that can possibly exist then
we see that DDD correctly emulated by each one of these
cannot possibly reach its "return" instruction halt state.

But ONLY ONE of those actuallu "correctly emulates" the input, and that one isn't a decider.
You just confuse the fact that a PARTIAL emulation not reaching a final state doesn't show that this input doesn't reach a final state later
And, you seem to not understand that the code of HHH is part of the code of the PROGRAM DDD that must be given to HHH to decide, and thus every one of your infinite set have a DIFFERENT input from all the others, and thus you can't use one emulation to tell you what the other emulations will do, in particular, the VERY DIFFERENT HHH that never aborts, creates a radically different input then the ones that do abort and return.
If you want to try to claim the input is only the bytes of the C function DDD, then you are just demonstrating that you don't know what a program is, and NO HHH can emulate that input more than 4 instructions, so you claim is just a LIE>

 Now you are trying to get away with claiming that there
are some HHH that do not belong to the set of every HHH
that can possibly exist.
 

Nope, where did I say that? That seems to be just another of your impossible so substantiate claims that proves you to be a liar.
I am just pointing out that partial emulation do not show that the complete behavior (which is what halting by definitiion looks at) does not later hit a final state, and in fact, we can PROVE for all your HHH that do abort and return that the DDD built on them DOES halt, and thus all of them are incorrect to say their input is non-halting.
Sorry, you just don't have anything to stand on but your bluster and double-talk.