I have reformulated my system so that it correctly handles this.

// Full Linz Ĥ as C/x86
void P(ptr x)
{ ptr y = copy(x);
if (H(x, y))
HERE: goto HERE;
}

Because it no longer relies on machine addresses H1(P,P) == H(P,P).

[Olcott 2021 generic halt deciding principle] Whenever the pure
simulation of the input to simulating halt decider H(x,y) never stops
running unless H aborts its simulation H correctly aborts this
simulation and returns 0 for not halting.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the UTM simulation of the input to Ĥ.qx ⟨Ĥ⟩ applied to ⟨Ĥ⟩ reaches
its own final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of the input to Ĥqx ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach its
final state (whether or not this simulation is aborted) then it is
necessarily true that Ĥqx transitions to Ĥ.qn correctly.

Halting problem undecidability and infinitely nested simulation V2

https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2

--
Copyright 2021 Pete Olcott

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

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.

--
Ben.

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.

When we further hypothesize the the original H was a simulating halt
decider then we get:

Ĥ applied to ⟨Ĥ⟩ essentially specifies infinite recursion that is
aborted after the first invocation of this infinite recursion.

Because it is not aborted at the first invocation we get the confusing
case where Ĥ halts yet its own simulation of itself must be aborted.

We don't have this issue with H. H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ aborts this
infinite recursion at its first invocation.

--
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/8/21 4:22 PM, olcott wrote:
> I have reformulated my system so that it correctly handles this.
>
> // Full Linz  Ĥ as C/x86
> void P(ptr x)
> {
>   ptr y = copy(x);
>   if (H(x, y))
>     HERE: goto HERE;
> }

Hopefully copy(x) copies ALL the code of x, which includes the H that P
calls, as THAT is part of the requirement.

>
> Because it no longer relies on machine addresses H1(P,P) == H(P,P).
>
> [Olcott 2021 generic halt deciding principle] Whenever the pure
> simulation of the input to simulating halt decider H(x,y) never stops
> running unless H aborts its simulation H correctly aborts this
> simulation and returns 0 for not halting.
>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If the UTM simulation of the input to Ĥ.qx ⟨Ĥ⟩ applied to ⟨Ĥ⟩ reaches
> its own final state.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> If the pure simulation of the input to Ĥqx ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach its
> final state (whether or not this simulation is aborted) then it is
> necessarily true that Ĥqx transitions to Ĥ.qn correctly.
>
>
>
> Halting problem undecidability and infinitely nested simulation V2
>
> https://www.researchgate.net/publication/356105750_Halting_problem_undecidability_and_infinitely_nested_simulation_V2
>
>

Except that if H.q0 <H^> <H^> -> H.qn because it THINKS that H^.q0 <H^>
will not halt, then we KNOW because H^.qx <H^> <H^> is identical to
H.q0 <H^> <H^>, and H.q0 <H^> <H^> goes to H.qn, that H^.qx <H^> <H^>
since it is the IDENTICAL algorithm with the IDENTICAL input will also
go to H^.qn, which halts.

Since we also know, by design, that H^.q0 <H^> will go to
H^.qx <H^> <H^> thus we hve proven that H^.q0 <H^> WILL go to H^.qn and
Halt.

Thus, since H <H^> <H^>, by the DEFINITION of the Halting Problem is
asking about the behavior of H^ <H^> (aka H^.q0 <H^>) and we have just
shown that this DOES Halt, H <H^> <H^> is INCORRECT to go to H.qn, as
that indicates that its input represents a non-halting comutation, but
we hae shown that it is HALTING.

If you want to talk about UTM, we KNOW, by the definiton of what a UTM
is that UTM <H^> <H^> behaves IDENTICALLY to H^ <H^>. PERIOD.

IF you Olcott 'Theory' refers to ANY concept of 'pure simulation' that
isn't compatible with what a UTM would do given the same input, it is
NOT talking about the REAL Halting Problem.

Summary.

H^.q0 <H^> Halts, BECAUSE H^.qx <H^> <H^> -> H^.qn, which is a Halting
State.

