On 12/9/21 7:54 PM, olcott wrote:
> On 12/9/2021 6:45 PM, André G. Isaak wrote:
>> On 2021-12-09 17:35, olcott wrote:
>>> On 12/9/2021 6:20 PM, André G. Isaak wrote:
>>>> On 2021-12-09 17:13, olcott wrote:
>>>>> On 12/9/2021 6:03 PM, André G. Isaak wrote:
>>>>>> On 2021-12-09 14:58, olcott wrote:
>>>>>>> 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.
>>>>>>
>>>>>> The problem here is that when Ben uses the term 'UTM' everyone
>>>>>> knows what he means, but when you use this term nobody knows what
>>>>>> you mean since you repeatedly used the term to refer to all sorts
>>>>>> of things which aren't UTMs.
>>>>>>
>>>>>
>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn if, and only if, UTM(⟨Ĥ⟩, ⟨Ĥ⟩)
>>>>> NEVER stops
>>>>> running without having to be aborted.
>>>>
>>>> A UTM *can't* be aborted. If its input represents a finite
>>>> computation it will halt; if its input does not represent a finite
>>>> computation it won't halt. Words actually mean things.
>>>>
>>>
>>> If Ĥ.qx axiomatically determines that UTM(⟨Ĥ⟩, ⟨Ĥ⟩) would never stop
>>> running then Ĥ.qx correctly reports that its input never halts. There
>>> is no need for any actual UTM anywhere.
>>
>> I have no idea what 'axiomatically determines' might mean.
>>
>
> Can you tell if either one of these would ever stop running without
> running them and waiting forever?
>
> If you can then you know what axiomatically determines means.

Just bad language.

Axioms tend to be defined as the fundamental unproven assumptions that
you build your logic on.

These 'Non-Halting' patterns don't need to be taken 'axiomatically', but
can be PROVEN to be non-halting patterns.

This just shows how little you know about logic.

