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

--
Copyright 2022 Pete Olcott

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