Thus H.q0 <H^> <H^> -> H.qn is INCORRECT, as UTM <H^> <H^> Halts
because, BY DEFINITION, it behaves identical to H^.q0 <H^>, which Halts.

FAIL.

Now, if H.q0 <H^> <H^> actually FAILS to go to H.qn but runs forever,
then it 'would have been correct' to go to H.qn, but since it didn't it
fails to be the needed decider.

Now if somehow H(P,P) never answer but H1(P,P) does, then that just
shows that H and H1 are NOT the same computation, BY DEFINITION (or have
a hidden input, which is basically the same thing).

On 12/8/21 5:40 PM, olcott wrote:
> 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.

No, you don't understand the notation.

H <x> y is what we use to decide if x y will halt, i.e the MACHINE x
given input Y.

Note, that H takes the REPRESENTATION of the machine, not the machine
itself, as that doesn't make sense.

So, in the above call, x = H^, so <x> = <H^>, y = <H^>

THus H <H^> <H^> is asking if H^ <H^> will halt.

>
> When we further hypothesize the the original H was a simulating halt
> decider then we get:
>
> Ĥ applied to ⟨Ĥ⟩ essentially specifies infinite recursion that is
> aborted after the first invocation of this infinite recursion.

It only specifies infinite recursion of H isn't able to answer its
question in finite time. You need to FIX what you have defined your H to
be. Either it actually is a 'pure simulation' and gets stuck in infinite
recursion and can't answer, or it DOES abort, and thus prevents H^ from
being infinitely recursive.

>
> Because it is not aborted at the first invocation we get the confusing
> case where Ĥ halts yet its own simulation of itself must be aborted.
>
> We don't have this issue with H. H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ aborts this
> infinite recursion at its first invocation.

And thus when we look at H^ <H^> and follow the EXACT SAME PATH, with a
finite preamble (from H^.q0 to H^.qx), we see that H^ <H^> will ALSO
Halt at H^.qn, and thus H^ <H^> is HALTING.

FAIL.

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.

--
Ben.

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

None-the-less Ĥ.qx is not deciding whether or not itself halts it is
deciding whether or not ⟨Ĥ⟩ applied to ⟨Ĥ⟩ specifies a sequence of
configurations that reaches its own final state.

Everyone gets confused about this and believes that when Ĥ.qx says that
itself never halts this is a contradiction that can't be true because it
just halted to say this.

On the other halts if Ĥ.qx says that itself halts it gets stuck in an
infinite loop so wrong again.

--
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/8/21 9:22 PM, olcott wrote:
> 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.
>>
>
> None-the-less Ĥ.qx is not deciding whether or not itself halts it is
> deciding whether or not ⟨Ĥ⟩ applied to ⟨Ĥ⟩ specifies a sequence of
> configurations that reaches its own final state.

<H^> can't be 'applied' to anything. It is just a string.

H^.qx <H^> <H^> (or more precisely, the H.q0 that is identical to this
code) is deciding on the behavoir of H^ applied to <H^>

Remember, H is applied to <x> y to decice what x applied to y does.

Linz terminalogiy was H Wm w decides on M w (where Wm is the description
of M).

>
> Everyone gets confused about this and believes that when Ĥ.qx says that
> itself never halts this is a contradiction that can't be true because it
> just halted to say this.

Right, THAT contradition is the key to the proof.

H applied to <x> y, to be correct, needs to go to H.qn if x applied to y
never halts, and to H.qy if x applied to y does halt.

Note, we can not say that H WILL get to H.qn if x applied to y never
halts, as that PRESUMES that H can exist and is correct, H will do what
its algorithm says it should do, and 'Get the right answer' is not a
proper algorithm.

Also, we know that H^ <p> WILL go to H^.qn if H <p> <p> goes to H.qn and
H^ <p> WILL go to H^.qy if H <p> <p> goes to H.qy as H^.q0 <p> will get
to H^.qx <p> <p> by construction, and then H^.qx has copied the
algorithm of H, so will end up in its equivalent state.

Now we also know that H^.qn WILL Halt, and H^.qy will fall into an
infinite loop.

Thus, by construction we can say that H^ <p> will Halt if H <p> <p> says
that p <p> will not halt (by going to qn) and H^ <p> will never halt if
H <p> <p> says that p <p> will Halt. This behavior of H^ is absolute by
construction, note it is based on what H SAYS p <p> will do, not what p
<p> actually does.

When we let <p> be <H^> we then get that:

H^ <H^> will Halt if H <H^> <H^> says H^ <H^> will not Halt and
H^ <H^> will not Halt if H <H^> MH^> says that H^ <H^> will Halt,

so we see that H is stuck and what ever it says will be wrong.

This is NOT a contradiction, because H's end state was always about be
correct, not what MUST happen, while H^'s behavior was built by
construction based on what H says.

Linz uses definite wording, as he started with the conditional
proposition that ASSUMED that H was correct, and he shows that this
assumption leads to a contradiction, and thus the assumption can't be
correct. You need to read the proof with the understanding of this form
of logic, that if a statement implies a falsehood, the statement must be
false.

>
> On the other halts if Ĥ.qx says that itself halts it gets stuck in an
> infinite loop so wrong again.
>

Right, an H that gets the answer right can not exist, as for it to exist
it implies that H^ will Halt and be Non-Halting at the same time, which
can not happen (or any of a number of other contradictions).

THe key point is that H being right was only an ASSUMPTION, it is
logically possible that an H that is right just doesn't exist, as we see
MUST be, as an H that is right can't happen.

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.

--
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 1:50 PM, olcott wrote:
> 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.
>

WRONG.

H^.qx <H^> <H^> transitions to H^.qn if and only if H.q0 <H^? <H^>
transitions to H.qn. This is by construction.

H.qn <H^> <H^> is only SUPPOSED to go to H.qn if and only if H^ <H^>
never halts or equivalenty if UTM(<H^>,<H^>) never halts.

Since we have your claim that H <H^> <H^> goes to H.qn, and thus your
claim that it somehow 'correctly' predicts H^ halting, we KNOW as a fact
that H^ <H^> will also go to H^.qn and thus we KNOW as a fact that it it
the case that UTM <H^> <H^> will Halt.

THis means that H was INCORRECT in its statement that H^ was non-halting.

PERIOD.

The assertion that H^.qx <H^> <H^> only transitions to H^.qn if and only
if UTM (<H^>, <H^>) Halts holds only in the case that H is assumed to be
correct.

Your statement of the contradiction only applies if we assume that H is
correct, and THAT assumption leads us to the inevitble contradition that
H^ will end up halting when it doesn't or not halting when it does,
shows that the assumption that H is correct can't be true.

FAIL.

On 12/9/2021 1:33 PM, Richard Damon wrote:
>
> On 12/9/21 1:50 PM, olcott wrote:
>> 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.
>>
>
> WRONG.
>
> H^.qx <H^> <H^> transitions to H^.qn if and only if H.q0 <H^? <H^>
> transitions to H.qn. This is by construction.
>

It is a common mistake to believe that the halt decider is basing its
halt status decision on its own behavior.

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.qn <H^> <H^> is only SUPPOSED to go to H.qn if and only if H^ <H^>
> never halts or equivalenty if UTM(<H^>,<H^>) never halts.
>
> Since we have your claim that H <H^> <H^> goes to H.qn, and thus your
> claim that it somehow 'correctly' predicts H^ halting, we KNOW as a fact
> that H^ <H^> will also go to H^.qn and thus we KNOW as a fact that it it
> the case that UTM <H^> <H^> will Halt.
>
> THis means that H was INCORRECT in its statement that H^ was non-halting.
>
> PERIOD.
>
> The assertion that H^.qx <H^> <H^> only transitions to H^.qn if and only
> if UTM (<H^>, <H^>) Halts holds only in the case that H is assumed to be
> correct.
>
> Your statement of the contradiction only applies if we assume that H is
> correct, and THAT assumption leads us to the inevitble contradition that
> H^ will end up halting when it doesn't or not halting when it does,
> shows that the assumption that H is correct can't be true.
>
> FAIL.

--
Copyright 2021 Pete Olcott

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

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. UTM(<M>, I) has the same halting behaviour as M applied
to I. You can re-write Linz's simpler conditions in terms of a UTM, but
you get the same contradiction.