>
> void Infinite_Loop(int N)
> {
>   HERE: goto HERE;
> }
>
> void Infinite_Recursion(int N)
> {
>   Infinite_Recursion(N);
> }
>
> _Infinite_Loop()
> [00000cc5](01)  55              push ebp
> [00000cc6](02)  8bec            mov ebp,esp
> [00000cc8](02)  ebfe            jmp 00000cc8
> [00000cca](01)  5d              pop ebp
> [00000ccb](01)  c3              ret
> Size in bytes:(0007) [00000ccb]
>
> _Infinite_Recursion()
> [00000cd5](01)  55              push ebp
> [00000cd6](02)  8bec            mov ebp,esp
> [00000cd8](03)  8b4508          mov eax,[ebp+08]
> [00000cdb](01)  50              push eax
> [00000cdc](05)  e8f4ffffff      call 00000cd5
> [00000ce1](03)  83c404          add esp,+04
> [00000ce4](01)  5d              pop ebp
> [00000ce5](01)  c3              ret
> Size in bytes:(0017) [00000ce5
>
>
>> And if there is no need for actual UTMs then why on earth bring them up?
>>
>> There's absolutely nothing wrong with the conditions which Linz uses
>> to describe when H_Hat reaches qn, and those were the exact conditions
>> which he intended.
>
> Application of the [Olcott 2021 generic halt deciding principle]
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn if, and only if, UTM(⟨Ĥ⟩, ⟨Ĥ⟩) NEVER
> stops running without having to be aborted.

FALSE STATEMENT

H^,qx <X> <X> will transition to H^.qn if, and only if, H <X> <X>
transitions to H.qn. PERIOD.

Now, H if it IS a true Halt Decider, will only go to H.qn if
UTM(<X>,<X>) will never halt, but we can't use that as a 'definition' of
H, as that is NOT an algorithm, and we don't have a proof that such an H
does exist.

In fact, the key of the Linz Proof is to show that it is impossible for
an H to exist that gives the right answer to the H^(<H^>) computation,
BECAUSE H^ has an ALLOWED 'feedback' path from H(p,p) to the behavior of
H^(p), that shows that no H can exists that meets the requirements.

> Eliminates the feedback loop between the halt decider and its input that
> otherwise makes the conventional pathological inputs undecidable.

And without the 'feedback loop' the computation you are deciding on
isn't the computation that the decider is supposed to answer, so it
gives the WRONG answer for the problem it NEEDS to answer to be a Halt
Decider.

You don't get to change the definitions.

>
>
>> If you change them to something else you are no longer talking about
>> Linz's H_Hat.
>>
>> André
>>
>>
>>
>
>

On 12/9/2021 8:17 PM, Richard Damon wrote:
> On 12/9/21 7:35 PM, olcott wrote:
>>>
>>
>> If Ĥ.qx axiomatically determines that UTM(⟨Ĥ⟩, ⟨Ĥ⟩) would never stop
>> running then Ĥ.qx correctly reports that its input never halts. There
>> is no need for any actual UTM anywhere.
>
> So, WHy does your H say H^ <H^> never halts when it has been shown, and
> you admit, that it does?
>
> You AGREE that P(P) when run Halts.
>
> You AGREE that your H(P,P) return 0 which says it thinks its input
> doesn't halt.
>
> You just refuse to admit that saying it doesn't halt when it does is an
> error.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn because it has proof that
Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM(⟨Ĥ⟩,⟨Ĥ⟩) never stops running.

>
> Note, As I have said before, H^.qx behavior is only determined by UTM if
> H is AcTUALLY a correct Halting Decider. ANY contradiction that you run
> into are explained by the fact that such an H actually can not exist.
>
> You CAN'T first assume that an H exist, and then use that to try to
> prove that an H exists. That is unsound logic.

--
Copyright 2021 Pete Olcott

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

On 12/9/21 7:08 PM, olcott wrote:
> 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.
>
> Which is another way of saying that the input to simulating halt decider
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ never stops running unless Ĥ.qx aborts its simulation of
> this input.
>
>> But I am sure you don't mean that.  If you did, you'd just use
>> Linz's simpler annotations.  You describe an Ĥ that does not behave like
>> Linz's Ĥ does.
>
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *IS NOT* deciding whether or not itself stops running.
>

No, it is deciding if H^ <H^> stops running, which will depend on the
answer that H <H^> <H^> gives (and will make it wrong).

Note, H^.qx is NOT really a 'decider' but a copy of a decider that has
been augmented to make H^.qx only an acceptor, not a decider.

H <x> y is supposed to be a decider, going to H.qy if x applied to y
will halt and to H.qn if x applied to y will never halt.

Supposed is the key word. For it to be successful for this case, then
H <H^> <H^> needs to go to H.qn if H^ <H^> does not halt, and to H.qy if
H^ <H^> does halt, but H^ contains a copy of H (as is allowed) and it H
goes to H.qn then H^ also goes to H^.qn and halts. and if H goes to
H.qy, then H^ also goes to H^.qy and then into and infinite loop.

Thus if H <H^> <H^> goes to H.qn then H^ <H^> also goes to H^.qn and
halts, which breaks H's requirements, and if H <H^> <H^> goes to H.qy
then H^ <H^> <H^> also goes to H^.qy and then into an infinite loop,
which also breaks H's requirements. And failing to reach either of the
se states also breaks H's requirements. Thus, there IS no possible H
that meets its requirements, PERIOD.

On 12/9/21 9:33 PM, olcott wrote:
> On 12/9/2021 8:17 PM, Richard Damon wrote:
>> On 12/9/21 7:35 PM, olcott wrote:
>>>>
>>>
>>> If Ĥ.qx axiomatically determines that UTM(⟨Ĥ⟩, ⟨Ĥ⟩) would never stop
>>> running then Ĥ.qx correctly reports that its input never halts. There
>>> is no need for any actual UTM anywhere.
>>
>> So, WHy does your H say H^ <H^> never halts when it has been shown,
>> and you admit, that it does?
>>
>> You AGREE that P(P) when run Halts.
>>
>> You AGREE that your H(P,P) return 0 which says it thinks its input
>> doesn't halt.
>>
>> You just refuse to admit that saying it doesn't halt when it does is
>> an error.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn > Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn because it has proof that
> Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM(⟨Ĥ⟩,⟨Ĥ⟩) never stops running.

Except that since UTM(<H^>,<H^>) BY DEFINITION behaves exactly the same
as H^ <H^> which is the same thing as H^.q0 <H^> which by your first
line reaches the state H^.qn which is a HALTING state, says H^ CAN NOT
HAVE A VALID PROOF.

You can NOT have a valid proof of something that is incorrect.

Remember, if ONE instance of H^.qx <H^> <H^> goes to H^.qn, then ALL
instances of H^.qx <H^> <H^> go to H^.qn, and thus we can see that ALL
H^.q0 <H^> -> H^.qn and Halt, thus UTM(<H^>, <H^>) will HALT

This gives us a contradiction, as you said before it will not halt.

This contradiction is the proof that your assumed existence of an H that
meets the requirements is wrong.

FAIL.

>
>>
>> Note, As I have said before, H^.qx behavior is only determined by UTM
>> if H is AcTUALLY a correct Halting Decider. ANY contradiction that you
>> run into are explained by the fact that such an H actually can not exist.
>>
>> You CAN'T first assume that an H exist, and then use that to try to
>> prove that an H exists. That is unsound logic.
>
>

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.

I think we've gone round the usual loop again, so unless you have
something new, I can't see the point in continuing.

--
Ben.

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.

> 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

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!!!

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

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

> 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

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.

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

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.

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

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

olcott <NoOne@NoWhere.com> writes:

> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:

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

Whatever that means, if it's a misinterpretation it should, of course,
be ignored. Just keep the correct annotation for those two lines and
you'll be OK. (Of course I know you will replace them with your own,
because you don't want to talk about an Ĥ that behaves as Linz
specifies.)

