On 4/10/2022 7:05 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/10/2022 4:18 PM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/10/2022 10:52 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 4/9/2022 5:54 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>>>>>>> It is the case that the correctly simulated input to embedded_H can
>>>>>>>>>>>>>>>>>> never possibly reach its own final state under any condition at all.
>>>>>>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yet you won't answer two simple questions! Why?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because I absolutely positively will not tolerate divergence from
>>>>>>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But you have no choice but to tolerate it. If someone wants to talk
>>>>>>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) == false but P(P)
>>>>>>>>>>>>>>> halts. You are wrong about your TM H because H <Ĥ> <Ĥ> transitions to
>>>>>>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel free to deny
>>>>>>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you believe (against the verified facts) that the simulated ⟨Ĥ0⟩
>>>>>>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>> I believe what you've told me: that you claim that H(P,P)==false is
>>>>>>>>>>>>> correct despite the fact that P(P) halts. That's wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> If the input to H(P,P) cannot possibly reach its final state then this
>>>>>>>>>>>> input is correctly rejected and nothing in the universe can possibly
>>>>>>>>>>>> contradict this.
>>>>>>>>>>>
>>>>>>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts. You don't dispute
>>>>>>>>>>> either (indeed they come from you).
>>>>>>>>> At least you don't contend these facts.
>>>>>>>>>
>>>>>>>>>>> Your new line in waffle is just an attempt to distract attention from a
>>>>>>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>>>>>>
>>>>>>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>>>>>>
>>>>>>>>>> A halt decider must compute the mapping from its inputs (not any damn
>>>>>>>>>> thing else in the universe) to its own final state on the basis of the
>>>>>>>>>> behavior specified by these inputs
>>>>>>>>>
>>>>>>>>> That's not counter intuitive, it's basic. Everyone knows this, though
>>>>>>>>> it took you a while to get round to it. A halt decider accepts or
>>>>>>>>> rejects a string based on the behaviour of the computation specified by
>>>>>>>>> that string. Of course, you never got as far in my exercises as
>>>>>>>>> specifying any TM that decides something on the basis of behaviour, so
>>>>>>>>> you really don't know how it's actually done. That was, I thought, the
>>>>>>>>> whole point of the exercises -- to see how TMs are specified to decide
>>>>>>>>> properties of computations.
>>>>>>>>
>>>>>>>> You have to actually pay attention to this,
>>>>>>>
>>>>>>> Flip, flop! Back to being wrong about TMs rather than being wrong about
>>>>>>> your old C junk. These uncontested facts: (1) H(P,P) == false, (2) P(P)
>>>>>>> halts are why your H and P are wrong.
>>>>>>
>>>>>> If you are able to break the problem down to it micro component parts
>>>>>> and carefully analyze each of these separately instead of simply
>>>>>> slipping down the slide of intuition then you can see that I am
>>>>>> correct.
>>>>>>
>>>>>> If it is true that the correct simulation input to H(P,P) cannot
>>>>>> possibly reach its own final state then
>>>>>>
>>>>>> The input to H(P,P) is non-halting then
>>>>> There is no "input to H(P,P)".
>>>>
>>>> The correct simulation of the input to H
>>> Better. I still would not call it "input" (since these are C functions)
>>> but you've got the hang of what am saying. Well done.
>>>
>>>> cannot possibly ever reach it final state thus is a non-halting
>>>> sequence of configurations even if everyone and everything in the
>>>> universe disagrees.
>>>
>>> The truth is not determined by who does or does not agree with
>>> something. But to find the truth of the matter you must first stop
>>> talking literal nonsense. The arguments to H (what you call the
>>> "input") are two pointers. What does simulating two pointers mean?
>>> What you mean, I hope, is simulating calling the first pointer with the
>>> second as it's argument. That simulation, according to you, will halt
>>> (or "reach it's final state" in your flamboyant, sciencey, language).
>>> It will halt because the direct call P(P) halts. Everything here halts
>>> (according to you). That's why H is wrong.
>>
>> You simply are ignoring the actual execution trace that conclusively
>> proves that the simulated input to H cannot possibly reach its final
>> own state.
>
> The traces that matter are the one of P(P) halting (you made the mistake
> of posting it once), and the one of H(P,P) return false (you posted that
> as well). You a free to retract any of these at any time, but until you
> do, your H is wrong by your own supplied traces.
>

