On 8/25/2021 7:15 PM, Richard Damon wrote:
> On 8/25/21 10:15 AM, olcott wrote:
>> On 8/25/2021 7:19 AM, Richard Damon wrote:
>>> On 8/24/21 11:53 PM, olcott wrote:
>>>> On 8/24/2021 7:35 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 8/24/2021 9:09 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 8/23/2021 10:09 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 8/23/2021 6:26 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 8/23/2021 2:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> I ignore dishonest dodges away from the point at hand.
>>>>>>>>>>> OK, let's do that:
>>>>>>>>>>>        "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting
>>>>>>>>>>> computation"
>>>>>>>>>>> is wrong.  You wrote that immediately after a line showing that Ĥ
>>>>>>>>>>> applied to ⟨Ĥ⟩ halts.  Everything since then has just been
>>>>>>>>>>> dodging this
>>>>>>>>>>> error.
>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>>> The details are mess, but basically, yes.  Detail errors (that
>>>>>>>>>>> would get
>>>>>>>>>>> your paper rejected out of hand) available if you ask really
>>>>>>>>>>> nicely.
>>>>>>>>>>
>>>>>>>>>> Which details do you think are incorrect?
>>>>>>>>>
>>>>>>>>> A UTM is not a decider so the hat construction can't be applied to
>>>>>>>>> it.
>>>>>>>>> And if we make a "UTM-decider" (a TM that is a pure simulator
>>>>>>>>> except
>>>>>>>>> that is accepts those computations whose simulations terminate) we
>>>>>>>>> still
>>>>>>>>> can't apply the hat construction because it won't have a rejecting
>>>>>>>>> state.  Thus your use of "exactly like Ĥ except..." is, at best,
>>>>>>>>> disingenuous.  The differences must be greater than the "except..."
>>>>>>>>> clause suggests.
>>>>>>>>
>>>>>>>> My whole purpose was to simply show what happens when the simulating
>>>>>>>> halt decide at Ĥ.qx only simulates its input.
>>>>>>> I know, but you wanted to know what details you'd got wrong.
>>>>>>>
>>>>>>
>>>>>> If my plan was to swap the simulating halt decider at Ĥ.qx with a UTM
>>>>>> and then rename this machine to Ĵ and I did swap swap the simulating
>>>>>> halt decider at Ĥ.qx with a UTM and rename this machine to Ĵ then it
>>>>>> is a God damned lie that I got anything wrong.
>>>>>
>>>>> No.  You won't get it unless you really try.
>>>>>
>>>>>>>> We can still have the same final states, except now that are
>>>>>>>> unreachable dead code.
>>>>>>> Except you show below this unreachable state being reached:
>>>>>>
>>>>>> No I do frigging not.
>>>>>
>>>>> Yes you did.  I quoted you: Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn.
>>>>>
>>>>>> The code is still there but the infinite cycle
>>>>>> from Ĵ.qx to Ĵ.q0 prevents it from ever being reached.
>>>>>
>>>>> No.  You are totally at sea.  I did my best to explain but you'd
>>>>> have to
>>>>> want to learn to make any progress.
>>>>>
>>>>>>>      Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>>> The TM at Ĵ.qx is your "UTM-decider" with an unreachable reject
>>>>>>> state.
>>>>>>> Do you see why I don't think you know what you are saying?
>>>>>>
>>>>>> The you imagine what I mean to say instead of examining what I
>>>>>> actually say is your mistake.
>>>>>>
>>>>>> This machine
>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> is transformed into this machine:
>>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn // a machine stuck in
>>>>>> infinitely nested simulation
>>>>>
>>>>> You don't know what this notation means.  I don't think I can help you
>>>>> with this.
>>>>>
>>>>>>>>>>>> There is an infinite cycle from Ĵ.qx to Ĵ.q0.
>>>>>>>>>>> No, but that's just because you've never written a UTM so you
>>>>>>>>>>> don't know
>>>>>>>>>>> how such a TM would work.  Ĵ applied to ⟨Ĵ⟩ is non-halting but
>>>>>>>>>>> there
>>>>>>>>>>> will not be a cycle from Ĵ.q0 -> Ĵ.qx -> Ĵ.q0...[1]
>>>>>>>>>>>
>>>>>>>>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>>>>>>>
>>>>>>>>>>> Eh?  You've just said that Ĵ applied to ⟨Ĵ⟩ is non-halting.
>>>>>>> This needs to be addressed.
>>>>>>
>>>>>> That you don't believe that there is a cycle from Ĵ.qx to Ĵ.q0 is
>>>>>> flatly wrong.
>>>>>
>>>>> No, I'm right about that.
>>>>
>>>> Try and exaplain how you are right about that.
>>>
>>> The fact that the code for J (or P) has absolutely no path to go from
>>> the state qx to the state q0 OF THE SAME EXECUTION (which is what the
>>> diagram is showing).
>>>
>>> Yes, there is a 'virtual' connection from qx of one invocation to a q0
>>> of a simulated embedded invocation, but that state is NOT the outer q0.
>>>
>>> Turing Machine P or J NEVER go back to their own q0 state.
>>>
>>> You could perhaps say we have a nesting of
>>>
>>> P0.q0 -> P0.qx -> P1.q0 -> P1.qx ...
>>>
>>> But that is a NESTING, not a LOOP.
>>>
>>> They are different.
>>
>> None-the-less we have infinitely nested simulation that would never halt
>> unless the simulating halt decider aborts its simulation of its input.
>
> You HAVE to decide what your H is doing.
>

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.

Ĵ copies its input ⟨Ĵ1⟩ to ⟨Ĵ2⟩ then simulates this input Ĵ1 with its
input ⟨Ĵ2⟩
which copies its input ⟨Ĵ2⟩ to ⟨Ĵ3⟩ then simulates this input Ĵ2 with
its input ⟨Ĵ3⟩
which copies its input ⟨Ĵ3⟩ to ⟨Ĵ4⟩ then simulates this input Ĵ3 with
its input ⟨Ĵ4⟩ ...

With the Peter Linz Ĥ we have exactly the same thing while the
simulating halt decider at Ĥ.qx remains in simulation mode.

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

thus
>> we have infinitely nested simulation that would never halt
>> unless the simulating halt decider aborts its simulation of its input.

--
Copyright 2021 Pete Olcott

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