--
Ben.

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?

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

On 12/10/2021 10:12 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>
>>>> Ĥ.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.
>
> Whatever that means,

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not itself halts*

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not its own first state Ĥ.q0
reaches a final state.*

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

> if it's a misinterpretation it should, of course,
> be ignored. Just keep the correct annotation for those two lines and
> you'll be OK. (Of course I know you will replace them with your own,
> because you don't want to talk about an Ĥ that behaves as Linz
> specifies.)
>

--
Copyright 2021 Pete Olcott

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

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

On 12/10/21 11:31 AM, olcott wrote:
> On 12/10/2021 10:14 AM, Richard Damon wrote:
>> On 12/10/21 10:24 AM, olcott wrote:
>>>
>>> Ĥ.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*
>

And the DEFINITION of PURE SIMULATION is that the a PURE SIMULATOR (aka
a UTM) behaves exactly like running the computation (machine/input) it
is simulating.

Therefore, no difference.

If you think there is, you have a wrong definition somewhere.

On 12/10/21 11:29 AM, olcott wrote:
> On 12/10/2021 10:12 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>> Ĥ.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.
>>
>> Whatever that means,
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not itself halts*
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not its own first state Ĥ.q0
> reaches a final state.*
>
> 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.*

Except that the input *IS* the description of 'itself' and 'its own
first state'

This that input DOES 'refer' to itself, or at least a copy of itself
that MUST behave just like itself.

FAIL.

If this isn't true, then you have failed at setting up the problem
correctly.

>
>
>> if it's a misinterpretation it should, of course,
>> be ignored.  Just keep the correct annotation for those two lines and
>> you'll be OK.  (Of course I know you will replace them with your own,
>> because you don't want to talk about an Ĥ that behaves as Linz
>> specifies.)
>>
>
>

olcott <NoOne@NoWhere.com> writes:

> On 12/10/2021 10:12 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>> Ĥ.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.
>> Whatever that means,
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not itself halts*

The sub-TM at Ĥ.qx is not a decider, so I agree with the words you have
said (but not with what you meant to say).

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.

> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not its own first state Ĥ.q0
> reaches a final state.*

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not deciding anything. The sub-TM at Ĥ.qx, when given
⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transitions to Ĥ.qn if, and only if, Ĥ applied to
⟨Ĥ⟩ does not halt.

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

The special case of things you call simulating halt deciders are
included in everything Linz has to say about halt deciders in general.
The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating halt
decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transition to
Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.

--
Ben.

On 12/10/2021 1:55 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 12/10/2021 10:12 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>>> Ĥ.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.
>>> Whatever that means,
>>
>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not itself halts*
>
> The sub-TM at Ĥ.qx is not a decider, so I agree with the words you have
> said (but not with what you meant to say).
>

Ĥ.qx <is> an exact copy of H so it <is> a halt decider that has its yes
state corrupted, thus causing it to no longer be a decider.

> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>

No this is false.

>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not its own first state Ĥ.q0
>> reaches a final state.*
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not deciding anything. The sub-TM at Ĥ.qx, when given
> ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transitions to Ĥ.qn if, and only if, Ĥ applied to
> ⟨Ĥ⟩ does not halt.
>

In other words you mean that Ĥ.qx transitions to Ĥ.qn if any only if
Ĥ.qx never reaches any final state.