--
Ben.

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.

> UTM(<M>, I) has the same halting behaviour as M applied
> to I. You can re-write Linz's simpler conditions in terms of a UTM, but
> you get the same contradiction.
>

With that convoluted notational convention one could be easily confused
into thinking that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qn if and only if Ĥ.qx
does not transition to Ĥ.qn.

One key aspect of my discovery that is crucially relevant is the level
of indirect reference between Ĥ.qx and its 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 12/9/21 3:40 PM, olcott wrote:
> On 12/9/2021 1:33 PM, Richard Damon wrote:
>>
>> On 12/9/21 1:50 PM, olcott wrote:
>>> 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.
>>>
>>
>> WRONG.
>>
>> H^.qx <H^> <H^> transitions to H^.qn if and only if H.q0 <H^? <H^>
>> transitions to H.qn. This is by construction.
>>
>
> It is a common mistake to believe that the halt decider is basing its
> halt status decision on its own behavior.
>
> 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

So, what do you disagree with what I said?

Your H says H(P,P) should be the value 0, indicating that P(P) will not
halt, but if H actually DOES return the value of 0, the P(P) will Halt,
so H was wrong.

The DEFINITION of what determines the RIGHT answer for H, is the running
of the independent computation that its input represents, thus for
H(P,P), we run P(P).

The construction of H^/P is such that if H(x,x) returns 0, sayig that H
thinks that x(x) will never halt, then H^/P(x) will halt. When x is the
description of H^/P this means that we H^/P will ask H what H^/P will
do, and it will do the opposite, and there is NOTHING that H can do
about it, H(x,y) always needs to return a value, and that value needs to
always be the same for EVERY call to H(x,y) for those same x and y.

H^/P is fully able to ask H what it thinks H^(<H^>) / P(P) will do, and
then just do the opposite. H's only way to not be wrong is to just not
answer, at which point it becomes wrong by default.

You seem to have a blind spot about that fact that H^/P is ALLOWED to
base its behavior on the answer that H gives about H^/P, and then react
to it.

H is CONSTRAINED by its design to return what ever answer its algorithm
provides. The is no 'magic' get the right answer button to use. H^/P is
able to use whatever answer H gives, and for the case of H(P,P) it is
able to make P(P) behave in a way contrary to what H says, making H
wrong. This is just basic fundamentals of how Computations and Turing
Machines work. I don't think you really understand any of this.

>
>> H.qn <H^> <H^> is only SUPPOSED to go to H.qn if and only if H^ <H^>
>> never halts or equivalenty if UTM(<H^>,<H^>) never halts.
>>
>> Since we have your claim that H <H^> <H^> goes to H.qn, and thus your
>> claim that it somehow 'correctly' predicts H^ halting, we KNOW as a
>> fact that H^ <H^> will also go to H^.qn and thus we KNOW as a fact
>> that it it the case that UTM <H^> <H^> will Halt.
>>
>> THis means that H was INCORRECT in its statement that H^ was non-halting.
>>
>> PERIOD.
>>
>> The assertion that H^.qx <H^> <H^> only transitions to H^.qn if and
>> only if UTM (<H^>, <H^>) Halts holds only in the case that H is
>> assumed to be correct.
>>
>> Your statement of the contradiction only applies if we assume that H
>> is correct, and THAT assumption leads us to the inevitble contradition
>> that H^ will end up halting when it doesn't or not halting when it
>> does, shows that the assumption that H is correct can't be true.
>>
>> FAIL.
>
>

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

--
Ben.

On 12/9/2021 4:46 PM, Richard Damon wrote:
> On 12/9/21 3:40 PM, olcott wrote:
>> On 12/9/2021 1:33 PM, Richard Damon wrote:
>>>
>>> On 12/9/21 1:50 PM, olcott wrote:
>>>> 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.
>>>>
>>>
>>> WRONG.
>>>
>>> H^.qx <H^> <H^> transitions to H^.qn if and only if H.q0 <H^? <H^>
>>> transitions to H.qn. This is by construction.
>>>
>>
>> It is a common mistake to believe that the halt decider is basing its
>> halt status decision on its own behavior.
>>
>> 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
>
> So, what do you disagree with what I said?
>

