On Sunday, April 10, 2022 at 10:53:38 PM UTC-4, olcott wrote:
> On 4/10/2022 9:47 PM, Dennis Bush wrote:
> > On Sunday, April 10, 2022 at 10:44:25 PM UTC-4, olcott wrote:
> >> On 4/10/2022 9:41 PM, Dennis Bush wrote:
> >>> On Sunday, April 10, 2022 at 10:38:33 PM UTC-4, olcott wrote:
> >>>> On 4/10/2022 9:32 PM, Dennis Bush wrote:
> >>>>> On Sunday, April 10, 2022 at 10:27:20 PM UTC-4, olcott wrote:
> >>>>>> On 4/10/2022 9:17 PM, Dennis Bush wrote:
> >>>>>>> On Sunday, April 10, 2022 at 10:09:41 PM UTC-4, olcott wrote:
> >>>>>>>> On 4/10/2022 9:06 PM, Dennis Bush wrote:
> >>>>>>>>> On Sunday, April 10, 2022 at 10:02:56 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 4/10/2022 8:59 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Sunday, April 10, 2022 at 9:55:22 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 4/10/2022 8:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:43:47 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 4/10/2022 8:38 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:36:11 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 4/10/2022 8:30 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:26:57 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 4/10/2022 8:17 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:13:23 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 4/10/2022 8:10 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:07:18 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 8:03 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 9:00:25 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 7:44 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 8:40:34 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 7:28 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 7:58:55 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 6:26 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, April 10, 2022 at 7:20:44 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 6:14 PM, André G. Isaak wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-04-10 17:08, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 5:59 PM, André G. Isaak wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-04-10 16:40, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 5:35 PM, André G. Isaak wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-04-10 15:56, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 4:49 PM, André G. Isaak wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2022-04-10 15:00, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 3:15 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/10/2022 3:07 PM, André G. Isaak wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I'm trying to get you to write using correct and coherent
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> notation. That's one of the things you'll need to be able to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do if you ever hope to publish. That involves remembering to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always include conditions and using the same terms in your
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'equations' as in your text.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Not sure how that makes me a 'deceitful bastard'.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> André
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT you pretended to not know what I mean by embedded_H so
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you could artificially contrive a fake basis for rebuttal
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when no actual basis for rebuttal exists makes you a deceitful
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bastard.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IT IS THE CASE THAT the correctly simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H never reaches its own final state of ⟨Ĥ0.qy⟩ or
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ0.qn⟩ under any condition what-so-ever therefore ⟨Ĥ0⟩ ⟨Ĥ1⟩ is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved to specify a non-halting sequence of configurations.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qy
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ2⟩ ⊢* H.qn
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is now the third reply you've made to the same post.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That post didn't make any arguments whatsoever about your claims.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It simply pointed out that you are misusing your notation and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> urged you to correct it.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THE NOTATION IS A STIPULATIVE DEFINITION THUS DISAGREEMENT IS
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INCORRECT.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the notation is junk, then the definition is also junk.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's like "stipulating" that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +×yz÷² = ±z+³
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's meaningless because the notation is meaningless, much like
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your notation above.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is meaningless:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qy // what's the condition?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qn // what's the condition?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> With no conditions specified, the above is just nonsense.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> André
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is still nonsense.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H would reach its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> own final state.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H would never
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its own final state.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And again you're still being inconsistent.. You can either use H or use
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H, but you can't mix the two.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sure I can. I just did.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This means that H pretends that it is only a UTM to see what its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would do in this case. If it would never reach its own
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state then H correctly rejects this input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A Turing Machine cannot "pretend" to be some different Turing Machine.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It can perform a pure simulation of its input until this simulated input
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a repeating behavior pattern that proves this input never
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its own final state.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> If that's the case, why does an actual UTM applied to the *same* input halt?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hint: Because the result of an actual UTM applied to the input defines the correct answer, so H answers wrong.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Intuitively that would seem to be true, this intuition is incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The ultimate definition of correct is the computation of the mapping of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> the inputs to an accept or reject state on the basis of the behavior
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> that these inputs specify.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> That simulated inputs to embedded_H would never reach their own final
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> state under any condition what-so-ever
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> IS THE ULTIMATE MEASURE OF THEIR HALTING BEHAVIOR
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> and conclusively proves they specify a non-halting sequence of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Since embedded_H is the same as H (as you have yet to provide any evidence to the contrary), then the above can be applied to any simulating halt decider.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> The topic is the single point that the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to
> >>>>>>>>>>>>>>>>>>>>>>>>>> embedded_h cannot possibly reach its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> And that same logic gives us this:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> That simulated inputs <N><5> to Ha3 would never reach their own final
> >>>>>>>>>>>>>>>>>>>>>>>>> state under any condition what-so-ever
> >>>>>>>>>>>>>>>>>>>>>>>>> IS THE ULTIMATE MEASURE OF THEIR HALTING BEHAVIOR
> >>>>>>>>>>>>>>>>>>>>>>>>> and conclusively proves they specify a non-halting sequence of
> >>>>>>>>>>>>>>>>>>>>>>>>> configurations.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> THE SIMULATED INPUT CANNOT POSSIBLY REACH ITS OWN FINAL STATE
> >>>>>>>>>>>>>>>>>>>>>>>>> THIS SINGLE FACT BY ITSELF PROVES THAT THE INPUT IS CORRECTLY REJECTED
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Try to find an error in the above.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> That simulated inputs <N><5> to Ha3
> >>>>>>>>>>>>>>>>>>>>>>>> are pure nonsense gibberish.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> So you agree that Ha3 is correct to reject <N><5>?
> >>>>>>>>>>>>>>>>>>>>>> It has no associated meaning
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Sure it does. Ha3 is a simulating halt decider whose halt status criteria is to abort after 3 steps, and N takes <n> as input and runs for exactly n steps before halting in state N.qy. And Ha3 rejects <N><5>.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> That simulated inputs <N><5> to Ha3 would never reach their own final
> >>>>>>>>>>>>>>>>>>>> You are starting with a broken halt decider, my rules only apply to
> >>>>>>>>>>>>>>>>>>>> correct halt deciders.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> It is like you are saying that no one can possibly drive their car and
> >>>>>>>>>>>>>>>>>>>> to prove this you drive your car into a tree.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> So what criteria would you apply to Ha3 to determine that it's broken?
> >>>>>>>>>>>>>>>>>> I would simply say that ridiculously stupid ideas such as Ha3 should
> >>>>>>>>>>>>>>>>>> never be presented by someone with your top 0.04% reputation they
> >>>>>>>>>>>>>>>>>> denigrate you. You must know how stupid this idea was before you first
> >>>>>>>>>>>>>>>>>> mentioned it.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> If it's so obvious to you that Ha3 is broken, then you should be able to explain exactly how to determine that.
> >>>>>>>>>>>>>>>> Obviously a very lame attempt at a head game by a guy with your reputation.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Explain how you would determine Ha3 is broken. If you don't, I'll be forced to conclude that you agree that it's correct.
> >>>>>>>>>>>>>> I will quit talking to you until you stop the head games.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> That you have difficultly following my logic (actually, your own logic applied to a different halt decider) doesn't mean I'm playing head games.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Explain exactly how you would determine that Ha3 is broken, or admit that it is not.
> >>>>>>>>>>>> You know that the question is mere denigration:
> >>>>>>>>>>>> https://en.wikipedia.org/wiki/UFTP
> >>>>>>>>>>>
> >>>>>>>>>>> This is how you know you're stuck, when you go completely off topic.
> >>>>>>>>>>>
> >>>>>>>>>>> Explain exactly how you would determine that Ha3 is broken, or admit that it is not.
> >>>>>>>>>> I will ask you a similar question in the same vein:
> >>>>>>>>>>
> >>>>>>>>>> Exactly how do you know that driving a car into a tree is not a very
> >>>>>>>>>> good way to see how a car drives, please provide every single detail.
> >>>>>>>>>
> >>>>>>>>> Dishonest dodge.
> >>>>>>>>>
> >>>>>>>>> If Ha3 is broken, explain exactly how you would determine that. Tell us how you would determine that the result that a simulating halt decider gives is correct.
> >>>>>>>> I thought of a good way to answer this.
> >>>>>>>> It does not meet the specs of a simulating halt decider.
> >>>>>>>>
> >>>>>>
> >>>>>> A simulating halt decider must continue to simulate its input until it
> >>>>>> has proof that this simulation would never end.
> >>>>>>>
> >>>>>>> Since a given halt decider X has a fixed algorithm, that would mean the input would need to be passed to a different halt decider Y. So if Y showed that the input halts, would you agree that it shows that X was incorrect to report non-halting?
> >>>>>> The given halt decider has a fixed algorithm that can be applied to any
> >>>>>> input on its tape. The whole idea of Y seems pretty crazy.
> >>>>>
> >>>>> Multiple candidate halt deciders H can exist, with each one potentially getting cases right that another might get wrong. Ha3 is one of these. The multiple halt deciders you refer to as "H" (and which Ha3 is actually a part of) are others. So if one simulating halt decider X reports a given input as non-halting, and if another simulating halt decider Y is given the same input and reports halting, would you agree that Y shows that X was incorrect because it didn't simulate for long enough?
> >>>>>
> >>>> That is too far off topic. I have been talking circles with Ben for 17
> >>>> years. We now must talk in hierarchies, cyclic paths are trimmed off of
> >>>> the decision tree.
> >>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qy
> >>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qn
> >>>>
> >>>> When Ĥ is applied to ⟨Ĥ0⟩
> >>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
> >>>> H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
> >>>> Then these steps would keep repeating:
> >>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
> >>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
> >>>>
> >>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H never
> >>>> reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know that it is
> >>>> non-halting.
> >>>
> >>> Now you're the one getting off topic. We were talking about how to determine whether a given simulating halt decider is giving the correct answer, which is actually relevant to what you just posted.
> >>>
> >>> If one simulating halt decider X reports a given input as non-halting, and if another simulating halt decider Y is given the same input and reports halting, would you agree that Y shows that X was incorrect because it didn't simulate for long enough?
> >>>
> >> There is a single ULTIMATE MEASURE of the correctness of a halt decider
> >> and that is whether its correctly simulated input would halt.
> >
> > That being the case, if X simulates a given input and reports non-halting, and Y simulates the same input and (never leaving UTM mode) reports halting, wouldn't that mean the correctly simulated input would halt?
> It is self-evident that the actual behavior of the actual simulated
> input is the ULTIMATE MEASURE of the correctness of any halt decider.
>
> In epistemology (theory of knowledge), a self-evident proposition is a
> proposition that is known to be true by understanding its meaning
> without proof... https://en.wikipedia.org/wiki/Self-evidence

But but that logic, the actual behavior of the actual simulated input <N><5> to Ha3 is non-halting. You don't seem to agree with that, which would mean that your claim that "the actual behavior of the actual simulated input is the ULTIMATE MEASURE of the correctness of any halt decider" doesn't make sense.

So you need some other way to determine if a given simulating halt decider is correct to abort a given input, and some other simulating halt decider simulating that same input to a final state would indicate that the first was *not* correct to abort and report non-halting.

Agreed?