It is never the case that the simulated input to H(P,P) ever reaches its
own final state.

_P()
[00000956](01) 55 push ebp
[00000957](02) 8bec mov ebp,esp
[00000959](03) 8b4508 mov eax,[ebp+08]
[0000095c](01) 50 push eax
[0000095d](03) 8b4d08 mov ecx,[ebp+08]
[00000960](01) 51 push ecx

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.

Which brings us back to Ha3, which is a simulating halt decider whose halt status criteria is to abort after 3 steps, and N, which takes <n> as input and runs for exactly n steps before halting in state N.qy. Ha3 rejects <N><5>. This means:

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.

On 4/10/22 7:58 PM, 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.

And the behavior that these input specify is the behavior of H^ applied
to <H^>.

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

Nope, the CORRECT simulation of the inputs (by a REAL UTM) does reach a
final state if H / embedded_H applied to <H^> <H^> goes to H.Qn (and if
H / embedded_H ooesn't do that, then it fails to give an answer and thus
fails to be a Halt Decider)

The simulation that doesn't reach its final state is the simulation by H
/ embedded_H. If that does abort its simulation, then it is not a UTM so
its failure to reach a final state is irrelevent. If it doesn't abort
its simulation then it doesn't answer and fails to be a decider.

So, your H / embedded_H isn't correct, because it is NOT the ultimate
measure of their halting behavior, that is the behavior of H^ applied to
<H^> which halt if H / embedded_H rejects its input and goes to H.Qn.

So, FAIL.

On 4/10/22 8:02 PM, olcott wrote:
> On 4/10/2022 7:00 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/10/2022 4:41 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>> The above means this:
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>> That's funny!  You really have no idea what this notation means, do
>>>> you?
>>>>
>>>>> embedded_H is a simulating halt decider that has a full UTM embedded
>>>>> within it. As soon as it sees that the pure UTM simulation of its
>>>>> input would never reach the final state of this input it aborts this
>>>>> simulation and rejects this non-halting input.
>>>>
>>>> So you had no business writing those two junk lines, did you?  Or do
>>>> you
>>>> really think that they are in some way compatible with that last
>>>> paragraph?  Probably neither.  I really think you see it much like
>>>> poetry.  Meanings are supposed to be intuited from unusual, often
>>>> metaphorical, juxtapositions of symbols.
>>>
>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qy
>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ2⟩ ⊢* H.qn
>>
>> Still junk.
>>
>
> Ĥ.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.
>

Right, and the CORRECTLY simulated input <H^> <H^> will behave exactly
like H^ applied to <H^> (That is the DEFINITION of Correct Simulation)
which Halts if H applied to <H^> <H^> goes to H.qn, so that answer must
be wrong.

FAIL.