>> 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.*
>
> The special case of things you call simulating halt deciders are
> included in everything Linz has to say about halt deciders in general.
> The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating halt
> decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transition to
> Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>

No this is incorrect.

The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating halt
decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transition to
Ĥ.qn

when it detects that its pure simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ never
stops running unless Ĥ.qx aborts its simulation of this input.

--
Copyright 2021 Pete Olcott

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

On 2021-12-10 13:47, olcott wrote:
> On 12/10/2021 1:55 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/10/2021 10:12 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>> Ĥ.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.
>>>> Whatever that means,
>>>
>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not itself halts*
>>
>> The sub-TM at Ĥ.qx is not a decider, so I agree with the words you have
>> said (but not with what you meant to say).
>>
>
> Ĥ.qx <is> an exact copy of H so it <is> a halt decider that has its yes
> state corrupted, thus causing it to no longer be a decider.

Ĥ.qx is a single state. It isn't any kind of decider

The set of state transitions which *starts* at Ĥ.qx is based on a halt
decider but with its accepting state replaced by a loop, meaning that it
is no longer a decider at all. So I don't see why you are arguing about
this.

>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>>
>
> No this is false.

The set of state transitions beginning with Ĥ.qx is, as you point out,
based on a halt decider, and the rejecting state of that decider remains
unchanged.

So yes, the condition that

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.

is exactly correct since that is the condition under which a halt
decider is defined to reject its input.

You may not like this definition. That does not make it 'false'. It is
the correct definition, and the one used by absolutely everyone in the
field of computing. If you replace it with something else, you are the
one using the wrong definition.

>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not its own first state Ĥ.q0
>>> reaches a final state.*
>>
>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not deciding anything.  The sub-TM at Ĥ.qx, when given
>> ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transitions to Ĥ.qn if, and only if, Ĥ applied to
>> ⟨Ĥ⟩ does not halt.
>>
>
> In other words you mean that Ĥ.qx transitions to Ĥ.qn if any only if
> Ĥ.qx never reaches any final state.
>
>>> 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.*
>>
>> The special case of things you call simulating halt deciders are
>> included in everything Linz has to say about halt deciders in general.
>> The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating halt
>> decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transition to
>> Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>>
>
> No this is incorrect.
>
> The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating halt
> decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transition to
> Ĥ.qn
>
> when it detects that its pure simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ never
> stops running unless Ĥ.qx aborts its simulation of this input.

And if that condition is not met under *precisely* the same conditions
as the actual, accepted condition that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only
if, Ĥ applied to ⟨Ĥ⟩ does not halt, then you are not justified in
altering the definition.

And while it is apparent that your condition does *not* match the actual
criterion, only you know what is really intended by your revised
criterion since you very clearly do not mean pure simulation when you
right 'pure simulation.'

Ĥ applied to ⟨Ĥ⟩ halts. You have acknowledged that. That means that UTM
⟨Ĥ⟩ ⟨Ĥ⟩ will also halt and that would be the only meaning of 'pure
simulation' that makes any sense. So whatever meaning you intend for
your revised criterion will remain forever mysterious. All we know for
sure is that it doesn't match the actual halting criterion and therefore
your Ĥ has no bearing on the Linz proof.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 12/10/2021 4:02 PM, André G. Isaak wrote:
> On 2021-12-10 13:47, olcott wrote:
>> On 12/10/2021 1:55 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 12/10/2021 10:12 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>>>> Ĥ.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.
>>>>> Whatever that means,
>>>>
>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not itself halts*
>>>
>>> The sub-TM at Ĥ.qx is not a decider, so I agree with the words you have
>>> said (but not with what you meant to say).
>>>
>>
>> Ĥ.qx <is> an exact copy of H so it <is> a halt decider that has its
>> yes state corrupted, thus causing it to no longer be a decider.
>
> Ĥ.qx is a single state. It isn't any kind of decider
>
> The set of state transitions which *starts* at Ĥ.qx is based on a halt
> decider but with its accepting state replaced by a loop, meaning that it
> is no longer a decider at all. So I don't see why you are arguing about
> this.
>

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn portion is that part that is identical to H.

>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>
>>
>> No this is false.
>
> The set of state transitions beginning with Ĥ.qx is, as you point out,
> based on a halt decider, and the rejecting state of that decider remains
> unchanged.
>
> So yes, the condition that
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>
> is exactly correct since that is the condition under which a halt
> decider is defined to reject its input.
>

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if and only if Ĥ.qx does not transition to Ĥ.qn is
incorrect.

