XPost: sci.logic

On 1/27/24 17:06, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   D(D);
12 }

*Execution Trace*
Line 11: main() invokes D(D);
Line 03: D(D) invokes H(D,D) that simulates D(D)

*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.

D correctly simulated by H cannot possibly reach its simulated final
state in 1 to ∞ steps of correct simulation.

*Every computation that only stops running because some steps of this*
*same computation had to be aborted to prevent the infinite execution*
*of this computation is a computation that does not halt*

Because D specifies that it calls H(D,D) in recursive simulation and H
must abort this recursive simulation to prevent the infinite execution
of directly executed D(D) we know that D(D) does not actually halt even though it really looks like it does.

Within the Turing Machine model of computation only UTM simulations can
be aborted, direct executions cannot be aborted.

*Dishonest straw man*
You are dishonestly pretending that the directly executed D(D) is
simulated by H.

If you kill John does it kill his identical twin brother?

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

XPost: sci.logic

On 1/27/24 17:50, olcott wrote:

On 1/27/2024 10:45 AM, immibis wrote:

On 1/27/24 17:06, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   D(D);
12 }

*Execution Trace*
Line 11: main() invokes D(D);
Line 03: D(D) invokes H(D,D) that simulates D(D)

*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.

D correctly simulated by H cannot possibly reach its simulated final
state in 1 to ∞ steps of correct simulation.

*Every computation that only stops running because some steps of this*
*same computation had to be aborted to prevent the infinite execution*
*of this computation is a computation that does not halt*

Because D specifies that it calls H(D,D) in recursive simulation and H
must abort this recursive simulation to prevent the infinite execution
of directly executed D(D) we know that D(D) does not actually halt even
though it really looks like it does.

Within the Turing Machine model of computation only UTM simulations can
be aborted, direct executions cannot be aborted.

*Dishonest straw man*
You are dishonestly  pretending that the directly executed D(D) is
simulated by H.

*Not at all, you merely did not pay close enough attention*

The directly executed D(D) never halts unless the recursive
simulation that it specifies in its call to H(D,D) has been
aborted by H.

So John never says hello unless his identical twin Jake dies. When Jake
dies, you think John cannot say hello because John is dead.

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

XPost: sci.logic

On 1/27/24 11:45 AM, immibis wrote:

On 1/27/24 17:06, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   D(D);
12 }

*Execution Trace*
Line 11: main() invokes D(D);
Line 03: D(D) invokes H(D,D) that simulates D(D)

*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.

D correctly simulated by H cannot possibly reach its simulated final
state in 1 to ∞ steps of correct simulation.

*Every computation that only stops running because some steps of this*
*same computation had to be aborted to prevent the infinite execution*
*of this computation is a computation that does not halt*

Because D specifies that it calls H(D,D) in recursive simulation and H
must abort this recursive simulation to prevent the infinite execution
of directly executed D(D) we know that D(D) does not actually halt even
though it really looks like it does.

Within the Turing Machine model of computation only UTM simulations can
be aborted, direct executions cannot be aborted.

*Dishonest straw man*
You are dishonestly  pretending that the directly executed D(D) is
simulated by H.

If you kill John does it kill his identical twin brother?

If H isn't doing that, then how do you expect H to get the right answer,
since that is the DEFINITION of the question it is being asked?

"Does the program/input described by the input Halt when run?"

or, does PO-Computation Theory not include the fact that identical
copies of programs given identical inputs will return the identical
answers? That is sort of a fundamental part of Computation Theory.

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

XPost: sci.logic

On 1/27/24 11:06 AM, olcott wrote:

01 int D(ptr x)  // ptr is pointer to int function
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   D(D);
12 }

*Execution Trace*
Line 11: main() invokes D(D);
Line 03: D(D) invokes H(D,D) that simulates D(D)

*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.

D correctly simulated by H cannot possibly reach its simulated final
state in 1 to ∞ steps of correct simulation.

*Every computation that only stops running because some steps of this*
*same computation had to be aborted to prevent the infinite execution*
*of this computation is a computation that does not halt*

Because D specifies that it calls H(D,D) in recursive simulation and H
must abort this recursive simulation to prevent the infinite execution
of directly executed D(D) we know that D(D) does not actually halt even though it really looks like it does.

Within the Turing Machine model of computation only UTM simulations can
be aborted, direct executions cannot be aborted.

And nothing needed to (or could) abort any of the steps of the directly executed D(D) that calls an H(D,D) that aborts its simulation of ITS
COPY of the program D(D).

You show your misunderstand by saying a UTM simulation can be aborted,
as a UTM, by defintion, will not abort its simulation.

A partial UTMish simulation might be aborted, but such a simulation is
NOT a "Correct Simulation" per the theory that lets you use a simulation
as a replacement for direct execution, and so is irrelevent.

You might be able, in some cases, to use the information from a partial
UTMish simulation to prove that the ACTUAL UTM simulation of the input
would never halt, but it turns out you can't in this case.

If H(D,D) aborts its simulation and returns 0, then it could not have
correctly determined that the UTM simulation of this input would not
halt, as it will, as D(D) (which is based on the H that gives the
claimed right answer) will call its exact copy of this H(D,D) which WILL
return 0, and this D(D) will Halt, and thus a "Correct Simulation" of
this input will halt.

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

XPost: sci.logic

On 1/27/24 17:52, olcott wrote:

On 1/27/2024 10:50 AM, olcott wrote:

The directly executed D(D) never *stops running* unless the
recursive simulation that it specifies in its call to H(D,D)
has been aborted by H.

That's a different computation

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

XPost: sci.logic

On 1/27/24 20:10, olcott wrote:

On 1/27/2024 12:08 PM, immibis wrote:

On 1/27/24 17:52, olcott wrote:

On 1/27/2024 10:50 AM, olcott wrote:

The directly executed D(D) never *stops running* unless the
recursive simulation that it specifies in its call to H(D,D)
has been aborted by H.

That's a different computation

*D specifies that it calls H(D,D) in recursive simulation*
A thing is not different than itself.

A simulation is different than a direct execution.

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

XPost: sci.logic

On 1/27/24 20:21, olcott wrote:

On 1/27/2024 1:19 PM, immibis wrote:

On 1/27/24 20:10, olcott wrote:

On 1/27/2024 12:08 PM, immibis wrote:

On 1/27/24 17:52, olcott wrote:

On 1/27/2024 10:50 AM, olcott wrote:

The directly executed D(D) never *stops running* unless the
recursive simulation that it specifies in its call to H(D,D)
has been aborted by H.

That's a different computation

*D specifies that it calls H(D,D) in recursive simulation*
A thing is not different than itself.

A simulation is different than a direct execution.

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

That a simulation does not halt if it is not aborted only proves that
the simulation does not halt.

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

XPost: sci.logic

On 1/27/24 4:31 PM, olcott wrote:

On 1/27/2024 2:44 PM, immibis wrote:

On 1/27/24 20:21, olcott wrote:

On 1/27/2024 1:19 PM, immibis wrote:

On 1/27/24 20:10, olcott wrote:

On 1/27/2024 12:08 PM, immibis wrote:

On 1/27/24 17:52, olcott wrote:

On 1/27/2024 10:50 AM, olcott wrote:

The directly executed D(D) never *stops running* unless the
recursive simulation that it specifies in its call to H(D,D)
has been aborted by H.

That's a different computation

*D specifies that it calls H(D,D) in recursive simulation*
A thing is not different than itself.

A simulation is different than a direct execution.

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

That a simulation does not halt if it is not aborted only proves that
the simulation does not halt.

*It proves that behavior specified by the input DOES NOT HALT*
*It proves that behavior specified by the input DOES NOT HALT*
*It proves that behavior specified by the input DOES NOT HALT*

NOPE. Not by the REAL definition.

The CORRECT simulation, as well as the DIRECT EXECTION of the input of D
built on the H that aborts, shows D(D) calling H(D,D), then that H(D,D) aborting it simulation (since you are claim that it is ok for H to
abort in this case, and it does) and then returning to D(D) and it halting.

If you DEFINE H to not abort, then yes, the input D is non-halting, but
that H can't abort its simulation as it wss defined to be non-aborting.

So, the ONLY H that is "allowed" to abort its simulation because its
input is non-halting is also the H that was defined not to do it.

Any H that tries to take that option, is shown to have an input that
actually did halt and would have completed the correct simulation if the
input was given to a real correct simulator. (You can't use this H to do
that, as it always aborts its input).

You run into the problem that since D is defined to call the H that you
claim to get the right answer, that H can't use the results of an H
simulating a DIFFERENT D based on a DIFFERENT H.

You are just caught it the trap of not defining programs correctly.

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

XPost: sci.logic

On 1/27/24 5:28 PM, olcott wrote:

On 1/27/2024 4:06 PM, Richard Damon wrote:

On 1/27/24 4:31 PM, olcott wrote:

On 1/27/2024 2:44 PM, immibis wrote:

On 1/27/24 20:21, olcott wrote:

On 1/27/2024 1:19 PM, immibis wrote:

On 1/27/24 20:10, olcott wrote:

On 1/27/2024 12:08 PM, immibis wrote:

On 1/27/24 17:52, olcott wrote:

On 1/27/2024 10:50 AM, olcott wrote:

The directly executed D(D) never *stops running* unless the
recursive simulation that it specifies in its call to H(D,D) >>>>>>>>> has been aborted by H.

That's a different computation

*D specifies that it calls H(D,D) in recursive simulation*
A thing is not different than itself.

A simulation is different than a direct execution.

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

That a simulation does not halt if it is not aborted only proves
that the simulation does not halt.

*It proves that behavior specified by the input DOES NOT HALT*
*It proves that behavior specified by the input DOES NOT HALT*
*It proves that behavior specified by the input DOES NOT HALT*

NOPE. Not by the REAL definition.

Halt deciders were always required to report on the behavior
that their input specifies and D specifies recursive simulation
to H. *Alternative understandings have always been misconceptions*

No, D specifies FINITE recursion to an H that aborts its simulation.

FINITE recursion is not non-halting.

Yes, if you define your H to not abort, then D specifies non-halting
behavior to a "decider" that fails to answer, and thus isn't a decider.

If H aborts its simulation and returns a value, D specifies behavior
based on that return value.

Your H makes an error by not understanding that the H it is seeing
called is EXACTLY like it, so if this H aborts, so does the H being called.

REALITY IS REALITY, you can't look at a fantasy that isn't what actually happens.

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

XPost: sci.logic

On 1/27/24 5:56 PM, olcott wrote:

On 1/27/2024 4:46 PM, Richard Damon wrote:

On 1/27/24 5:28 PM, olcott wrote:

On 1/27/2024 4:06 PM, Richard Damon wrote:

On 1/27/24 4:31 PM, olcott wrote:

On 1/27/2024 2:44 PM, immibis wrote:

On 1/27/24 20:21, olcott wrote:

On 1/27/2024 1:19 PM, immibis wrote:

On 1/27/24 20:10, olcott wrote:

On 1/27/2024 12:08 PM, immibis wrote:

On 1/27/24 17:52, olcott wrote:

On 1/27/2024 10:50 AM, olcott wrote:

The directly executed D(D) never *stops running* unless the >>>>>>>>>>> recursive simulation that it specifies in its call to H(D,D) >>>>>>>>>>> has been aborted by H.

That's a different computation

*D specifies that it calls H(D,D) in recursive simulation*
A thing is not different than itself.

A simulation is different than a direct execution.

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

That a simulation does not halt if it is not aborted only proves
that the simulation does not halt.

*It proves that behavior specified by the input DOES NOT HALT*
*It proves that behavior specified by the input DOES NOT HALT*
*It proves that behavior specified by the input DOES NOT HALT*

NOPE. Not by the REAL definition.

Halt deciders were always required to report on the behavior
that their input specifies and D specifies recursive simulation
to H. *Alternative understandings have always been misconceptions*

No, D specifies FINITE recursion to an H that aborts its simulation.

FINITE recursion is not non-halting.

The key fact that H(D,D) only halts when H aborts its simulation
of D conclusively proves that D DOES NOT HALT. Aborted simulations
do not count as D halting.

Nope.

H aborted a DIFFERENT instnace of D, The D that calls H halts because of
this. That D was not being "simulated" and thus wasn't aborted.

This shows that H was INCORRECT in its decision to abort.

Yes, H aborting its simulation doesn't, by itself, say the input is
Halting, as the simulation didn't reach a final state. It didn't also
show that an unbounded number of steps of simulation by a correct
simulation wouldn't halt (rememver, D calls the H that does what the H
that you claim gave the right aswer does, which is abort it simulation).

The fact that this correct simulation isn't done by H doesn't affect the
fact that the correct simulation shows that the direct execution halts.

You keep on confusing different things thinking they are the same,

This could be a sign of mental problems, or could just be signs of
stupidity.

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

XPost: sci.logic

On 1/27/24 6:51 PM, olcott wrote:

On 1/27/2024 5:40 PM, Richard Damon wrote:

On 1/27/24 5:56 PM, olcott wrote:

On 1/27/2024 4:46 PM, Richard Damon wrote:

On 1/27/24 5:28 PM, olcott wrote:

On 1/27/2024 4:06 PM, Richard Damon wrote:

On 1/27/24 4:31 PM, olcott wrote:

On 1/27/2024 2:44 PM, immibis wrote:

On 1/27/24 20:21, olcott wrote:

On 1/27/2024 1:19 PM, immibis wrote:

On 1/27/24 20:10, olcott wrote:

On 1/27/2024 12:08 PM, immibis wrote:

On 1/27/24 17:52, olcott wrote:

On 1/27/2024 10:50 AM, olcott wrote:

The directly executed D(D) never *stops running* unless the >>>>>>>>>>>>> recursive simulation that it specifies in its call to H(D,D) >>>>>>>>>>>>> has been aborted by H.

That's a different computation

*D specifies that it calls H(D,D) in recursive simulation* >>>>>>>>>>> A thing is not different than itself.

A simulation is different than a direct execution.

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

That a simulation does not halt if it is not aborted only proves >>>>>>>> that the simulation does not halt.

*It proves that behavior specified by the input DOES NOT HALT*
*It proves that behavior specified by the input DOES NOT HALT*
*It proves that behavior specified by the input DOES NOT HALT*

NOPE. Not by the REAL definition.

Halt deciders were always required to report on the behavior
that their input specifies and D specifies recursive simulation
to H. *Alternative understandings have always been misconceptions*

No, D specifies FINITE recursion to an H that aborts its simulation.

FINITE recursion is not non-halting.

The key fact that H(D,D) only halts when H aborts its simulation
of D conclusively proves that D DOES NOT HALT. Aborted simulations
do not count as D halting.

Nope.

H aborted a DIFFERENT instnace of D,

I don't believe that you actually believe that the levels
of recursive simulation in the same recursive simulation
chain are separate instances.

That would be the same as believing that infinite recursion
is not infinite because each call has a different stack frame.

Nope.

The the fact that H aborts its simulation has ZERO errect on any caller
of it. Thus H(D,D) aborting its simulation of D(D) does not affect the
direct execution of D(D) that calls that H.

Please show how it does.

Note, your thought of equivalence of simulation to execution only apply
to UNCONDITIONAL simulation, the fact that an outer layer of simulation
can see in to the behavior of the inner layers is different than with
calls, where the other level are "inert" while the inner layers are running.

If an outer layer aborts, that makes all the inner layers just
disappear, but doesn't affect any layers outside of it, except by what
it returns to them.

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

XPost: sci.logic

On 1/27/24 7:35 PM, olcott wrote:

On 1/27/2024 6:15 PM, Richard Damon wrote:

On 1/27/24 6:51 PM, olcott wrote:

On 1/27/2024 5:40 PM, Richard Damon wrote:

On 1/27/24 5:56 PM, olcott wrote:

On 1/27/2024 4:46 PM, Richard Damon wrote:

On 1/27/24 5:28 PM, olcott wrote:

On 1/27/2024 4:06 PM, Richard Damon wrote:

On 1/27/24 4:31 PM, olcott wrote:

On 1/27/2024 2:44 PM, immibis wrote:

On 1/27/24 20:21, olcott wrote:

On 1/27/2024 1:19 PM, immibis wrote:

On 1/27/24 20:10, olcott wrote:

On 1/27/2024 12:08 PM, immibis wrote:

On 1/27/24 17:52, olcott wrote:

On 1/27/2024 10:50 AM, olcott wrote:

The directly executed D(D) never *stops running* unless the >>>>>>>>>>>>>>> recursive simulation that it specifies in its call to H(D,D) >>>>>>>>>>>>>>> has been aborted by H.

That's a different computation

*D specifies that it calls H(D,D) in recursive simulation* >>>>>>>>>>>>> A thing is not different than itself.

A simulation is different than a direct execution.

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

That a simulation does not halt if it is not aborted only
proves that the simulation does not halt.

*It proves that behavior specified by the input DOES NOT HALT* >>>>>>>>> *It proves that behavior specified by the input DOES NOT HALT* >>>>>>>>> *It proves that behavior specified by the input DOES NOT HALT* >>>>>>>>>

NOPE. Not by the REAL definition.

Halt deciders were always required to report on the behavior
that their input specifies and D specifies recursive simulation
to H. *Alternative understandings have always been misconceptions* >>>>>>>

