On 4/10/22 5:00 PM, olcott wrote:
> On 4/10/2022 3:15 PM, olcott wrote:
>> On 4/10/2022 3:07 PM, André G. Isaak wrote:
>>> On 2022-04-10 13:55, olcott wrote:
>>>> On 4/10/2022 2:50 PM, André G. Isaak wrote:
>>>>> On 2022-04-10 13:26, olcott wrote:
>>>>>> On 4/10/2022 2:17 PM, André G. Isaak wrote:
>>>>>>> On 2022-04-10 10:35, olcott wrote:
>>>>>>>> On 4/10/2022 11:14 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 4/10/2022 10:22 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 4/9/2022 7:14 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 4/9/2022 5:25 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You state that for the H you are championing
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>        Ĥ.q0 <Ĥ> ⊦* Ĥ.qx <Ĥ> <Ĥ> ⊦* Ĥ.qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To see why this H is not a halt decider, you must answer
>>>>>>>>>>>>>>> the two
>>>>>>>>>>>>>>> questions you are studiously avoiding.  What state does H
>>>>>>>>>>>>>>> <Ĥ> <Ĥ>
>>>>>>>>>>>>>>> transition to, and what string must be passed to H for H
>>>>>>>>>>>>>>> to tell us
>>>>>>>>>>>>>>> whether or not Ĥ applied to <Ĥ> halts or not?
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Is the input to embedded_H non-halting? YES
>>>>>>>>>>>>> The only plausible meaning for whether a string, s, is
>>>>>>>>>>>>> non-halting is
>>>>>>>>>>>>> whether UTM(s) is non-halting.  UTM(<Ĥ> <Ĥ>) halts
>>>>>>>>>>>>> (according to you).
>>>>>>>>>>>>
>>>>>>>>>>>> embedded_H contains a fully functional UTM.
>>>>>>>>>>> So what?  It can contain a fully functional chess program for
>>>>>>>>>>> all anyone
>>>>>>>>>>> cares.  What matters is what "is the input to embedded_H
>>>>>>>>>>> non-halting"
>>>>>>>>>>> means.  The only sane meaning is whether or not UTM(<Ĥ> <Ĥ>)
>>>>>>>>>>> halts, and
>>>>>>>>>>> it does (according to you).
>>>>>>>>>>>
>>>>>>>>>>>> The correctly simulated input to embedded_H would never
>>>>>>>>>>>> reach its own
>>>>>>>>>>>> final state whether or not aborted by embedded_H.
>>>>>>>>>>>
>>>>>>>>>>> UTM(<Ĥ> <Ĥ>) halts (according to you).  Are you retracing
>>>>>>>>>>> that? Or are
>>>>>>>>>>> you now saying both at once?  We know you are quite happy to
>>>>>>>>>>> claim
>>>>>>>>>>> flat-out contradictory facts at the same time.
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qy
>>>>>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ2⟩ ⊢* H.qn
>>>>>>>>>
>>>>>>>>> No once cares about this math poem.  You have invented some
>>>>>>>>> names to
>>>>>>>>> cloak your mistakes, but unless ⟨Ĥ0⟩=⟨Ĥ1⟩=⟨Ĥ2⟩=⟨Ĥ⟩ it's junk.
>>>>>>>>> What
>>>>>>>>> matters is that
>>>>>>>>>
>>>>>>>>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy ⊦* oo  if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts, and
>>>>>>>>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn        if UTM(⟨Ĥ⟩ ⟨Ĥ⟩) does
>>>>>>>>> not halt.
>>>>>>>>>
>>>>>>>>>> The simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ to embedded_H never reaches its
>>>>>>>>>> final
>>>>>>>>>> state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ under any condition what-so-ever
>>>>>>>>>
>>>>>>>>> UTM(⟨Ĥ⟩ ⟨Ĥ⟩) halts.  But what string must be passed to H for H
>>>>>>>>> to tell
>>>>>>>>
>>>>>>>> The above means this:
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>
>>>>>>> Which is an entirely meaningless specification since you don't
>>>>>>> include the necessary conditions which determine when H.qy and
>>>>>>> H.qn are reached.
>>>>>>>
>>>>>>> Why this is so difficult for you to grasp is beyond me.
>>>>>>>
>>>>>>> And I don't think you really understand what 'UTM' means. A UTM
>>>>>>> is a TM which, when given a TM descroption <M> and an input
>>>>>>> string I determines what the *result* of applying <M> to I would
>>>>>>> be. It doesn't accept or reject its input based on whether it
>>>>>>> describes a halting computation, so claiming you can just replace
>>>>>>> your embedded_H with a UTM is nonsensical.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* H.qy
>>>>>> Ĥ.q0 ⟨Ĥ0⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ2⟩ ⊢* H.qn
>>>>>
>>>>> And once again you omit the crucial conditions...
>>>>>
>>>>> You claim to want to be taken seriously. Using meaningless notation
>>>>> is not the way to do this. The above could mean 'go to H.qy' if
>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩ ends in the symbol 0 or if ⟨Ĥ0⟩ ⟨Ĥ1⟩ doesn't end in a 0
>>>>> or if it is raining or pretty much anything else you want it to
>>>>> mean. Without specifying a condition this says nothing whatsoever
>>>>> about WHICH of the two final states should be reached.
>>>>>
>>>>>> If 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.
>>>>>
>>>>> if you want to talk about "embedded_H" at least employ a
>>>>> specification which contains embedded_H. The (incomplete) one you
>>>>> give above contains H, but no "embedded_H".
>>>>
>>>> The copy of the Linz H that it embedded in Ĥ is what I mean by
>>>> embedded_H you deceitful bastard.
>>>
>>> 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
>
>

Except it ISN'T the case that the CORRECTLY simulation of the input to
embedded_H, <H^ 0> <H^ 1>, never reaches its own final state.

That correct simulation has been shown, and it reaches H.Qn and Halts.

SO, you statement is just false.

It confuses the simulation that embedded_H does with the correct
simulation, so it is based on bad logic.

FAIL.