A Simulating Halt Decider (SHD) computes the mapping from its input to
its own accept or reject state based on whether or not the pure
simulation of its input could reach the final state of this input in a
finite number of simulated steps.

The following simplifies the syntax for the definition of the Linz
Turing machine Ĥ, it is now a single machine with a single start state.
A copy of Linz H is embedded at Ĥ.qx

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

The above shows that the simulated input to embedded_H never reaches its
own final state whether or not its simulation is aborted.
(a) If the simulation is not aborted the above sequence never ends.
(b) If the simulation is aborted the entire chain of recursive
simulations immediately stops.

In no case does the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ ever reach its final state
⟨Ĥ⟩.qn thus never meets the Linz definition of halting:

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234) Thus if embedded_H rejects its input it
is necessarily correct.

Because all halt deciders are deciders they compute the mapping from
their input finite strings inputs to their own accept or reject state.
Halt deciders (because they are deciders) do not compute any mappings
from non-finite string non-inputs.

No halt decider ever determines the halt status of the computation that
contains its actual self thus embedded_H does not compute the mapping
from Ĥ ⟨Ĥ⟩ because it is neither an input nor a finite string.

Even Linz was confused by this. embedded_H is not supposed to report on
itself or the computation that it is contained within.

As long as it is verified that the simulated input to embedded_H cannot
reach its final state then we know that this simulated input cannot meet
the Linz definition of halting.

As long as we know that this simulated input cannot meet the Linz
definition of halting we know that this input specifies a non-halting
sequence of configurations.

As long as we know that this input specifies a non-halting sequence of
configurations then we know that embedded_H would be correct to reject
this input.

Halting problem undecidability and infinitely nested simulation (V4)

https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4

--
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 3/25/22 12:16 PM, olcott wrote:
> A Simulating Halt Decider (SHD) computes the mapping from its input to
> its own accept or reject state based on whether or not the pure
> simulation of its input could reach the final state of this input in a
> finite number of simulated steps.
>
> The following simplifies the syntax for the definition of the Linz
> Turing machine Ĥ, it is now a single machine with a single start state.

THE WRONG Definition, as explained below.

> A copy of Linz H is embedded at Ĥ.qx
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
> state.

No, WRONG condition, H^ -> Qy if H -> Qy, which it is supposed to do if
and only if H^ applied to <H^> Halts.

There is NO mention of 'Simulation' in the definition, especially by H.

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
> final state.

No, WRONG contition. H^ -> Qn if H -> Qn, which it is supposed to do if
and only if H^ applied to <H^> will never halt.

There is NO mention of 'Simulation', in the definition, especialy by H.

Note, by the definition of a UTM, we CAN substitute UTM <H^> <H^> for H^
applied to <H^> in both of those, but BY DEFINITION, a UTM will NEVER
abort is simulation of its input, so if H does, it is NOT a UTM, BY
DEFINITION.

>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Then these steps would keep repeating:
>   Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>

And that behavior ONLY happens if embedded_H NEVER aborts its
simulation, and in that case, yes H^ appliled to <H^> is non-halting,
but H never gives the answer, so it fails to be a decider.

> The above shows that the simulated input to embedded_H never reaches its
> own final state whether or not its simulation is aborted.

Not quite, it shows the simulation by embedded_H can never reach its
fina state, but that is NOT the requirement from above. IF embedded_H
does abort its simulation, we need to look to H^ applied to <H^> or UTM
applied to <H^> <H^> (which will do the same) to get the right answer.

> (a) If the simulation is not aborted the above sequence never ends.

Yes, and H never answer, and thus fails.

> (b) If the simulation is aborted the entire chain of recursive
> simulations immediately stops.
>

And returns to the initial H^ applied to <H^> which used the first
version of embedded_H, which then HALT, showing that it is a Halting
Computation.

> In no case does the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ ever reach its final state
> ⟨Ĥ⟩.qn thus never meets the Linz definition of halting:

Doesn't matter what the PARTIAL simulation by ebedded_H does, what
matters is what the actual machine does, or by equivalence, the
simulation of the input by a UTM.

>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234) Thus if embedded_H rejects its input it
> is necessarily correct.

Right, the TURING MACHINE, and H^ applied to <H^> does Halt if
embedded_H -> Qn

>
> Because all halt deciders are deciders they compute the mapping from
> their input finite strings inputs to their own accept or reject state.
> Halt deciders (because they are deciders) do not compute any mappings
> from non-finite string non-inputs.

And the input is <H^> <H^> which maps to Qy or Qn. Thus it fullfils the
requiments of something we can ask a decider to do.

The MAPPING, is based on H^ applied to <H^>, but the MAPPING is allowed
to be anything. The only possible issue is the mapping might not
actually be computable (like Halting is not computable) You confuse
being ALLOWED with being ABLE.

> No halt decider ever determines the halt status of the computation that
> contains its actual self thus embedded_H does not compute the mapping
> from Ĥ ⟨Ĥ⟩ because it is neither an input nor a finite string.

Nothing in the rules prohibts it. Can you show where that comes from, or
is this just another of your UNFOUNDED 'self-evident truth' that aren't
even part of the Formal Logic System?

>
> Even Linz was confused by this. embedded_H is not supposed to report on
> itself or the computation that it is contained within.

No, he was not confused, YOU ARE.

>
> As long as it is verified that the simulated input to embedded_H cannot
> reach its final state then we know that this simulated input cannot meet
> the Linz definition of halting.

Except the ACTUAL simulation of the input DOES reach the final state. It
is just the partial simulaton done by H/embedded_H that doesn't, and
partial simulations do not, by themselves, prove non-halting.

>
> As long as we know that this simulated input cannot meet the Linz
> definition of halting we know that this input specifies a non-halting
> sequence of configurations.

Except it does.

>
> As long as we know that this input  specifies a non-halting sequence of
> configurations then we know that embedded_H would be correct to reject
> this input.
>

Except it Halts/

>
> Halting problem undecidability and infinitely nested simulation (V4)
>
> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>
>

Full of ERRORS.

You start with a wrong definition and thus your whole logic sequence is
UNSOUND.

FAIL.