The following is the exact Linz Ĥ applied to its own Turing machine
description except that the infinite loop appended to the YES path has
been removed.

Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn

The copy of H at Ḧ.qx maps ⟨Ḧ⟩ ⟨Ḧ⟩ to a final state on the basis of the
behavior of the pure simulation of N steps of ⟨Ḧ⟩ applied to ⟨Ḧ⟩

It performs a pure simulation of its input until:
(a) Its input halts on its own, then it transitions to Ḧ.qy.

(b) It determines that the pure simulation of its input would never halt
on its own, then it aborts its simulation and transitions to Ḧ.qn.

https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (315-320)

--
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/24/21 3:37 PM, olcott wrote:
> The following is the exact Linz Ĥ applied to its own Turing machine
> description except that the infinite loop appended to the YES path has
> been removed.
>
> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
> Ḧq0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
>
> The copy of H at Ḧ.qx maps ⟨Ḧ⟩ ⟨Ḧ⟩ to a final state on the basis of the
> behavior of the pure simulation of N steps of ⟨Ḧ⟩ applied to ⟨Ḧ⟩
>
> It performs a pure simulation of its input until:
> (a) Its input halts on its own, then it transitions to Ḧ.qy.
>
> (b) It determines that the pure simulation of its input would never halt
> on its own, then it aborts its simulation and transitions to Ḧ.qn.
>
> https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (315-320)
>

Ok.

So we have that H^ <H^> (aka H^q0 <H^>) will always go to
H^.qx <H^> <H^>

We also know that H^.qx <H^> <H^> is a point with a full copy of the
code of H (with a modification to what happens AFTER reaching H.qy) so
H^.qx will go to H^.qy or H^.qn exactly by the same rules as H uses to
go from H.q0 to H.qy or H.qn.

H <H^> <H^>, being assumed to be a perfect Halt Decider will go to H.qy
if its input <H^> <H^> represents a Halting computation, and to Hqn if
its input represents a non-halting computation.

So this means that H^.qx <H^> <H^> and also H^q0 <H^> will end up going
to H^.qy. By construction H^.qy will end up in a non-halting behavior
due to the added infinite loop, and H^.qn will end up in Halting Behavior.

Let us now look at H.

By your definition, H will go to H.qy if it can see its input halt. The
computation H^ <H^> will only halt if H^ goes to H^.qn or H halts in
some state not defined as an answer (which it isn't allowed to do being
a corret decider), so H can only go to qy if H^ goes to qn, but that can
only happen if H goes to qn.

Since there is NO case where H can go to BOTH qy and qn, this can not
happen.

Next, by your definition, H will go th H.qn if it can prove that the
computation its input represents ( H^ <H^> ) will never halt. But, if H
<H^> <H^> goes to H.qn then we know that H^ <H^> will also go to H^.qn
and Halt, so H <H^> <H^> can NOT go to H.qn, as if it does, its input
represents a Halting Computaton.

We have just PROVED that by your rules, H can NOT go to either H.qy or
H.qn and thus your H must NEVER halt and fails to be the needed decider,
or H fails to follow your rules, or it used unsound logic and just
THINKS that the pure simulation of its input will never halt when it does.

Thus, your H must fail to meet its requirements, or in other words,
there exists NO H that meets these requirements. PERIOD.

Please show the error in the logic.

Most likely you are going to object to the fact that all copies of H
(including the one at H^.qx) behave the same, but that is a FUNDAMENTAL
property of Turing Machines and Computations in general, so you better
prove that it is actually possible for a REAL Turing Machine or an
ACTUAL algorithm to behave the way you need it to.