On 4/9/2022 2:11 PM, Richard Damon wrote:
>
> On 4/9/22 2:32 PM, olcott wrote:
>> On 4/9/2022 1:28 PM, Richard Damon wrote:
>>>
>>> On 4/9/22 11:25 AM, olcott wrote:
>>>> On 4/9/2022 10:20 AM, Richard Damon wrote:
>>>>> On 4/9/22 10:41 AM, olcott wrote:
>>>>>> 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, it is the key gap in
>>>>>> your reasoning. The following proves that the simulated input ⟨Ĥ0⟩
>>>>>> ⟨Ĥ1⟩ to embedded_H cannot possibly reach its own final state under
>>>>>> any condition what-so-ever.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ0⟩
>>>>>>     Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then
>>>>>>     H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>> Then these steps would keep repeating:
>>>>>>     Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>     Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>
>>>>>> Since we can see that the simulated input: ⟨Ĥ0⟩ to embedded_H
>>>>>> never reaches its own final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩ we know
>>>>>> that it is non-halting.
>>>>>
>>>>> Right, if embedded_H never goes to Qn
>>>>
>>>> It never goes to Qn because there is no Qn, you might as well have
>>>> said if embedded_H goes to Disneyland, why is it so difficult for
>>>> you to get the details exactly right?
>>>
>>> Then it isn't the required decider!!!!
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn
>> There is no Qn it is called H.qn2.1
>> There is no Qn it is called H.qn
>>
>
> Maybe you should read your source material.
>
> In H the states are called q0, qy, and qn (the q being normal case, the
> following letter a subscript)
>
> I capitalize the q to make it clear from the subscript
>
> Read Definition 12.1
>
> There is no embedded_H, the only machines HE talks about are H, the

He talks about the copy of H that is embedded in Ĥ, numbskull, I
abbreviate this to: embedded_H.

--
Copyright 2022 Pete Olcott

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