It is not the case that Ĥ applied to ⟨Ĥ⟩ is being examined by Ĥ.qx, it
is one level of indirect reference away from this.

> Your H says H(P,P) should be the value 0, indicating that P(P) will not
> halt, but if H actually DOES return the value of 0, the P(P) will Halt,
> so H was wrong.
>
> The DEFINITION of what determines the RIGHT answer for H, is the running
> of the independent computation that its input represents, thus for
> H(P,P), we run P(P).
>
> The construction of H^/P is such that if H(x,x) returns 0, sayig that H
> thinks that x(x) will never halt, then H^/P(x) will halt. When x is the
> description of H^/P this means that we H^/P will ask H what H^/P will
> do, and it will do the opposite, and there is NOTHING that H can do
> about it, H(x,y) always needs to return a value, and that value needs to
> always be the same for EVERY call to H(x,y) for those same x and y.
>
> H^/P is fully able to ask H what it thinks H^(<H^>) / P(P) will do, and
> then just do the opposite. H's only way to not be wrong is to just not
> answer, at which point it becomes wrong by default.
>
> You seem to have a blind spot about that fact that H^/P is ALLOWED to
> base its behavior on the answer that H gives about H^/P, and then react
> to it.
>
> H is CONSTRAINED by its design to return what ever answer its algorithm
> provides. The is no 'magic' get the right answer button to use. H^/P is
> able to use whatever answer H gives, and for the case of H(P,P) it is
> able to make P(P) behave in a way contrary to what H says, making H
> wrong. This is just basic fundamentals of how Computations and Turing
> Machines work. I don't think you really understand any of this.
>
>
>>
>>> H.qn <H^> <H^> is only SUPPOSED to go to H.qn if and only if H^ <H^>
>>> never halts or equivalenty if UTM(<H^>,<H^>) never halts.
>>>
>>> Since we have your claim that H <H^> <H^> goes to H.qn, and thus your
>>> claim that it somehow 'correctly' predicts H^ halting, we KNOW as a
>>> fact that H^ <H^> will also go to H^.qn and thus we KNOW as a fact
>>> that it it the case that UTM <H^> <H^> will Halt.
>>>
>>> THis means that H was INCORRECT in its statement that H^ was
>>> non-halting.
>>>
>>> PERIOD.
>>>
>>> The assertion that H^.qx <H^> <H^> only transitions to H^.qn if and
>>> only if UTM (<H^>, <H^>) Halts holds only in the case that H is
>>> assumed to be correct.
>>>
>>> Your statement of the contradiction only applies if we assume that H
>>> is correct, and THAT assumption leads us to the inevitble
>>> contradition that H^ will end up halting when it doesn't or not
>>> halting when it does, shows that the assumption that H is correct
>>> can't be true.
>>>
>>> FAIL.
>>
>>
>

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

So just to make sure everyone is on the same page, a UTM is a turing
machine which takes as its input the description of a computation (i.e.
the description of a turing machine and an input string) and performs
that exact computation. A UTM does not have the ability to 'abort' its
input, so when you talk about something aborting its input, you are not
talking about a UTM.

People will agree to the description that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to
Ĥ.qn if, and only if, UTM(⟨Ĥ⟩, ⟨Ĥ⟩) does not halt, though the
introduction of a UTM is entirely pointless here.

But people won't agree to the above if you are using the term 'UTM' to
mean anything other than UTM.

André

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

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.

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

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.

> So just to make sure everyone is on the same page, a UTM is a turing
> machine which takes as its input the description of a computation (i.e.
> the description of a turing machine and an input string) and performs
> that exact computation. A UTM does not have the ability to 'abort' its
> input, so when you talk about something aborting its input, you are not
> talking about a UTM.
>
> People will agree to the description that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to
> Ĥ.qn if, and only if, UTM(⟨Ĥ⟩, ⟨Ĥ⟩) does not halt, though the
> introduction of a UTM is entirely pointless here.
>

