On Monday, April 11, 2022 at 7:40:28 PM UTC-4, olcott wrote:
> On 4/11/2022 6:37 PM, Dennis Bush wrote:
> > On Monday, April 11, 2022 at 4:29:08 PM UTC-4, olcott wrote:
> >> On 4/11/2022 3:19 PM, Malcolm McLean wrote:
> >>> On Monday, 11 April 2022 at 19:39:44 UTC+1, André G. Isaak wrote:
> >>>> On 2022-04-11 12:17, olcott wrote:
> >>>>> On 4/11/2022 12:57 PM, André G. Isaak wrote:
> >>>>>> On 2022-04-10 22:32, olcott wrote:
> >>>>>>> On 4/10/2022 11:26 PM, André G. Isaak wrote:
> >>>>>>>> On 2022-04-10 22:15, olcott wrote:
> >>>>>>>>> On 4/10/2022 11:11 PM, André G. Isaak wrote:
> >>>>>>>>>> On 2022-04-10 21:01, olcott wrote:
> >>>>>>>>>>> On 4/10/2022 9:57 PM, André G. Isaak wrote:
> >>>>>>>>>>>> On 2022-04-10 20:38, olcott wrote:
> >>>>>>>>>>>>
> >>>>>>>>>>>>> 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
> >>>>>>>>>>>>
> >>>>>>>>>>>> And we're back to the meaningless notation again.
> >>>>>>>>>>>>
> >>>>>>>>>>>> You are truly incapable of learning anything.
> >>>>>>>>>>>>
> >>>>>>>>>>>> André
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> You can't remember the details between posts? Everyone else can.
> >>>>>>>>>>
> >>>>>>>>>> I can remember. But that doesn't change the fact that the notation
> >>>>>>>>>> you write above is meaningless without a condition specified.
> >>>>>>>>>>
> >>>>>>>>>> You claim you want to know how to present your ideas so you will
> >>>>>>>>>> be taken seriously. I'm trying to help with that. When someone
> >>>>>>>>>> points out an error in your notation, why insist on continuing to
> >>>>>>>>>> use the broken notation?
> >>>>>>>>>>
> >>>>>>>>>> André
> >>>>>>>>>
> >>>>>>>>> I have a single primary goal that supersedes and overrides all
> >>>>>>>>> other goals, get mutual agreement on my current stage of progress.
> >>>>>>>>
> >>>>>>>> I thought your goal was to eventually publish, which requires
> >>>>>>>> learning to use notation properly so you don't look like an
> >>>>>>>> illiterate crank.
> >>>>>>>>
> >>>>>>>>> Ĥ.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.
> >>>>>>>>>
> >>>>>>>>> embedded_H correctly rejects its input.
> >>>>>>>>
> >>>>>>>> No, it doesn't, because a correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ halts.
> >>>>>>>
> >>>>>>> The correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by the copy of H that is embedded
> >>>>>>> in Ĥ is the only thing that is being examined.
> >>>>>>
> >>>>>> There is no "correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by the copy of H that is
> >>>>>> embedded in Ĥ"
> >>>>>>
> >>>>>> H is not a simulator. It is a halt decider.
> >>>>>
> >>>>> That is a quite stupid thing to say.
> >>>>>
> >>>>> Every simulating halt decider (SHD) contains a fully functional UTM that
> >>>>> it uses to continue to simulate its input until this SHD has proof that
> >>>>> this simulation would never end.
> >>>> This claim is simply nonsense.
> >>>>
> >>>> A UTM is *defined* as a Turing Machine which takes as its input the
> >>>> description of a computation and computes what the result of that
> >>>> computation would be. While this is normally done via something which
> >>>> might be described as 'simulation', that isn't part of the definition of
> >>>> a UTM. UTMs are defined in terms of the *result* which they compute.
> >>>>
> >>>> If you have some TM which takes a string and prints an infinite number
> >>>> of copies of that string to the tape (obviously, this is a non-halting
> >>>> computation), then a UTM must also print and infinite number of copies
> >>>> of that string to the tape. Would your SHD print an infinite number of
> >>>> copies of string X when given a description of this TM and X as its
> >>>> input? Unless the answer is 'yes', you're not dealing with a UTM.
> >>>>
> >>>> And since a UTM is defined by what it does rather than by the steps it
> >>>> takes to do that, saying something acts as a UTM "until X" is entirely
> >>>> meaningless.
> >>>>
> >>> Not really. PO's idea is to have a simulator with an infinite cycle detector.
> >>> You would achieve this by modifying a UTM, so describing it as a "modified
> >>> UTM", or "acts like a UTM until it detects an infinite cycle", is reasonable.
> >>> And such a machine is a fairly powerful halt decider. Even if the infinite cycle
> >>> detector isn't very sophisticated, it will still catch a large subset of non-
> >>> halting machines. But it won't catch all non-halting machines, and it can't
> >>> be scaled up by adding features until it is perfect. And Linz's H_Hat construct
> >>> will always defeat it, which PO refuses to accept.
> >>>
> >> It is self-evident that the actual behavior of the actual simulated
> >> input is the ULTIMATE MEASURE of the correctness of any halt decider.
> >
> > So what is the actual behavior of the actual simulated input <N><5> to Ha3?
> From here on out I will totally every off topic reply.
> I won't even tell you that I am ignoring it.

It is not off topic because it perfectly illustrates that your "self-evident" criteria is nothing of the sort.

By your measure, the actual behavior of the actual simulated input <N><5> to Ha3 is non-halting and is therefore the ULTIMATE MEASURE of the correctness of Ha3, therefore it is correct.

But we've shown that that isn't the case because Ha7 accepts <N><5>. Therefore this:

> >> It is self-evident that the actual behavior of the actual simulated
> >> input is the ULTIMATE MEASURE of the correctness of any halt decider.

Has been demonstrated to be FALSE.

Which also means that this:

embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

Which can also be written (since embedded_H is the same as H, and since H aborts we can call it Ha) like this

Ha ⟨Ĥa⟩ ⟨Ĥa⟩ ⊢* Ha.qn

Is also incorrect because Hb, which has the same halt status criteria as Ha but defers aborting for k steps, does this:

Hb ⟨Ĥa⟩ ⟨Ĥa⟩ ⊢* Hb.qy

And as you said before:

---
A simulating halt decider must continue to simulate its input until it
has proof that this simulation would never end.
---

And just as Ha7 proves that Ha3 does not do this for the input <N><5>, Hb proves that Ha did not do this for the input ⟨Ĥa⟩ ⟨Ĥa⟩. Therefore Ha is *not* correct to abort ⟨Ĥa⟩ ⟨Ĥa⟩. and Linz is validated.