On 4/10/22 8:09 PM, olcott wrote:
> On 4/10/2022 7:05 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/10/2022 4:18 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/10/2022 10:52 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/9/2022 5:54 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>>>>>>>> never possibly reach its own final state under any
>>>>>>>>>>>>>>>>>>> condition at all.
>>>>>>>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject
>>>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because I absolutely positively will not tolerate
>>>>>>>>>>>>>>>>> divergence from
>>>>>>>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But you have no choice but to tolerate it.  If someone
>>>>>>>>>>>>>>>> wants to talk
>>>>>>>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) ==
>>>>>>>>>>>>>>>> false but P(P)
>>>>>>>>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>>>>>>>>> transitions to
>>>>>>>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel
>>>>>>>>>>>>>>>> free to deny
>>>>>>>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you believe (against the verified facts) that the
>>>>>>>>>>>>>>> simulated ⟨Ĥ0⟩
>>>>>>>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I believe what you've told me: that you claim that
>>>>>>>>>>>>>> H(P,P)==false is
>>>>>>>>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the input to H(P,P) cannot possibly reach its final
>>>>>>>>>>>>> state then this
>>>>>>>>>>>>> input is correctly rejected and nothing in the universe can
>>>>>>>>>>>>> possibly
>>>>>>>>>>>>> contradict this.
>>>>>>>>>>>>
>>>>>>>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You
>>>>>>>>>>>> don't dispute
>>>>>>>>>>>> either (indeed they come from you).
>>>>>>>>>> At least you don't contend these facts.
>>>>>>>>>>
>>>>>>>>>>>> Your new line in waffle is just an attempt to distract
>>>>>>>>>>>> attention from a
>>>>>>>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>>>>>>>
>>>>>>>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>>>>>>>
>>>>>>>>>>> A halt decider must compute the mapping from its inputs (not
>>>>>>>>>>> any damn
>>>>>>>>>>> thing else in the universe) to its own final state on the
>>>>>>>>>>> basis of the
>>>>>>>>>>> behavior specified by these inputs
>>>>>>>>>>
>>>>>>>>>> That's not counter intuitive, it's basic.  Everyone knows
>>>>>>>>>> this, though
>>>>>>>>>> it took you a while to get round to it.  A halt decider
>>>>>>>>>> accepts or
>>>>>>>>>> rejects a string based on the behaviour of the computation
>>>>>>>>>> specified by
>>>>>>>>>> that string.  Of course, you never got as far in my exercises as
>>>>>>>>>> specifying any TM that decides something on the basis of
>>>>>>>>>> behaviour, so
>>>>>>>>>> you really don't know how it's actually done.  That was, I
>>>>>>>>>> thought, the
>>>>>>>>>> whole point of the exercises -- to see how TMs are specified
>>>>>>>>>> to decide
>>>>>>>>>> properties of computations.
>>>>>>>>>
>>>>>>>>> You have to actually pay attention to this,
>>>>>>>>
>>>>>>>> Flip, flop!  Back to being wrong about TMs rather than being
>>>>>>>> wrong about
>>>>>>>> your old C junk.  These uncontested facts: (1) H(P,P) == false,
>>>>>>>> (2) P(P)
>>>>>>>> halts are why your H and P are wrong.
>>>>>>>
>>>>>>> If you are able to break the problem down to it micro component
>>>>>>> parts
>>>>>>> and carefully analyze each of these separately instead of simply
>>>>>>> slipping down the slide of intuition then you can see that I am
>>>>>>> correct.
>>>>>>>
>>>>>>> If it is true that the correct simulation input to H(P,P) cannot
>>>>>>> possibly reach its own final state then
>>>>>>>
>>>>>>> The input to H(P,P) is non-halting then
>>>>>> There is no "input to H(P,P)".
>>>>>
>>>>> The correct simulation of the input to H
>>>> Better.  I still would not call it "input" (since these are C
>>>> functions)
>>>> but you've got the hang of what am saying.  Well done.
>>>>
>>>>> cannot possibly ever reach it final state thus is a non-halting
>>>>> sequence of configurations even if everyone and everything in the
>>>>> universe disagrees.
>>>>
>>>> The truth is not determined by who does or does not agree with
>>>> something.  But to find the truth of the matter you must first stop
>>>> talking literal nonsense.  The arguments to H (what you call the
>>>> "input") are two pointers.  What does simulating two pointers mean?
>>>> What you mean, I hope, is simulating calling the first pointer with the
>>>> second as it's argument.  That simulation, according to you, will halt
>>>> (or "reach it's final state" in your flamboyant, sciencey, language).
>>>> It will halt because the direct call P(P) halts.  Everything here halts
>>>> (according to you).  That's why H is wrong.
>>>
>>> You simply are ignoring the actual execution trace that conclusively
>>> proves that the simulated input to H cannot possibly reach its final
>>> own state.
>>
>> The traces that matter are the one of P(P) halting (you made the mistake
>> of posting it once), and the one of H(P,P) return false (you posted that
>> as well).  You a free to retract any of these at any time, but until you
>> do, your H is wrong by your own supplied traces.
>>
>
>
>
> _P()
> [00000956](01)  55              push ebp
> [00000957](02)  8bec            mov ebp,esp
> [00000959](03)  8b4508          mov eax,[ebp+08]
> [0000095c](01)  50              push eax
> [0000095d](03)  8b4d08          mov ecx,[ebp+08]
> [00000960](01)  51              push ecx
>
> // keeps going to [00000956] until aborted