A simulating halt decider does not report on its own behavior. A
simulating halt decider reports on the behavior of the simulation its
its own machine description.

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

Common sense would tall you that these two must be identical and common
sense is proven to be incorrect.

> You may not like this definition. That does not make it 'false'. It is
> the correct definition, and the one used by absolutely everyone in the
> field of computing. If you replace it with something else, you are the
> one using the wrong definition.
>
>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not its own first state Ĥ.q0
>>>> reaches a final state.*
>>>
>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not deciding anything.  The sub-TM at Ĥ.qx, when given
>>> ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transitions to Ĥ.qn if, and only if, Ĥ applied to
>>> ⟨Ĥ⟩ does not halt.
>>>
>>
>> In other words you mean that Ĥ.qx transitions to Ĥ.qn if any only if
>> Ĥ.qx never reaches any final state.
>>
>>>> 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.*
>>>
>>> The special case of things you call simulating halt deciders are
>>> included in everything Linz has to say about halt deciders in general.
>>> The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating halt
>>> decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transition to
>>> Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>
>>
>> No this is incorrect.
>>
>> The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating
>> halt decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape,
>> transition to Ĥ.qn
>>
>> when it detects that its pure simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ never
>> stops running unless Ĥ.qx aborts its simulation of this input.
>
> And if that condition is not met under *precisely* the same conditions
> as the actual, accepted condition that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only
> if, Ĥ applied to ⟨Ĥ⟩ does not halt, then you are not justified in
> altering the definition.

A simulating halt decider does not report on its own behavior. A
simulating halt decider reports on the behavior of the simulation its
its own machine description.

This is one level of indirection away (pointer to a pointer) from
referring to its actual self.

> And while it is apparent that your condition does *not* match the actual
> criterion, only you know what is really intended by your revised
> criterion since you very clearly do not mean pure simulation when you
> right 'pure simulation.'
>

0 to ∞ steps of the simulation of P(P) by H are identical to 0 to ∞
steps of the direct execution of P(P) by H.

0 to ∞ simulated steps of P(P) by H never stop running.

> Ĥ applied to ⟨Ĥ⟩ halts. You have acknowledged that. That means that UTM

0 to ∞ steps of the simulation ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by Ĥ.qx never stop
running.

> ⟨Ĥ⟩ ⟨Ĥ⟩ will also halt and that would be the only meaning of 'pure
> simulation' that makes any sense. So whatever meaning you intend for
> your revised criterion will remain forever mysterious. All we know for
> sure is that it doesn't match the actual halting criterion and therefore
> your Ĥ has no bearing on the Linz proof.
>
> André
>

--
Copyright 2021 Pete Olcott

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