It *IS* the [Olcott 2021 generic halt deciding principle] that
eliminates the feedback loop between the halt decider and its
conventional otherwise pathological input.

> But people won't agree to the above if you are using the term 'UTM' to
> mean anything other than UTM.
>
> 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-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.

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

No, it isn't another way of saying that since a UTM is not a 'simulating
halt decider'. It is a UTM. And a UTM cannot abort its input.

>> So just to make sure everyone is on the same page, a UTM is a turing
>> machine which takes as its input the description of a computation
>> (i.e. the description of a turing machine and an input string) and
>> performs that exact computation. A UTM does not have the ability to
>> 'abort' its input, so when you talk about something aborting its
>> input, you are not talking about a UTM.
>>
>> People will agree to the description that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to
>> Ĥ.qn if, and only if, UTM(⟨Ĥ⟩, ⟨Ĥ⟩) does not halt, though the
>> introduction of a UTM is entirely pointless here.
>>
>
> It *IS* the [Olcott 2021 generic halt deciding principle] that
> eliminates the feedback loop between the halt decider and its
> conventional otherwise pathological input.

Linz's H_Hat very clearly states the conditions under which H_Hat
reaches final state qn and the conditions under which H_Hat loops. If
your "proof" requires you to change these conditions to anything else,
you are no longer talking about the Linz H_Hat.

André

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

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.

>> 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.
>
> No, it isn't another way of saying that since a UTM is not a 'simulating
> halt decider'. It is a UTM. And a UTM cannot abort its input.
>
>>> So just to make sure everyone is on the same page, a UTM is a turing
>>> machine which takes as its input the description of a computation
>>> (i.e. the description of a turing machine and an input string) and
>>> performs that exact computation. A UTM does not have the ability to
>>> 'abort' its input, so when you talk about something aborting its
>>> input, you are not talking about a UTM.
>>>
>>> People will agree to the description that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to
>>> Ĥ.qn if, and only if, UTM(⟨Ĥ⟩, ⟨Ĥ⟩) does not halt, though the
>>> introduction of a UTM is entirely pointless here.
>>>
>>
>> It *IS* the [Olcott 2021 generic halt deciding principle] that
>> eliminates the feedback loop between the halt decider and its
>> conventional otherwise pathological input.
>
> Linz's H_Hat very clearly states the conditions under which H_Hat
> reaches final state qn and the conditions under which H_Hat loops. If
> your "proof" requires you to change these conditions to anything else,
> you are no longer talking about the Linz H_Hat.
>
> 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-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.

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. If you change them to something else you are no
longer talking about Linz's H_Hat.

André

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

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.

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.

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

> If you change them to something else you are no
> longer talking about Linz's H_Hat.
>
> 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 12/9/21 7:02 PM, olcott wrote:
> On 12/9/2021 4:46 PM, Richard Damon wrote:
>> On 12/9/21 3:40 PM, olcott wrote:
>>> On 12/9/2021 1:33 PM, Richard Damon wrote:
>>>>
>>>> On 12/9/21 1:50 PM, olcott wrote:
>>>>> 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.
>>>>>
>>>>
>>>> WRONG.
>>>>
>>>> H^.qx <H^> <H^> transitions to H^.qn if and only if H.q0 <H^? <H^>
>>>> transitions to H.qn. This is by construction.
>>>>
>>>
>>> It is a common mistake to believe that the halt decider is basing its
>>> halt status decision on its own behavior.
>>>
>>> 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
>>
>> So, what do you disagree with what I said?
>>
>
> It is not the case that Ĥ applied to ⟨Ĥ⟩ is being examined by Ĥ.qx, it
> is one level of indirect reference away from this.

WHAT indirection?

H^.qx has EXACTLY the same code as H.q0 coming from it to its answer.

H^.qx <H^> <H^> is thus EXACTLY the same computation as H.q0 <H^> <H^>

If H claims to be a Halt decider, then the answer it generates when we
run H <x> y is BY DEFINITION supposed to be the halting behavior of X
applied to y.

There are NO 'indirect' references.

Do you not understand what it means to put a copy of an algorithm into
another algorithm?

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.

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.