On 4/10/22 5:51 PM, olcott wrote:
> 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]
>
>
>

So you adminit that H(P,P) doesn't answer? Then it FAILS to be a Decider.

Note, if one copy of H(P,P) doesn't answer then NO copy of H(P,P) can
answer or H fails to be a Computation and thus H is not the equivalent
of a Turing Machine.

Thus you don't actually have a Turing Machine that is a counter to Linz.

I guess you just admitted that you wasted 17 years of your pitiful life.

FAIL.

If you wish to claim that two copies of the exact same Turing Machine
can have different behavior with two identical copies of an input,
please provide an example.

Otherwise you ar just proving that you still don't understand the basics
of Turing Machines (which is WHY you have wasted 17 years of your life).