On 2021-12-10 15:48, olcott wrote:
> On 12/10/2021 4:02 PM, André G. Isaak wrote:
>> On 2021-12-10 13:47, olcott wrote:
>>> On 12/10/2021 1:55 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 12/10/2021 10:12 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>>>> Ĥ.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.
>>>>>> Whatever that means,
>>>>>
>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not itself halts*
>>>>
>>>> The sub-TM at Ĥ.qx is not a decider, so I agree with the words you have
>>>> said (but not with what you meant to say).
>>>>
>>>
>>> Ĥ.qx <is> an exact copy of H so it <is> a halt decider that has its
>>> yes state corrupted, thus causing it to no longer be a decider.
>>
>> Ĥ.qx is a single state. It isn't any kind of decider
>>
>> The set of state transitions which *starts* at Ĥ.qx is based on a halt
>> decider but with its accepting state replaced by a loop, meaning that
>> it is no longer a decider at all. So I don't see why you are arguing
>> about this.
>>
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn portion is that part that is identical to H.
>
>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not
>>>> halt.
>>>>
>>>
>>> No this is false.
>>
>> The set of state transitions beginning with Ĥ.qx is, as you point out,
>> based on a halt decider, and the rejecting state of that decider
>> remains unchanged.
>>
>> So yes, the condition that
>>
>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>>
>> is exactly correct since that is the condition under which a halt
>> decider is defined to reject its input.
>>
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if and only if Ĥ.qx does not transition to Ĥ.qn is
> incorrect.
>
> A simulating halt decider does not report on its own behavior. A
> simulating halt decider reports on the behavior of the simulation its
> its own machine description.
>
>      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
>
> Common sense would tall you that these two must be identical and common
> sense is proven to be incorrect.
>
>> You may not like this definition. That does not make it 'false'. It is
>> the correct definition, and the one used by absolutely everyone in the
>> field of computing. If you replace it with something else, you are the
>> one using the wrong definition.
>>
>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not its own first state Ĥ.q0
>>>>> reaches a final state.*
>>>>
>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not deciding anything.  The sub-TM at Ĥ.qx, when given
>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transitions to Ĥ.qn if, and only if, Ĥ applied to
>>>> ⟨Ĥ⟩ does not halt.
>>>>
>>>
>>> In other words you mean that Ĥ.qx transitions to Ĥ.qn if any only if
>>> Ĥ.qx never reaches any final state.
>>>
>>>>> 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.*
>>>>
>>>> The special case of things you call simulating halt deciders are
>>>> included in everything Linz has to say about halt deciders in general.
>>>> The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating halt
>>>> decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape,
>>>> transition to
>>>> Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>
>>>
>>> No this is incorrect.
>>>
>>> The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating
>>> halt decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape,
>>> transition to Ĥ.qn
>>>
>>> when it detects that its pure simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ never
>>> stops running unless Ĥ.qx aborts its simulation of this input.
>>
>> And if that condition is not met under *precisely* the same conditions
>> as the actual, accepted condition that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and
>> only if, Ĥ applied to ⟨Ĥ⟩ does not halt, then you are not justified in
>> altering the definition.
>
> A simulating halt decider does not report on its own behavior. A
> simulating halt decider reports on the behavior of the simulation its
> its own machine description.

A halt decider, regardless of whether it is simulating or otherwise,
reports on the behaviour of the computation represented by its input.
This is very clearly stated by the conditions which Linz indicates in
his proof.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.

It doesn't matter than you don't like this conditions. they are the
conditions that the rest of the universe is talking about when they
discuss halt deciders.

They are clear, unambiguous, and correct.

> This is one level of indirection away (pointer to a pointer) from
> referring to its actual self.

There are no 'pointers' when talking about Turing Machines. Nor does the
word 'itself' appear anywhere in the above conditions. Nor for that
matter do the terms 'UTM', 'simulation', nor 'pure simulation'. Nor, for
that matter are there any good reasons for adding such terms.

>> And while it is apparent that your condition does *not* match the
>> actual criterion, only you know what is really intended by your
>> revised criterion since you very clearly do not mean pure simulation
>> when you right 'pure simulation.'
>>
>
> 0 to ∞ steps of the simulation of P(P) by H are identical to 0 to ∞
> steps of the direct execution of P(P) by H.
>
> 0 to ∞ simulated steps of P(P) by H never stop running.
>
>> Ĥ applied to ⟨Ĥ⟩ halts. You have acknowledged that. That means that UTM
>
> 0 to ∞ steps of the simulation ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by Ĥ.qx never stop
> running.

But Ĥ(⟨Ĥ⟩) halts as does UTM(⟨Ĥ⟩, ⟨Ĥ⟩) as does your P(P), so clearly
there is something wrong with your simulator.

If a given computations behaves differently when simulated by your
simulator than when it is run directly, then your simulator clearly
isn't performing a 'pure simulation'.