No, D specifies FINITE recursion to an H that aborts its simulation. >>>>>>
FINITE recursion is not non-halting.

The key fact that H(D,D) only halts when H aborts its simulation
of D conclusively proves that D DOES NOT HALT. Aborted simulations
do not count as D halting.

Nope.

H aborted a DIFFERENT instnace of D,

I don't believe that you actually believe that the levels
of recursive simulation in the same recursive simulation
chain are separate instances.

That would be the same as believing that infinite recursion
is not infinite because each call has a different stack frame.

Nope.

The the fact that H aborts its simulation has ZERO errect on any
caller of it. Thus H(D,D) aborting its simulation of D(D) does not
affect the direct execution of D(D) that calls that H.

So in other words you are claiming to be too stupid to understand
that unless H every H that can possibly exist aborts its simulated D
that neither H nor directly executed D would ever stop running?

No, I am claiming that YOU are too stupid to understand that programs do
what they are programmed to do.

Thus any H that was programmed to abort, is given a D that calls a copy
of that H, and that input, if correctly simulated (which H doesn't do
since it aborts) will reach a terminal state,

The only ground for H to correctly abort is if it can prove that a
correct simulation of its input would be non-halting.

Since a correct simulation of its input Halted, H does not have the
needed facts to make its aborting correct.

IF you want to try to justify based on "ITS" correct simulation, then NO
H can correctly abort, as no H that aborts mets the requirement of doing
a correct simulation.

Your inability to see this just proves you are too stupid (perhaps intentionally made so) to understand the basics of Programs.

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

XPost: sci.logic

On 1/28/24 01:35, olcott wrote:

On 1/27/2024 6:15 PM, Richard Damon wrote:

On 1/27/24 6:51 PM, olcott wrote:

On 1/27/2024 5:40 PM, Richard Damon wrote:

On 1/27/24 5:56 PM, olcott wrote:

On 1/27/2024 4:46 PM, Richard Damon wrote:

On 1/27/24 5:28 PM, olcott wrote:

On 1/27/2024 4:06 PM, Richard Damon wrote:

On 1/27/24 4:31 PM, olcott wrote:

On 1/27/2024 2:44 PM, immibis wrote:

On 1/27/24 20:21, olcott wrote:

On 1/27/2024 1:19 PM, immibis wrote:

On 1/27/24 20:10, olcott wrote:

On 1/27/2024 12:08 PM, immibis wrote:

On 1/27/24 17:52, olcott wrote:

On 1/27/2024 10:50 AM, olcott wrote:

The directly executed D(D) never *stops running* unless the >>>>>>>>>>>>>>> recursive simulation that it specifies in its call to H(D,D) >>>>>>>>>>>>>>> has been aborted by H.

That's a different computation

*D specifies that it calls H(D,D) in recursive simulation* >>>>>>>>>>>>> A thing is not different than itself.

A simulation is different than a direct execution.

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

*The direct execution of D(D) specifies*
*that it calls H(D,D) in recursive simulation*

That a simulation does not halt if it is not aborted only
proves that the simulation does not halt.

*It proves that behavior specified by the input DOES NOT HALT* >>>>>>>>> *It proves that behavior specified by the input DOES NOT HALT* >>>>>>>>> *It proves that behavior specified by the input DOES NOT HALT* >>>>>>>>>

NOPE. Not by the REAL definition.

Halt deciders were always required to report on the behavior
that their input specifies and D specifies recursive simulation
to H. *Alternative understandings have always been misconceptions* >>>>>>>

No, D specifies FINITE recursion to an H that aborts its simulation. >>>>>>
FINITE recursion is not non-halting.

The key fact that H(D,D) only halts when H aborts its simulation
of D conclusively proves that D DOES NOT HALT. Aborted simulations
do not count as D halting.

Nope.

H aborted a DIFFERENT instnace of D,

I don't believe that you actually believe that the levels
of recursive simulation in the same recursive simulation
chain are separate instances.

That would be the same as believing that infinite recursion
is not infinite because each call has a different stack frame.

Nope.

The the fact that H aborts its simulation has ZERO errect on any
caller of it. Thus H(D,D) aborting its simulation of D(D) does not
affect the direct execution of D(D) that calls that H.

So in other words you are claiming to be too stupid to understand
that unless H every H that can possibly exist aborts its simulated D
that neither H nor directly executed D would ever stop running?

Every H that can possibly exist is a hippopotamous because no H can
possibly exist.

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