XPost: comp.theory, sci.math, sci.logic

A SHD computes the mapping from its input to its own accept or reject
state based on whether or not the pure simulation of its simulated input
could reach its own final state 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.



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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 3/25/2022 3:29 PM, Ben Bacarisse wrote:

olcott <NoOne@NoWhere.com> writes:

A SHD computes the mapping from its input to its own accept or reject
state based on whether or not the pure simulation of its simulated
input could reach its own final state 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.

Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ halts.

No it turns out to be the case that a halt decider is not allowed to
report on its own behavior because itself is neither an input nor a
finite string. Deciders must compute the mapping from their input finite strings to an accept or reject state.

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

Or, more simply, use Linz's condition: if Ĥ applied to ⟨Ĥ⟩ does not halt.

No it turns out to be the case that a halt decider is not allowed to
report on its own behavior because itself is neither an input nor a
finite string. Deciders must compute the mapping from their input finite strings to an accept or reject 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 ... is wrong for any Ĥ that meets Linz's definitions. You can talk about a TM that acts like this, but since it's not what Linz is talking
about any conclusions you draw don't apply the proof.

Linz merely doesn't bother to notice what happens when H is a simulating
halt decider.

--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 3/26/2022 7:30 PM, Ben Bacarisse wrote:

olcott <NoOne@NoWhere.com> writes:

what the correct answer for it is, is determined solely by whether or
not Ĥ halts on input ⟨Ĥ⟩.

That is not true. This is true:

The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of infinite recursion that only terminates normally because of its one-way dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.



--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 3/27/2022 11:20 AM, Ben Bacarisse wrote:

olcott <NoOne@NoWhere.com> writes:

On 3/26/2022 7:30 PM, Ben Bacarisse wrote:

olcott <NoOne@NoWhere.com> writes:

what the correct answer for it is, is determined solely by whether or
not Ĥ halts on input ⟨Ĥ⟩.

That is not true.

You don't get to say what the halting problem is. It's already been specified.

Every string either represents a halting computation or it does not.
There is no context other than some prior agreed encoding about how a TM
and an input should be represented. A halt decide must accept exactly
those strings that represent halting computations.

The fact that you need to reject the very definition of the problem is
clear evidence that you know that no TM is a halt decider.

This is true:

The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its
one-way dependency relationship on embedded_H aborting the second
invocation of this otherwise infinite recursion.

It does not matter why the computation represented a particular string
halts. You've been trying to pull this "it only halts because" nonsense
for years.

As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation then its
rejection of this input is necessarily correct and everything else in
the universe is totally irrelevant.

A halt decider must compute the mapping from its inputs (not anything
else in the universe besides it inputs) to its own accept or reject
state based on the actual behavior specified by these actual inputs (not
any behavior of anything else in the universe).

We also know that the actual behavior specified by these inputs must be
the same as the behavior of the simulation of N steps of this input by a
UTM. On this basis we know that any behavior that diverges from this
behavior is not the correct basis for the halt status decision.

The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some computation.

If it is simulated outside of Ĥ then it must have the same behavior as
Ĥ applied to ⟨Ĥ⟩.

If it is simulated inside of Ĥ then several steps of Ĥ have already been executed when this simulation begins thus specifying a different
sequence of configurations then when Ĥ starts at its beginning.

I assume you have not
been deceiving us for years, and you know that the computation it
represents is Ĥ applied to the string ⟨Ĥ⟩.

When Ĥ is simulated in the middle of Ĥ this is different than when Ĥ is simulated at the beginning of Ĥ.

That either is or is not a
halting computation. There is no context-dependence (other than the

void Infinite_Recursion(int N)
{
Infinite_Recursion(N);
}

It is obvious that the above sequence is infinitely recursive.
If the halt decider aborts the second recursive call then the first
recursive call would halt. That the first recursive call halts does not indicate that it is a halting computation.

agreed encoding). There is no dispensation from "special" kinds of
halting.

Don't you think that having to have these sort of basic matter explained
to you, year in, year out, indicates that maybe you should be doing
something else?

YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY TRUE.

As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation then its
rejection of this input is necessarily correct and everything else in
the universe is totally irrelevant.



--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.math, sci.logic

On 3/27/2022 7:33 PM, Richard Damon wrote:

On 3/27/22 8:22 PM, olcott wrote:

On 3/27/2022 6:56 PM, Richard Damon wrote:

On 3/27/22 7:37 PM, olcott wrote:

On 3/27/2022 6:34 PM, Dennis Bush wrote:

On Sunday, March 27, 2022 at 7:26:34 PM UTC-4, olcott wrote:

On 3/27/2022 6:22 PM, Richard Damon wrote:

On 3/27/22 7:16 PM, olcott wrote:

On 3/27/2022 6:05 PM, Dennis Bush wrote:

On Sunday, March 27, 2022 at 6:55:02 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/27/2022 5:47 PM, Dennis Bush wrote:

On Sunday, March 27, 2022 at 6:43:43 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/27/2022 5:38 PM, Dennis Bush wrote:

On Sunday, March 27, 2022 at 6:12:47 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/27/2022 3:50 PM, Dennis Bush wrote:

On Sunday, March 27, 2022 at 4:40:59 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 3/27/2022 3:24 PM, Dennis Bush wrote:

On Sunday, March 27, 2022 at 3:35:17 PM UTC-4, olcott >>>>>>>>>>>>>>>>> wrote:

On 3/27/2022 2:23 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 3/27/22 2:56 PM, olcott wrote:

On 3/27/2022 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:44 PM, olcott wrote:

On 3/27/2022 1:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:22 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:17 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 1:44 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 11:20 AM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>

On 3/26/2022 7:30 PM, Ben Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>

what the correct answer for it is, is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> determined
solely by
whether or
not Ĥ halts on input ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>

That is not true.

You don't get to say what the halting problem >>>>>>>>>>>>>>>>>>>>>>>>>>> is.
It's already
been
specified.

Every string either represents a halting >>>>>>>>>>>>>>>>>>>>>>>>>>> computation or it does
not.
There is no context other than some prior agreed >>>>>>>>>>>>>>>>>>>>>>>>>>> encoding about
how a TM
and an input should be represented. A halt >>>>>>>>>>>>>>>>>>>>>>>>>>> decide
must accept
exactly
those strings that represent halting >>>>>>>>>>>>>>>>>>>>>>>>>>> computations.

The fact that you need to reject the very >>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the
problem is
clear evidence that you know that no TM is a >>>>>>>>>>>>>>>>>>>>>>>>>>> halt
decider.

This is true:

The directly executed Ĥ applied to ⟨Ĥ⟩ is the
first invocation of
infinite recursion that only terminates >>>>>>>>>>>>>>>>>>>>>>>>>>>> normally
because of its
one-way dependency relationship on embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>> aborting the second
invocation of this otherwise infinite >>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion.

It does not matter why the computation >>>>>>>>>>>>>>>>>>>>>>>>>>> represented
a particular
string
halts. You've been trying to pull this "it only >>>>>>>>>>>>>>>>>>>>>>>>>>> halts because"
nonsense
for years.

As long as the simulated input to embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>> could
never reach
its final state in any finite number of steps of >>>>>>>>>>>>>>>>>>>>>>>>>> correct
simulation then its rejection of this input is >>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
correct and everything else in the universe is >>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.

A halt decider must compute the mapping from its >>>>>>>>>>>>>>>>>>>>>>>>>> inputs (not
anything else in the universe besides it >>>>>>>>>>>>>>>>>>>>>>>>>> inputs) to
its own
accept or reject state based on the actual >>>>>>>>>>>>>>>>>>>>>>>>>> behavior
specified by
these actual inputs (not any behavior of anything >>>>>>>>>>>>>>>>>>>>>>>>>> else in the
universe).

We also know that the actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>> specified by
these inputs
must be the same as the behavior of the >>>>>>>>>>>>>>>>>>>>>>>>>> simulation
of N steps of
this input by a UTM. On this basis we know >>>>>>>>>>>>>>>>>>>>>>>>>> that any
behavior
that diverges from this behavior is not the >>>>>>>>>>>>>>>>>>>>>>>>>> correct
basis for
the halt status decision.

The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents some computation.

If it is simulated outside of Ĥ then it must have >>>>>>>>>>>>>>>>>>>>>>>>>> the same
behavior as Ĥ applied to ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>
If it is simulated inside of Ĥ then several >>>>>>>>>>>>>>>>>>>>>>>>>> steps of
Ĥ have
already been executed when this simulation >>>>>>>>>>>>>>>>>>>>>>>>>> begins thus
specifying a different sequence of configurations >>>>>>>>>>>>>>>>>>>>>>>>>> then when Ĥ
starts at its beginning.

I assume you have not
been deceiving us for years, and you know >>>>>>>>>>>>>>>>>>>>>>>>>>> that the
computation it
represents is Ĥ applied to the string ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>

When Ĥ is simulated in the middle of Ĥ this is >>>>>>>>>>>>>>>>>>>>>>>>>> different than
when Ĥ is simulated at the beginning of Ĥ. >>>>>>>>>>>>>>>>>>>>>>>>>>

That either is or is not a >>>>>>>>>>>>>>>>>>>>>>>>>>> halting computation. There is no >>>>>>>>>>>>>>>>>>>>>>>>>>> context-dependence
(other
than the

void Infinite_Recursion(int N) >>>>>>>>>>>>>>>>>>>>>>>>>> {
Infinite_Recursion(N);
}

It is obvious that the above sequence is >>>>>>>>>>>>>>>>>>>>>>>>>> infinitely
recursive.
If the halt decider aborts the second >>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
then the
first recursive call would halt. That the first >>>>>>>>>>>>>>>>>>>>>>>>>> recursive call
halts does not indicate that it is a halting >>>>>>>>>>>>>>>>>>>>>>>>>> computation.

agreed encoding). There is no dispensation from >>>>>>>>>>>>>>>>>>>>>>>>>>> "special"
kinds of
halting.

Don't you think that having to have these >>>>>>>>>>>>>>>>>>>>>>>>>>> sort of
basic matter
explained
to you, year in, year out, indicates that >>>>>>>>>>>>>>>>>>>>>>>>>>> maybe you
should be
doing
something else?

YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.
YOU ARE UNABLE TO GRASP THAT THIS IS NECESSARY >>>>>>>>>>>>>>>>>>>>>>>>>> TRUE.

As long as the simulated input to embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>> could
never reach
its final state in any finite number of steps of >>>>>>>>>>>>>>>>>>>>>>>>>> correct
simulation then its rejection of this input is >>>>>>>>>>>>>>>>>>>>>>>>>> necessarily
correct and everything else in the universe is >>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant.

No, YOU do not grasp that the definitions that >>>>>>>>>>>>>>>>>>>>>>>>> were
established
ARE the definitions you need to use, >>>>>>>>>>>>>>>>>>>>>>>>

Because a halt decider must compute the mapping >>>>>>>>>>>>>>>>>>>>>>>> from
its input
finite strings based on the actual behavior >>>>>>>>>>>>>>>>>>>>>>>> specified
by these
strings which is correctly measured by a correct >>>>>>>>>>>>>>>>>>>>>>>> simulation of N
steps of these strings you already know that I am >>>>>>>>>>>>>>>>>>>>>>>> correct.

Nope, wrong definition, wrong answer. >>>>>>>>>>>>>>>>>>>>>>>
Do you have a reference for adding the 'of N steps' >>>>>>>>>>>>>>>>>>>>>>> into the
definition?

N = "simulating it for as many steps as it will take" >>>>>>>>>>>>>>>>>>>>>

So might be infinite, and thus H fails to answer in >>>>>>>>>>>>>>>>>>>>> finite time.

You already that this is an infinite pattern: >>>>>>>>>>>>>>>>>>>>
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⟩...

Note, the ... notation means that you intend the >>>>>>>>>>>>>>>>>>> pattern to
keep on
repeating for ever, so you are SHOWING 3 steps, but >>>>>>>>>>>>>>>>>>> stateing that more
occur.

What I said, was that pattern only repeats infinity if >>>>>>>>>>>>>>>>>>> embedded_H never
aborts its simulation.

When embedded_H correctly computes the mapping from its >>>>>>>>>>>>>>>>>> input finite
strings ⟨Ĥ⟩ ⟨Ĥ⟩ to its own final reject state >>>>>>>>>>>>>>>>>

Which it doesn't, because Ĥ applied to ⟨Ĥ⟩ halts, and >>>>>>>>>>>>>>>>> that is
the behavior that embedded_H (and therefore H) is >>>>>>>>>>>>>>>>> stipulated
to answer about. So anything you say that follows doesn't >>>>>>>>>>>>>>>>> matter.

That is a common misconception. Please read my paper. >>>>>>>>>>>>>>>>
Halting problem undecidability and infinitely nested >>>>>>>>>>>>>>>> simulation (V4)

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

I've read it, and it's bogus. It says nothing more than what >>>>>>>>>>>>>>> you've been saying before.

To repeat:

When H3 correctly computes the mapping from its input finite >>>>>>>>>>>>>>> strings <N> <3> to its own final reject state
on the basis that there is
no finite number N of steps of correct simulation of this >>>>>>>>>>>>>>> input
by the
UTM within H3 then H3 has correctly decided that its >>>>>>>>>>>>>>> input never halts.

There is no H3, <N> or <3>. There is an ⟨Ĥ3⟩

Sure there is, I defined them earlier. But just so there's no >>>>>>>>>>>>> confusion with your ⟨Ĥ3⟩. I'll call it Ha3 instead. So Ha3 >>>>>>>>>>>>> uses
as its halt status criteria: simulate for 3 steps and abort. >>>>>>>>>>>> That is ridiculously stupid.

You might as well define counting to ten: 1,2,3 DONE.

So Ha3 is obviously wrong? What criteria do you use to
determine that?

That is an intentionally stupid question.

I want to hear your answer.  What criteria do you use to show that >>>>>>>>> Ha3 applied to <N><5> reporting non-halting is incorrect?

I take it that you want me to ignore everything you say.
This work is intended to be my legacy before I die.
If you just want to play head games go fornicate yourself.

The fact you have trouble with these simple questions shows how
bad your
logic is.

I told him that his question was just liked counting to ten: 1,2,3 >>>>>> DONE.

So in other words H3a is not simulating for enough steps?

TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its
final state in any finite number of steps of correct simulation by
embedded_H then its rejection of this input is necessarily correct.

Like, you need to use THE ACTUAL DEFINITION OF WHAT H IS SUPPOSED TO DO?

That is out-of-scope. You must find an error in my exact words and
explain why it is an error, otherwise we get stuck talking in circles
that are various shades of the strawman error.

The error in your words is that you don't use the right defintion of
Halting,

So in other words you disagree with Linz:

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)




--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)