On 8/21/2021 10:52 AM, Richard Damon wrote:
> On 8/21/21 9:26 AM, olcott wrote:
>> On 8/21/2021 7:14 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 8/20/2021 8:03 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 8/20/2021 5:22 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 8/20/2021 3:40 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 8/20/2021 10:10 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>>>> I am not going to bother to answer all of this so that you
>>>>>>>>>>>> can stay
>>>>>>>>>>>> focused on one key point:
>>>>>>>>>
>>>>>>>>>>> You are not going to stay focused on the most serious error
>>>>>>>>>>> you have yet
>>>>>>>>>>> posted?
>>>>>>>>>>
>>>>>>>>>> You have to go though the following reasoning and point out the
>>>>>>>>>> specific error.
>>>>>>>>>
>>>>>>>>> The specific error is that the string ⟨Ĥ⟩ ⟨Ĥ⟩ encodes the
>>>>>>>>> computation of
>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ which, everyone agrees, is a halting
>>>>>>>>> computation.  Your
>>>>>>>>> statement of Aug 12th that
>>>>>>>>>
>>>>>>>>>       "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting computation."
>>>>>>>>>
>>>>>>>>> is simply wrong in the simplest factual way.  I don't have to look
>>>>>>>>> anywhere else to point out the specific error.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>> The string ⟨Ĥ1⟩ ⟨Ĥ2⟩ equals the string ⟨Ĥ⟩ ⟨Ĥ⟩.  So long as you
>>>>>>> refuse
>>>>>>> to correct the basic error and agree that ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
>>>>>>> computation everything you say from here on is nonsense.
>>>>>>>
>>>>>>>> The executed Ĥ in the above expression only halts because of its
>>>>>>>> computational dependence on the halt status decision of the
>>>>>>>> simulating
>>>>>>>> halt decider on its input Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩.
>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩ encodes a halting computation, just as ⟨Ĥ⟩ ⟨Ĥ⟩ does.  Do
>>>>>>> you
>>>>>>> still refuse to acknowledge that basic error?
>>>>>>>
>>>>>>>> The simulated input Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ has no such computational
>>>>>>>> dependence on the executed Ĥ.
>>>>>>> The string ⟨Ĥ1⟩ ⟨Ĥ2⟩ encodes a halting computation.  The 1 and the 2
>>>>>>> might help you explain when and how the encoded computation halts,
>>>>>>> but
>>>>>>> they don't alter the fact that identical strings encode identical
>>>>>>> computations.  In this case, halting ones.
>>>>>>
>>>>>> THIS SEEMS OVER YOUR HEAD:
>>>>>> The fact that Ĥ only halts because Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ decides that its
>>>>>> input never halts ( Ĥ is computationally dependent on Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ )
>>>>>
>>>>> You need to correct the basic error before you can be taken seriously.
>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩ is the same string as ⟨Ĥ⟩ ⟨Ĥ⟩ and encodes a halting
>>>>> computation.
>>>>
>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
>>>> if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ halts, and
>>>>
>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>> if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ does not halt
>>>
>>> You don't say which is the case for you Ĥ.  Have you changed you mind?
>>> If not, there's not much point in giving both lines as only one will
>>> apply to your actual Ĥ.
>>>
>>> Of course the math poem is silly.  The simulation of an encoded TM
>>> behaves exactly the same (in terms of halting) as the TM itself.  And
>>> ⟨Ĥ1⟩ = ⟨Ĥ2⟩ = ⟨Ĥ⟩ so you might as well have stuck with what Linz wrote.
>>>
>>>>> Sadly, I suspect that this:
>>>>> a.  ⟨Ĥ⟩ ⟨Ĥ⟩ (and all the silly ⟨Ĥ1⟩ ⟨Ĥ2⟩ variations) are identical
>>>>>       strings that encode exactly the same computation.
>>>>
>>>> (1) Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>> You know that when the machine at Ĵ.qx is a UTM that Ĵ applied to ⟨Ĵ⟩
>>>> never halts.
>>>
>>> You know that ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting computation but you can't admit
>>> it.  What the string ⟨Ĵ⟩ ⟨Ĵ⟩ encodes is not, I think, disputed.
>>>
>>>> (2) From this you should be able to know that the simulating halt
>>>> decider at Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ would never halt unless it stops simulating
>>>> its input.
>>>
>>> So what?  The "unless" applies: your H (embedded in Ĥ at qx) does halt
>>> (or stop as you disingenuously put it).  That's why the string ⟨Ĥ⟩ ⟨Ĥ⟩
>>> encodes a halting computation.
>>>
>>
>> The executed Ĥ only halts because the simulated ⟨Ĥ⟩ on ⟨Ĥ⟩ never halts.
>
> WRONG.
>
> H^ <H^> Halts, so it is Halting.
>
> The PARTIALLY simulated <H^> <H^> was not simulated to its Halting
> state, but if this input is given to to a real pure simulator, it will Halt.
>
> Since, as you have said, the aborting of a simulation can not affect the
> halting status of that input,

Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn

I did not say that. I said the the decision to abort or not to abort is
based on whether or not the input to the simulating halt decider would
ever stop running while the simulating halt decider remains in
simulation mode.

As we can see by the following analysis the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩
never halts while the simulating halt decider at Ĥ.qx remains in
simulation mode.

When we define Ĵ to be exactly like Ĥ except that it has a UTM at Ĵ.qx
instead of a simulating halt decider then we can see that Ĵ applied to
⟨Ĵ⟩ never halts. There is an infinite cycle from Ĵ.qx to Ĵ.q0.

Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn

Ĵ0.q0 copies its input ⟨Ĵ1⟩ to ⟨Ĵ2⟩ then Ĵ0.qx simulates Ĵ1 with the
⟨Ĵ2⟩ copy then
Ĵ1.q0 copies its input ⟨Ĵ2⟩ to ⟨Ĵ3⟩ then Ĵ1.qx simulates Ĵ2 with the
⟨Ĵ3⟩ copy then
Ĵ2.q0 copies its input ⟨Ĵ3⟩ to ⟨Ĵ4⟩ then Ĵ2.qx simulates Ĵ3 with the
⟨Ĵ4⟩ copy then ...

From this we can conclude that while the simulating halt decider at
Ĥ.qx remains in pure simulation mode (thus not aborting the simulation
of its input) ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ never halts.

> the fact that the actual pure simulation
> of <H^> <H^> does go to a halt says that input is a Halting Input, and
> the status that H saw was't 'never halts' but 'hasn't halted yet'
>
>> If we simply say that ⟨Ĥ⟩ on ⟨Ĥ⟩ halts that is exactly the same thing
>> as saying that because "This sentences is not true" that makes it true.
>
> WRONG. <H^> on <H^> is exactly Halting as that is what a real simulator
> says, and, as even you have stated, an aborted simulation doesn't affect
> the halting status of that input, so the fact that it didn't see the
> halting state does NOT imply that the input is non-halting.
>
>>
>> If we simply say that ⟨Ĥ⟩ on ⟨Ĥ⟩ halts that requires Ĥ.qx to transition
>> to Ĥ.qy ∞ which makes it never halt.
>
>
> UNSOUDN
>
>>
>> So simply saying that ⟨Ĥ⟩ on ⟨Ĥ⟩ halts is incorrect.
>> I understand that these things can be intellectually overwhelming.
>>
>
> UNSOUND.
>
> Yes, YOU have been intellectually overwhelmed by this logic.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein