On 12/10/2021 10:14 AM, Richard Damon wrote:
> On 12/10/21 10:24 AM, olcott wrote:
>> On 12/9/2021 10:46 PM, Richard Damon wrote:
>>> On 12/9/21 11:15 PM, olcott wrote:
>>>> On 12/9/2021 9:59 PM, Richard Damon wrote:
>>>>> On 12/9/21 10:28 PM, olcott wrote:
>>>>>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 12/9/2021 5:16 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <polcott2@gmail.com> writes:
>>>>>>>>>
>>>>>>>>>> On 12/9/2021 3:32 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 12/8/2021 7:56 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 12/8/2021 4:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> If the UTM simulation...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>> If the pure simulation...
>>>>>>>>>>>>>>> No.  As you know, the correct annotations for those lines
>>>>>>>>>>>>>>> are:
>>>>>>>>>>>>>>>        Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>        if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>>>>>>>>>>        Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>        if Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>>>>>>>>>> and the usual conclusion follows immediately form these
>>>>>>>>>>>>>>> facts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Actually even Linz got that incorrectly.
>>>>>>>>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not deciding whether or not Ĥ (and thus
>>>>>>>>>>>>>> itself) halts
>>>>>>>>>>>>>> it is deciding whether or not ⟨Ĥ⟩ applied to ⟨Ĥ⟩ would halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Strings don't halt (or not halt).  You know that too (or
>>>>>>>>>>>>> you should know
>>>>>>>>>>>>> that by now).  Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn if, and
>>>>>>>>>>>>> only if, Ĥ
>>>>>>>>>>>>> applied to ⟨Ĥ⟩ does not halt.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn if, and only if, UTM(⟨Ĥ⟩,
>>>>>>>>>>>> ⟨Ĥ⟩) stops
>>>>>>>>>>>> running without having to be aborted.
>>>>>>>>>>>
>>>>>>>>>>> No.  Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn if, and only if,
>>>>>>>>>>> UTM(⟨Ĥ⟩, ⟨Ĥ⟩)
>>>>>>>>>>> does not halt.
>>>>>>>>>>
>>>>>>>>>> I forgot to put the word <never> in there.
>>>>>>>>>> It is great that you agree with my simple syntax.
>>>>>>>>>
>>>>>>>>> If you mean "if, and only if, UTM(⟨Ĥ⟩, ⟨Ĥ⟩) never stops
>>>>>>>>> running" then we
>>>>>>>>> agree.
>>>>>>>>
>>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn if, and only if, UTM(⟨Ĥ⟩, ⟨Ĥ⟩)
>>>>>>>> NEVER stops
>>>>>>>> running without having to be aborted.
>>>>>>>
>>>>>>> That's the wrong criterion.  You are not describing Linz's Ĥ
>>>>>>> anymore.
>>>>>>> To address the proof, you need Ĥ to mean what Linz means, and
>>>>>>> that's a
>>>>>>> machine that does this:
>>>>>>>
>>>>>>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>    if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>>>>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>    if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>>
>>>>>>
>>>>>> This can be misinterpreted to mean that Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> transitions to Ĥ.qn if and only if Ĥ.qx does not transition to Ĥ.qn.
>>>>>
>>>>>
>>>>> But That IS one of the derived requirements, which is why H can't
>>>>> exist!!!
>>>>>
>>>>
>>>> That ignores that actual specification:
>>>>       In computability theory, the halting problem is the problem of
>>>>       determining, from a description of an arbitrary computer program
>>>>       and an input, whether the program will finish running, or
>>>> continue
>>>>       to run forever. https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>>
>>>
>>> No, it doesn't. You just can't keep the full problem in your head.
>>>
>>> H needs to be a defined algorithm which can process ANY input that
>>> represents a computation, and tell if that computation will finish
>>> running or continue to run forever.
>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>
>> We have to start with this:
>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not reporting on whether or not Ĥ.q0 ⟨Ĥ⟩ halts.
>
> What else does H^ applied to <H^> Mean then?
>

Simulating halt decider Ĥ.qx *is deciding whether or not a pure
simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ would ever reach a final state of this
same input*

> Isn't "H^ applied to <H^>" what we mean by H^.q0 <H^>
>
> Both notations mean we start at the begining state of H^, which is
> H^.q0, and the tape given to the machine is <H^>
>
>>
>> Otherwise we simply have the incorrect question:
>>
>> Daryl McCullough  sci.logic
>> Jun 25, 2004, 6:30:39 PM
>>
>> You ask someone (we'll call him "Jack") to give a truthful
>> yes/no answer to the following question:
>>
>> Will Jack's answer to this question be no?
>>
>> Jack can't possibly give a correct yes/no answer to the question.
>>
>> https://groups.google.com/g/sci.logic/c/4kIXI1kxmsI/m/hRroMoQZx2IJ?pli=1
>>
>
> Not quite right. The difference is that H^ doesn't have 'volition', it
> is pre-programmed with an algorithm. H.q0/H^.qx <H^> <H^> WILL give some
> answer for ANY design of H, (or will fail to give an answer), that is
> fixed by the definition of H.
>
> Given that we can look at this in one of two ways:
>
> The first is to allow H to be fallible, in which case we see that H will
> always be wrong.
>
> The second is to insist that H is infallible, in which case we prove
> that H can not exist.
>
> Either method PROVES that an H that is correct can not exist, which is
> the conclusion of Turing, Linz, et all.
>
> In the same way, No Jack can exist that can truthfully answer the
> question. We either have a Jack that is incorrect, a Jack that never
> answers, or a Jack that just doesn't exist.
>
> The quesiton "Will H^ applied to <H^> Halt" DOES have a definite answer
> for every possible existing H^ (and thus for any possible existing H).
>
> THAT question is the Halting Problem Question, and it has a definite
> answer as long as H exists.
>
> The problem comes when you assume that an H exists that is always right.
>
> THEN you get the incorrect question, which just proves that an always
> correct H does not exist.
>
> The arrival at the contradiction is the POINT of the proof, it shows
> that the assumption that an H exists that meets the requirements can not
> be true.
>
> Maybe you need to study up on how a proof by contradiction works. I
> don't think you understand it, or maybe you have just broken you mind by
> just assuming without proof that such an H exists and are unwilling to
> let the logic show that you are wrong.
>
>>
>>>
>>> The problem that Linz (and Turing) proposes is let us assume that you
>>> CAN make such a computation and call it H.
>>>
>>> Let us now make a computation X to test this H, and this computation
>>> will take as an input the representation of a machine 'P' (using the
>>> same representation system as H uses), and then duplicate this
>>> description so it can ask our presumed to exist H if this P applied
>>> to the representation of this P will Halt.
>>>
>>> If H says that P applied to <P> will halt, then X will do the
>>> opposite and loop forever.
>>>
>>> If H says that P applied to <P> will never halt, then X will do the
>>> opposite and halt immediately.
>>>
>>> Building such an X, given that we have H defined, is a trivial task
>>> and is well defined. Note, X is NOT 'self referential' as it just
>>> takes an input representation duplicates it and calls H and then acts
>>> on the answer.
>>>
>>> Now, given that X is defined (with the assumption that H exists and
>>> is defined) we can construct a representation of it, and can call it <X>
>>>
>>> Again, this is a FULLY legal move, if H meets the requirement, we can
>>> encode ANY machine to be able to give it to H.
>>>
>>> We have no 'pathological' case, just purely legal operations.
>>>
>>> Now we can apply the machine X to this <X> and see what happens.
>>>
>>> X will take its input <X> and duplicate it and then ask its copy of H
>>> what this computation will do.
>>>
>>> THe input to H is <X> <X> which means what happens when X is applied
>>> to <X>, which just happens to be the computation we are running at
>>> the moment.
>>>
>>> H needs to do its processing and can only end up doing one of a few
>>> operations.
>>>
>>> H can reply that X applied to <X> is Halting, but if it does this,
>>> then X applied to <X> by the construction rule above will loop
>>> forever and be non-halting, thus H failed to give the right answer.
>>>
>>> H can reply that x applied to <X> is Non-Halting, but if t does this,
>>> then X applied to <X> by the construction above will Halt, and H
>>> again has failed to give the right answer.
>>>
>>> H can also refuse to give an answer, but then H still fails to meet
>>> its requirement.
>>>
>>> Thus, by construction this particular computation from the decider,
>>> which is a FULLY LEGAL operation, we have shown that ANY machine we
>>> think might be an actual Halt Decider has at least one input it
>>> decided incorrectly on. Since there does not exist any machine that
>>> meets the requirement, we can also state that as NO machine exists
>>> that meets that requirement.
>>>
>>> The 'self reference' that causes the problem does not exist in ANY of
>>> the actual code for either of the machines we are talking about. You
>>> actually only get a real self-refernce structure if you break the
>>> code-data separation of Turing Machines <X> doesn't have a
>>> 'refernece' to H, it includes in the representation a COPY of H,
>>> which actually means your address test that you you have used in the
>>> past doesn't actually work, as <X> doesn't actually have a
>>> 'reference' to H, just its own unique copy of it.
>>>
>>> Only your breaking of this isolation of code vs data, and then having
>>> X refer back to a single copy of H, and embed the representations as
>>> part of the code space, allows you to alter the form to have a 'real'
>>> self-reference form.
>>>
>>>>
>>>>
>>>>> H needs to go to qy if its input represents a Halting Computation.
>>>>>
>>>>> Thus if H^ <H^> goes to H^.qn (via H^.qx) and thus is halting,
>>>>> then H.q0 <H^> <H^> would have need to go to H.qy (but then H^
>>>>> wouldn't have gone to H^.qn)
>>>>>
>>>>> Similarly, if H^ <H^> goes to H^.qy and then to the infinite loop,
>>>>> and thus being non-halting, then H.q0 <H^> <H^> would need to go to
>>>>> H.qn (but then H^ wouldn't have done to H^.qy).
>>>>>
>>>>> So YES, you have a contradiction, which says the implied assumption
>>>>> that H exists is wrong.
>>>>>
>>>>> The key point is that generally starting with an assumption that
>>>>> something exists normally only happens in a proof of NON-existance,
>>>>> where we show this assumption breaks things. You can not actually
>>>>> prove that something exists starting with the assumption that it
>>>>> exists, that doesn't work.
>>>>>
>>>>>
>>>>>>
>>>>>>> I think we've gone round the usual loop again, so unless you have
>>>>>>> something new, I can't see the point in continuing.
>>>>>>>
>>>>>>
>>>>>> There is a new point of greater clarity above.
>>>>>>
>>>>>
>>>>
>>>>
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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