On 4/10/2022 4:41 PM, Richard Damon wrote:
> On 4/10/22 5:00 PM, olcott wrote:
>> 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
>>
>>
>
> Except it ISN'T the case that the CORRECTLY simulation of the input to
> embedded_H, <H^ 0> <H^ 1>, never reaches its own final state.
>

It is simply over your head.

_P()
[00000956](01) 55 push ebp
[00000957](02) 8bec mov ebp,esp
[00000959](03) 8b4508 mov eax,[ebp+08]
[0000095c](01) 50 push eax
[0000095d](03) 8b4d08 mov ecx,[ebp+08]
[00000960](01) 51 push ecx
[00000961](05) e8c0feffff call 00000826 // CALL H(P,P)

THE CORRECT SIMULATION OF P NEVER GETS PAST HERE

[00000966](03) 83c408 add esp,+08
[00000969](02) 85c0 test eax,eax
[0000096b](02) 7402 jz 0000096f
[0000096d](02) ebfe jmp 0000096d
[0000096f](01) 5d pop ebp
[00000970](01) c3 ret // THIS IS THE FINAL STATE
Size in bytes:(0027) [00000970]

--
Copyright 2022 Pete Olcott

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