On 4/10/22 8:25 PM, olcott wrote:
> On 4/10/2022 7:05 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 4/10/2022 4:18 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 4/10/2022 10:52 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/9/2022 5:54 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>>>>>>>> never possibly reach its own final state under any
>>>>>>>>>>>>>>>>>>> condition at all.
>>>>>>>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject
>>>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because I absolutely positively will not tolerate
>>>>>>>>>>>>>>>>> divergence from
>>>>>>>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But you have no choice but to tolerate it.  If someone
>>>>>>>>>>>>>>>> wants to talk
>>>>>>>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) ==
>>>>>>>>>>>>>>>> false but P(P)
>>>>>>>>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>>>>>>>>> transitions to
>>>>>>>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel
>>>>>>>>>>>>>>>> free to deny
>>>>>>>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you believe (against the verified facts) that the
>>>>>>>>>>>>>>> simulated ⟨Ĥ0⟩
>>>>>>>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I believe what you've told me: that you claim that
>>>>>>>>>>>>>> H(P,P)==false is
>>>>>>>>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If the input to H(P,P) cannot possibly reach its final
>>>>>>>>>>>>> state then this
>>>>>>>>>>>>> input is correctly rejected and nothing in the universe can
>>>>>>>>>>>>> possibly
>>>>>>>>>>>>> contradict this.
>>>>>>>>>>>>
>>>>>>>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You
>>>>>>>>>>>> don't dispute
>>>>>>>>>>>> either (indeed they come from you).
>>>>>>>>>> At least you don't contend these facts.
>>>>>>>>>>
>>>>>>>>>>>> Your new line in waffle is just an attempt to distract
>>>>>>>>>>>> attention from a
>>>>>>>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>>>>>>>
>>>>>>>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>>>>>>>
>>>>>>>>>>> A halt decider must compute the mapping from its inputs (not
>>>>>>>>>>> any damn
>>>>>>>>>>> thing else in the universe) to its own final state on the
>>>>>>>>>>> basis of the
>>>>>>>>>>> behavior specified by these inputs
>>>>>>>>>>
>>>>>>>>>> That's not counter intuitive, it's basic.  Everyone knows
>>>>>>>>>> this, though
>>>>>>>>>> it took you a while to get round to it.  A halt decider
>>>>>>>>>> accepts or
>>>>>>>>>> rejects a string based on the behaviour of the computation
>>>>>>>>>> specified by
>>>>>>>>>> that string.  Of course, you never got as far in my exercises as
>>>>>>>>>> specifying any TM that decides something on the basis of
>>>>>>>>>> behaviour, so
>>>>>>>>>> you really don't know how it's actually done.  That was, I
>>>>>>>>>> thought, the
>>>>>>>>>> whole point of the exercises -- to see how TMs are specified
>>>>>>>>>> to decide
>>>>>>>>>> properties of computations.
>>>>>>>>>
>>>>>>>>> You have to actually pay attention to this,
>>>>>>>>
>>>>>>>> Flip, flop!  Back to being wrong about TMs rather than being
>>>>>>>> wrong about
>>>>>>>> your old C junk.  These uncontested facts: (1) H(P,P) == false,
>>>>>>>> (2) P(P)
>>>>>>>> halts are why your H and P are wrong.
>>>>>>>
>>>>>>> If you are able to break the problem down to it micro component
>>>>>>> parts
>>>>>>> and carefully analyze each of these separately instead of simply
>>>>>>> slipping down the slide of intuition then you can see that I am
>>>>>>> correct.
>>>>>>>
>>>>>>> If it is true that the correct simulation input to H(P,P) cannot
>>>>>>> possibly reach its own final state then
>>>>>>>
>>>>>>> The input to H(P,P) is non-halting then
>>>>>> There is no "input to H(P,P)".
>>>>>
>>>>> The correct simulation of the input to H
>>>> Better.  I still would not call it "input" (since these are C
>>>> functions)
>>>> but you've got the hang of what am saying.  Well done.
>>>>
>>>>> cannot possibly ever reach it final state thus is a non-halting
>>>>> sequence of configurations even if everyone and everything in the
>>>>> universe disagrees.
>>>>
>>>> The truth is not determined by who does or does not agree with
>>>> something.  But to find the truth of the matter you must first stop
>>>> talking literal nonsense.  The arguments to H (what you call the
>>>> "input") are two pointers.  What does simulating two pointers mean?
>>>> What you mean, I hope, is simulating calling the first pointer with the
>>>> second as it's argument.  That simulation, according to you, will halt
>>>> (or "reach it's final state" in your flamboyant, sciencey, language).
>>>> It will halt because the direct call P(P) halts.  Everything here halts
>>>> (according to you).  That's why H is wrong.
>>>
>>> You simply are ignoring the actual execution trace that conclusively
>>> proves that the simulated input to H cannot possibly reach its final
>>> own state.
>>
>> The traces that matter are the one of P(P) halting (you made the mistake
>> of posting it once), and the one of H(P,P) return false (you posted that
>> as well).  You a free to retract any of these at any time, but until you
>> do, your H is wrong by your own supplied traces.
>>
>
> It is never the case that the simulated input to H(P,P) ever reaches its
> own final state.
>
> _P()
> [00000956](01)  55              push ebp
> [00000957](02)  8bec            mov ebp,esp
> [00000959](03)  8b4508          mov eax,[ebp+08]
> [0000095c](01)  50              push eax
> [0000095d](03)  8b4d08          mov ecx,[ebp+08]
> [00000960](01)  51              push ecx
>
> // keeps going to [00000956] until aborted

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