And the halting problem is not, nor has it ever been about what happens
inside some broken simulator.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 12/10/2021 5:06 PM, André G. Isaak wrote:
> On 2021-12-10 15:48, olcott wrote:
>> On 12/10/2021 4:02 PM, André G. Isaak wrote:
>>> On 2021-12-10 13:47, olcott wrote:
>>>> On 12/10/2021 1:55 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 12/10/2021 10:12 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>>>> Ĥ.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.
>>>>>>> Whatever that means,
>>>>>>
>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not itself halts*
>>>>>
>>>>> The sub-TM at Ĥ.qx is not a decider, so I agree with the words you
>>>>> have
>>>>> said (but not with what you meant to say).
>>>>>
>>>>
>>>> Ĥ.qx <is> an exact copy of H so it <is> a halt decider that has its
>>>> yes state corrupted, thus causing it to no longer be a decider.
>>>
>>> Ĥ.qx is a single state. It isn't any kind of decider
>>>
>>> The set of state transitions which *starts* at Ĥ.qx is based on a
>>> halt decider but with its accepting state replaced by a loop, meaning
>>> that it is no longer a decider at all. So I don't see why you are
>>> arguing about this.
>>>
>>
>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn portion is that part that is identical to H.
>>
>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not
>>>>> halt.
>>>>>
>>>>
>>>> No this is false.
>>>
>>> The set of state transitions beginning with Ĥ.qx is, as you point
>>> out, based on a halt decider, and the rejecting state of that decider
>>> remains unchanged.
>>>
>>> So yes, the condition that
>>>
>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>
>>> is exactly correct since that is the condition under which a halt
>>> decider is defined to reject its input.
>>>
>>
>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if and only if Ĥ.qx does not transition to Ĥ.qn
>> is incorrect.
>>
>> A simulating halt decider does not report on its own behavior. A
>> simulating halt decider reports on the behavior of the simulation its
>> its own machine description.
>>
>>       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
>>
>> Common sense would tall you that these two must be identical and
>> common sense is proven to be incorrect.
>>
>>> You may not like this definition. That does not make it 'false'. It
>>> is the correct definition, and the one used by absolutely everyone in
>>> the field of computing. If you replace it with something else, you
>>> are the one using the wrong definition.
>>>
>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not its own first state Ĥ.q0
>>>>>> reaches a final state.*
>>>>>
>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not deciding anything.  The sub-TM at Ĥ.qx, when given
>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape, transitions to Ĥ.qn if, and only if, Ĥ applied to
>>>>> ⟨Ĥ⟩ does not halt.
>>>>>
>>>>
>>>> In other words you mean that Ĥ.qx transitions to Ĥ.qn if any only if
>>>> Ĥ.qx never reaches any final state.
>>>>
>>>>>> 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.*
>>>>>
>>>>> The special case of things you call simulating halt deciders are
>>>>> included in everything Linz has to say about halt deciders in general.
>>>>> The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating
>>>>> halt
>>>>> decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape,
>>>>> transition to
>>>>> Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>
>>>>
>>>> No this is incorrect.
>>>>
>>>> The sub-TM at Ĥ.qx, when Ĥ has been constructed from a "simulating
>>>> halt decider" called H, should, when given ⟨Ĥ⟩ ⟨Ĥ⟩ on the tape,
>>>> transition to Ĥ.qn
>>>>
>>>> when it detects that its pure simulation of ⟨Ĥ⟩ applied to ⟨Ĥ⟩ never
>>>> stops running unless Ĥ.qx aborts its simulation of this input.
>>>
>>> And if that condition is not met under *precisely* the same
>>> conditions as the actual, accepted condition that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
>>> Ĥ.qn if, and only if, Ĥ applied to ⟨Ĥ⟩ does not halt, then you are
>>> not justified in altering the definition.
>>
>> A simulating halt decider does not report on its own behavior. A
>> simulating halt decider reports on the behavior of the simulation its
>> its own machine description.
>
> A halt decider, regardless of whether it is simulating or otherwise,
> reports on the behaviour of the computation represented by its input.
> This is very clearly stated by the conditions which Linz indicates in
> his proof.
>

This definition has confused too many people into thinking that it is
reporting on something besides the precise behavior that is stipulated
by the actual input.

The halt decider reports on the behavior its input as if the halt
decider was performing a correct pure simulation of this input.

The halt decider performs a correct pure simulation of N steps of its
input until the input halts on its own or the behavior of N steps of
this input conclusively proves that the correct simulation of this input
never stops running unless aborted.

> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>
> It doesn't matter than you don't like this conditions. they are the
> conditions that the rest of the universe is talking about when they
> discuss halt deciders.
>
> They are clear, unambiguous, and correct.
>
>> This is one level of indirection away (pointer to a pointer) from
>> referring to its actual self.
>
> There are no 'pointers' when talking about Turing Machines. Nor does the
> word 'itself' appear anywhere in the above conditions. Nor for that
> matter do the terms 'UTM', 'simulation', nor 'pure simulation'. Nor, for
> that matter are there any good reasons for adding such terms.
>
>>> And while it is apparent that your condition does *not* match the
>>> actual criterion, only you know what is really intended by your
>>> revised criterion since you very clearly do not mean pure simulation
>>> when you right 'pure simulation.'
>>>
>>
>> 0 to ∞ steps of the simulation of P(P) by H are identical to 0 to ∞
>> steps of the direct execution of P(P) by H.
>>
>> 0 to ∞ simulated steps of P(P) by H never stop running.
>>
>>> Ĥ applied to ⟨Ĥ⟩ halts. You have acknowledged that. That means that UTM
>>
>> 0 to ∞ steps of the simulation ⟨Ĥ⟩ applied to ⟨Ĥ⟩ by Ĥ.qx never stop
>> running.
>
> But Ĥ(⟨Ĥ⟩) halts as does UTM(⟨Ĥ⟩, ⟨Ĥ⟩) as does your P(P), so clearly
> there is something wrong with your simulator.
>
> If a given computations behaves differently when simulated by your
> simulator than when it is run directly, then your simulator clearly
> isn't performing a 'pure simulation'.
>
> And the halting problem is not, nor has it ever been about what happens
> inside some broken simulator.
>
> André
>

On 2021-12-10 16:32, olcott wrote:
> On 12/10/2021 5:06 PM, André G. Isaak wrote:

>> A halt decider, regardless of whether it is simulating or otherwise,
>> reports on the behaviour of the computation represented by its input.
>> This is very clearly stated by the conditions which Linz indicates in
>> his proof.
>>
>
> This definition has confused too many people into thinking that it is
> reporting on something besides the precise behavior that is stipulated
> by the actual input.

it hasn't confused anyone other than you. A halt decider does *not*
report on the behaviour of its input. It reports on the behaviour of the
computation represented by the input.

> The halt decider reports on the behavior its input as if the halt
> decider was performing a correct pure simulation of this input.

No, that's not the definition of halt decider. The actual definition is
the one used by Linz, and that is the one that should be stuck to.

It's trivially easy to 'prove' things when you allow your self to change
definitions. I can easily proof that there is a largest prime number
provided I get to redefine 'prime number' or 'largest', but I assure you
there is no Fields Medal in my future. Similarly, I can prove that P =
NP or that P != NP if I am just allowed to provide my own definitions.
But again, I won't be holding my breath for an ACM Turing Award.

Similarly, no 'proof' you offer claiming to show the halting problem is
computable will gain you any recognition if you don't stick to the
actual accepted definitions.

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

olcott <NoOne@NoWhere.com> writes:

> On 12/10/2021 1:55 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 12/10/2021 10:12 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 12/9/2021 9:03 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>> Ĥ.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.
>>>> Whatever that means,
>>>
>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ *is not deciding whether or not itself halts*
>> The sub-TM at Ĥ.qx is not a decider, so I agree with the words you have
>> said (but not with what you meant to say).
>
> Ĥ.qx <is> an exact copy of H...

No. We've been round and round this loop before and I see that André
has this in hand, so bye for now...

--
Ben.

On 12/10/2021 5:39 PM, André G. Isaak wrote:
> On 2021-12-10 16:32, olcott wrote:
>> On 12/10/2021 5:06 PM, André G. Isaak wrote:
>
>>> A halt decider, regardless of whether it is simulating or otherwise,
>>> reports on the behaviour of the computation represented by its input.
>>> This is very clearly stated by the conditions which Linz indicates in
>>> his proof.
>>>
>>
>> This definition has confused too many people into thinking that it is
>> reporting on something besides the precise behavior that is stipulated
>> by the actual input.
>
> it hasn't confused anyone other than you. A halt decider does *not*
> report on the behaviour of its input. It reports on the behaviour of the
> computation represented by the input.
>

When the input to a halt decider is directly executable machine code
then that halt status decision is based on the actual behavior of the
actual execution of this input.

The only reason that the word "representation" has ever been used is the
mere convention that TM's cannot directly execute other TM's, there must
be an intermediate TM description (essentially source-code) inbetween.

>> The halt decider reports on the behavior its input as if the halt
>> decider was performing a correct pure simulation of this input.
>
> No, that's not the definition of halt decider. The actual definition is
> the one used by Linz, and that is the one that should be stuck to.
>
> It's trivially easy to 'prove' things when you allow your self to change
> definitions. I can easily proof that there is a largest prime number
> provided I get to redefine 'prime number' or 'largest', but I assure you
> there is no Fields Medal in my future. Similarly, I can prove that P =
> NP or that P != NP if I am just allowed to provide my own definitions.
> But again, I won't be holding my breath for an ACM Turing Award.
>
> Similarly, no 'proof' you offer claiming to show the halting problem is
> computable will gain you any recognition if you don't stick to the
> actual accepted definitions.
>

--
Copyright 2021 Pete Olcott

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