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.

Either

1) H NEVER aborts the simulation, at which point Hn(<Hn^>, <Hn^>) never
returns an answer as is thus a failed decider

2) H Does abort the simulation so it can answer and then it turns out
that Ha^(<Ha^>) is a Halting computation.

The only way to have it both ways is for H to not be a computation,
(Which actually seems to be the case) in which case it also fails to be
a valid Halt Decider because it isn't the comptational equivalent of a
Turing Machine to be the Turing Machine H.

I think your problem is you just don't understand that last statement.

>
> This conclusively proves that the simulating halt decider at Ĥ.qx ⟨Ĥ1⟩
> ⟨Ĥ2⟩ must abort the simulation of this input which conclusively proves
> that this input never halts.
>

Nope. Just shows you don't know what you are talking about.

>>
>>>
>>>
>>>> But you are piling errors on errors now so
>>>> responding is getting harder.  What you are not responding to is the
>>>> contraction.  Even though there is no cycle from Ĵ.qx to Ĵ.q0, Ĵ
>>>> applied
>>>> to ⟨Ĵ⟩ is indeed non-halting you keep showing that it halts.  Even if
>>>> there were a cycle from Ĵ.qx to Ĵ.q0 you would still be contradicting
>>>> yourself.
>>>
>>
>
>