EQUIVALENTLY
It is never the case that the simulated input to H(P,P) ever reaches its
own final state of [00000970].

_P()
[00000956](01) 55 push ebp
[00000957](02) 8bec mov ebp,esp
[00000959](03) 8b4508 mov eax,[ebp+08]
[0000095c](01) 50 push eax
[0000095d](03) 8b4d08 mov ecx,[ebp+08]
[00000960](01) 51 push ecx

// keeps going to [00000956] until aborted
[00000961](05) e8c0feffff call 00000826 // H(P,P)
// Thus never ever reaches [00000970]

[00000966](03) 83c408 add esp,+08
[00000969](02) 85c0 test eax,eax
[0000096b](02) 7402 jz 0000096f
[0000096d](02) ebfe jmp 0000096d
[0000096f](01) 5d pop ebp
[00000970](01) c3 ret
Size in bytes:(0027) [00000970]

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

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

On 4/10/22 8:40 PM, 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⟩.

Except as pointed out, you aren't actually looking at the CORECT
simulation of the input <H^> <H^> because you just don't undestand what
it means because you are too stupied.

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

On 4/10/22 8:52 PM, 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
>
> YOU MUST HAVE VERY SEVERE BRAIN DAMAGE
>
> 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⟩.
>

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.

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.

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.

On 4/10/22 9:02 PM, 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.
>
> I will dumb it down for you a whole lot.
> If the simulated input to embeded_H is non-halting then it never halts.
>

On Sunday, April 10, 2022 at 9:02: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.
> I will dumb it down for you a whole lot.
> If the simulated input to embeded_H is non-halting then it never halts.

On 4/10/22 9:00 PM, olcott wrote:

> That simulated inputs <N><5> to Ha3
> are pure nonsense gibberish.
>
>
>

Like all your comments about the simulated input of H that differ from
the ACTUAL CORRECT SIMULATION of that input.

You just prove that you don't understand what you are talking about.

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

On 4/10/2022 8:04 PM, Richard Damon wrote:
> On 4/10/22 9:02 PM, 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.
>>
>> I will dumb it down for you a whole lot.
>> If the simulated input to embeded_H is non-halting then it never halts.
>>
>
> Only if it is the CORRECT simulation of the input.
>
> And if the correct simulation of the input halts, it is Halting.

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

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

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.

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?

On 4/10/22 9:09 PM, olcott wrote:
> On 4/10/2022 8:04 PM, Richard Damon wrote:
>> On 4/10/22 9:02 PM, 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.
>>>
>>> I will dumb it down for you a whole lot.
>>> If the simulated input to embeded_H is non-halting then it never halts.
>>>
>>
>> Only if it is the CORRECT simulation of the input.
>>
>> And if the correct simulation of the input halts, it is Halting.
>
> If the correctly simulated input to embedded_H is non-halting then it
> never halts.
>
> For the correctly simulated input to embedded_H to halts this input must
> reach its own final state.
>