XPost: sci.logic

On 3/3/24 8:47 PM, olcott wrote:

On 3/3/2024 2:40 PM, Richard Damon wrote:

On 3/3/24 11:34 AM, olcott wrote:

On 3/3/2024 6:15 AM, Richard Damon wrote:

On 3/2/24 9:58 PM, olcott wrote:

On 3/2/2024 3:53 PM, Richard Damon wrote:

On 3/2/24 1:00 PM, olcott wrote:

On 3/2/2024 7:52 AM, Richard Damon wrote:

On 3/2/24 12:56 AM, olcott wrote:

<big snip>

Every C function that in any way simulates another C
function must use:
u32  DebugStep(Registers* master_state,
                Registers* slave_state,
      Decoded_Line_Of_Code* decoded) { return 0; }

Thus when the outermost decider aborts the simulation
of its input everything else that this virtual machine
invoked at ever recursive depth is no longer pumped by
DebugStep().

It is an empirically verified fact that when a simulator
stops simulating its own input that ever machine that
this machine invoked including recursive simulations
no longer has a process that is pumping each simulated
step.

of nested simulations that the inner ones no longer have
any machine simulating them.

In other words, you are admitting that your system mixes up the >>>>>>>> address space of the programs and doesn't actually create a
computation.

Note, a simulator aborting a simulation may stop the progress of >>>>>>>> the simulation, but not of the actual behavior of the program it >>>>>>>> is simulating.

THAT ALWAYS continues (mathematically) until it reaches a final >>>>>>>> state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
halt

When Ĥ.H sees that itself would never stop running unless
it aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ the directly executed >>>>>>> version of Ĥ.H sees this same thing. They both transition
to Ĥ.Hqn correctly preventing their own non-termination
and incorrectly deciding halting for ⟨Ĥ⟩ ⟨Ĥ⟩.

Right, so H^ (H^) will "determine" with H^.Hq0 (H^) (H^) that its
input is non-halting and go to qn and halt, thus H, which made
that decision, is wrong.

Remember, the question is does the computation described by the
input Halt, and it DOES, so the correct answer should have been
HALTING, and thus the non-halting answer was just WRONG and INCORRECT >>>>>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt

Humans can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.H
cannot possibly terminate unless this simulation is aborted.

Humans can also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does
abort its simulation then Ĥ will halt.

It seems quite foolish to believe that computers
cannot possibly ever see this too.

We are not "Computations", and in particular, we are not H.

And Yes, (if we are smart) we can see that there is no answer that H
can give and be correct.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt

We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ >>> that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.

H merely needs to correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ to see that Ĥ
applied to ⟨Ĥ⟩ halts.

Both H and Ĥ.H use the same algorithm that correctly detects
whether or not a correct simulation of their input would cause
their own infinite execution unless aborted.

Humans can see that this criteria derives different answers
for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

Nope. If H^.H aborts its simulation on some condition, then H sees
exactly the same conditions and will abort its simulation and give the
same wrong answer.

*With the infinite loop removed*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn

Execution trace of Ĥ applied to ⟨Ĥ⟩ *infinite loop removed*
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

Simulation invariant: ⟨Ĥ⟩ correctly simulated by Ĥ.H never
reaches its own simulated final state of ⟨Ĥ.Hqy⟩ or ⟨Ĥ.Hqn⟩

Execution trace of H applied to ⟨H⟩ ⟨H⟩
(a) H applied ⟨H⟩ ⟨H⟩ simulates ⟨H⟩ applied to ⟨H⟩
(b) Transitions to H.qy and halts.
*Because no copies are made it runs out of params*

This same reasoning applies to H ⟨Ĥ⟩ ⟨Ĥ⟩ because no
copies are made of any input H cannot possibly get
stuck in infinite simulation by any input.

In. other words, you are admitting you are a moroic idiot.

Why are you looking at H (H) (H).

It isn't "Given a description of yourself"

it is given the specificed input, which here is (H^) (H^).

So, you are just PROVING YOURSELF TO BE A BLOOMIONG IDIOT intentionally
trying to avoid the truth,

You apparently don't know what simple words like "the same" mean.

H (H^) (H^) MUST give transition to the same state as H^.H (H^) (H^) transistions to.

Both will see EXACTLY the same states in their simulation that they are
doing, so will act exactly alike.

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

XPost: sci.logic

On 3/3/24 10:03 PM, olcott wrote:

On 3/3/2024 8:24 PM, Richard Damon wrote:

On 3/3/24 8:47 PM, olcott wrote:

On 3/3/2024 2:40 PM, Richard Damon wrote:

On 3/3/24 11:34 AM, olcott wrote:

On 3/3/2024 6:15 AM, Richard Damon wrote:

On 3/2/24 9:58 PM, olcott wrote:

On 3/2/2024 3:53 PM, Richard Damon wrote:

On 3/2/24 1:00 PM, olcott wrote:

On 3/2/2024 7:52 AM, Richard Damon wrote:

On 3/2/24 12:56 AM, olcott wrote:

<big snip>

Every C function that in any way simulates another C
function must use:
u32  DebugStep(Registers* master_state,
                Registers* slave_state,
      Decoded_Line_Of_Code* decoded) { return 0; }

Thus when the outermost decider aborts the simulation
of its input everything else that this virtual machine
invoked at ever recursive depth is no longer pumped by
DebugStep().

It is an empirically verified fact that when a simulator >>>>>>>>>>> stops simulating its own input that ever machine that
this machine invoked including recursive simulations
no longer has a process that is pumping each simulated
step.

of nested simulations that the inner ones no longer have >>>>>>>>>>> any machine simulating them.

In other words, you are admitting that your system mixes up >>>>>>>>>> the address space of the programs and doesn't actually create >>>>>>>>>> a computation.

Note, a simulator aborting a simulation may stop the progress >>>>>>>>>> of the simulation, but not of the actual behavior of the
program it is simulating.

THAT ALWAYS continues (mathematically) until it reaches a
final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
not halt

When Ĥ.H sees that itself would never stop running unless
it aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ the directly executed >>>>>>>>> version of Ĥ.H sees this same thing. They both transition
to Ĥ.Hqn correctly preventing their own non-termination
and incorrectly deciding halting for ⟨Ĥ⟩ ⟨Ĥ⟩.

Right, so H^ (H^) will "determine" with H^.Hq0 (H^) (H^) that
its input is non-halting and go to qn and halt, thus H, which
made that decision, is wrong.

Remember, the question is does the computation described by the >>>>>>>> input Halt, and it DOES, so the correct answer should have been >>>>>>>> HALTING, and thus the non-halting answer was just WRONG and
INCORRECT

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
halt

Humans can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.H >>>>>>> cannot possibly terminate unless this simulation is aborted.

Humans can also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does
abort its simulation then Ĥ will halt.

It seems quite foolish to believe that computers
cannot possibly ever see this too.

We are not "Computations", and in particular, we are not H.

And Yes, (if we are smart) we can see that there is no answer that >>>>>> H can give and be correct.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt

We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>> that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.

H merely needs to correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ to see that Ĥ >>>>> applied to ⟨Ĥ⟩ halts.

Both H and Ĥ.H use the same algorithm that correctly detects
whether or not a correct simulation of their input would cause
their own infinite execution unless aborted.

Humans can see that this criteria derives different answers
for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

Nope. If H^.H aborts its simulation on some condition, then H sees
exactly the same conditions and will abort its simulation and give
the same wrong answer.

*With the infinite loop removed*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn

Execution trace of Ĥ applied to ⟨Ĥ⟩ *infinite loop removed*
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

Simulation invariant: ⟨Ĥ⟩ correctly simulated by Ĥ.H never
reaches its own simulated final state of ⟨Ĥ.Hqy⟩ or ⟨Ĥ.Hqn⟩

Execution trace of H applied to ⟨H⟩ ⟨H⟩
(a) H applied ⟨H⟩ ⟨H⟩ simulates ⟨H⟩ applied to ⟨H⟩
(b) Transitions to H.qy and halts.
*Because no copies are made it runs out of params*

This same reasoning applies to H ⟨Ĥ⟩ ⟨Ĥ⟩ because no
copies are made of any input H cannot possibly get
stuck in infinite simulation by any input.

In. other words, you are admitting you are a moroic idiot.

Why are you looking at H (H) (H).

You continue to fail to understand how and why
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets a different answer than H ⟨Ĥ⟩ ⟨Ĥ⟩.

Do you understand that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would get stuck in
infinite simulation if its simulated input was not aborted?

Do you understand that H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck
in infinite simulation?

HOW DO THEY DIFFER IF THEY ARE THE SAME COMPUTATION?

If they aren't, you have lied about your making of H^.


You are just ADMITTING to being a ignorant pathological liar.

The likely issue is that you have lier that H is a Computation in the
first place since you don't know what that is and have described the
code for H using information that isn't an input to it.

That means you have just been lying for years and NOTHING you have done
on this has any application to the Halting Problem.

Of course, you are to stupid and self-made ignorant of this to
understand the issue.

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

XPost: sci.logic

On 3/4/24 12:39 AM, olcott wrote:

On 3/3/2024 8:24 PM, Richard Damon wrote:

On 3/3/24 8:47 PM, olcott wrote:

On 3/3/2024 2:40 PM, Richard Damon wrote:

On 3/3/24 11:34 AM, olcott wrote:

On 3/3/2024 6:15 AM, Richard Damon wrote:

On 3/2/24 9:58 PM, olcott wrote:

On 3/2/2024 3:53 PM, Richard Damon wrote:

On 3/2/24 1:00 PM, olcott wrote:

On 3/2/2024 7:52 AM, Richard Damon wrote:

On 3/2/24 12:56 AM, olcott wrote:

<big snip>

Every C function that in any way simulates another C
function must use:
u32  DebugStep(Registers* master_state,
                Registers* slave_state,
      Decoded_Line_Of_Code* decoded) { return 0; }

Thus when the outermost decider aborts the simulation
of its input everything else that this virtual machine
invoked at ever recursive depth is no longer pumped by
DebugStep().

It is an empirically verified fact that when a simulator >>>>>>>>>>> stops simulating its own input that ever machine that
this machine invoked including recursive simulations
no longer has a process that is pumping each simulated
step.

of nested simulations that the inner ones no longer have >>>>>>>>>>> any machine simulating them.

In other words, you are admitting that your system mixes up >>>>>>>>>> the address space of the programs and doesn't actually create >>>>>>>>>> a computation.

Note, a simulator aborting a simulation may stop the progress >>>>>>>>>> of the simulation, but not of the actual behavior of the
program it is simulating.

THAT ALWAYS continues (mathematically) until it reaches a
final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
not halt

When Ĥ.H sees that itself would never stop running unless
it aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ the directly executed >>>>>>>>> version of Ĥ.H sees this same thing. They both transition
to Ĥ.Hqn correctly preventing their own non-termination
and incorrectly deciding halting for ⟨Ĥ⟩ ⟨Ĥ⟩.

Right, so H^ (H^) will "determine" with H^.Hq0 (H^) (H^) that
its input is non-halting and go to qn and halt, thus H, which
made that decision, is wrong.

Remember, the question is does the computation described by the >>>>>>>> input Halt, and it DOES, so the correct answer should have been >>>>>>>> HALTING, and thus the non-halting answer was just WRONG and
INCORRECT

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
halt

Humans can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.H >>>>>>> cannot possibly terminate unless this simulation is aborted.

Humans can also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does
abort its simulation then Ĥ will halt.

It seems quite foolish to believe that computers
cannot possibly ever see this too.

We are not "Computations", and in particular, we are not H.

And Yes, (if we are smart) we can see that there is no answer that >>>>>> H can give and be correct.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt

We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>> that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩.

H merely needs to correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ to see that Ĥ >>>>> applied to ⟨Ĥ⟩ halts.

Both H and Ĥ.H use the same algorithm that correctly detects
whether or not a correct simulation of their input would cause
their own infinite execution unless aborted.

Humans can see that this criteria derives different answers
for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

Nope. If H^.H aborts its simulation on some condition, then H sees
exactly the same conditions and will abort its simulation and give
the same wrong answer.

*With the infinite loop removed*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn

Execution trace of Ĥ applied to ⟨Ĥ⟩ *infinite loop removed*
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

Simulation invariant: ⟨Ĥ⟩ correctly simulated by Ĥ.H never
reaches its own simulated final state of ⟨Ĥ.Hqy⟩ or ⟨Ĥ.Hqn⟩

Execution trace of H applied to ⟨H⟩ ⟨H⟩
(a) H applied ⟨H⟩ ⟨H⟩ simulates ⟨H⟩ applied to ⟨H⟩
(b) Transitions to H.qy and halts.
*Because no copies are made it runs out of params*

This same reasoning applies to H ⟨Ĥ⟩ ⟨Ĥ⟩ because no
copies are made of any input H cannot possibly get
stuck in infinite simulation by any input.

In. other words, you are admitting you are a moroic idiot.

*I am not the one that can't answer a yes/no question*
Do you understand that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would get stuck in
infinite simulation if its simulated input was not aborted?

Of course, but that is beside the point of giving a CORRECT answer.

It seems you think a wrong answer can be correct, which is just incorrect.

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

XPost: sci.logic

On 3/4/24 3:01 PM, olcott wrote:

On 3/4/2024 6:23 AM, Richard Damon wrote:

On 3/4/24 12:39 AM, olcott wrote:

On 3/3/2024 8:24 PM, Richard Damon wrote:

On 3/3/24 8:47 PM, olcott wrote:

On 3/3/2024 2:40 PM, Richard Damon wrote:

On 3/3/24 11:34 AM, olcott wrote:

On 3/3/2024 6:15 AM, Richard Damon wrote:

On 3/2/24 9:58 PM, olcott wrote:

On 3/2/2024 3:53 PM, Richard Damon wrote:

On 3/2/24 1:00 PM, olcott wrote:

On 3/2/2024 7:52 AM, Richard Damon wrote:

On 3/2/24 12:56 AM, olcott wrote:

<big snip>

Every C function that in any way simulates another C >>>>>>>>>>>>> function must use:
u32  DebugStep(Registers* master_state,
                Registers* slave_state, >>>>>>>>>>>>>       Decoded_Line_Of_Code* decoded) { return 0; } >>>>>>>>>>>>>
Thus when the outermost decider aborts the simulation >>>>>>>>>>>>> of its input everything else that this virtual machine >>>>>>>>>>>>> invoked at ever recursive depth is no longer pumped by >>>>>>>>>>>>> DebugStep().

It is an empirically verified fact that when a simulator >>>>>>>>>>>>> stops simulating its own input that ever machine that >>>>>>>>>>>>> this machine invoked including recursive simulations >>>>>>>>>>>>> no longer has a process that is pumping each simulated >>>>>>>>>>>>> step.

of nested simulations that the inner ones no longer have >>>>>>>>>>>>> any machine simulating them.

In other words, you are admitting that your system mixes up >>>>>>>>>>>> the address space of the programs and doesn't actually >>>>>>>>>>>> create a computation.

Note, a simulator aborting a simulation may stop the
progress of the simulation, but not of the actual behavior >>>>>>>>>>>> of the program it is simulating.

THAT ALWAYS continues (mathematically) until it reaches a >>>>>>>>>>>> final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
not halt

When Ĥ.H sees that itself would never stop running unless >>>>>>>>>>> it aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ the directly executed >>>>>>>>>>> version of Ĥ.H sees this same thing. They both transition >>>>>>>>>>> to Ĥ.Hqn correctly preventing their own non-termination >>>>>>>>>>> and incorrectly deciding halting for ⟨Ĥ⟩ ⟨Ĥ⟩.

Right, so H^ (H^) will "determine" with H^.Hq0 (H^) (H^) that >>>>>>>>>> its input is non-halting and go to qn and halt, thus H, which >>>>>>>>>> made that decision, is wrong.

Remember, the question is does the computation described by >>>>>>>>>> the input Halt, and it DOES, so the correct answer should have >>>>>>>>>> been HALTING, and thus the non-halting answer was just WRONG >>>>>>>>>> and INCORRECT

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
not halt

Humans can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.H >>>>>>>>> cannot possibly terminate unless this simulation is aborted. >>>>>>>>>
Humans can also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does >>>>>>>>> abort its simulation then Ĥ will halt.

It seems quite foolish to believe that computers
cannot possibly ever see this too.

We are not "Computations", and in particular, we are not H.

And Yes, (if we are smart) we can see that there is no answer
that H can give and be correct.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
halt

We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩. >>>>>>>
H merely needs to correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ to see that Ĥ >>>>>>> applied to ⟨Ĥ⟩ halts.

Both H and Ĥ.H use the same algorithm that correctly detects
whether or not a correct simulation of their input would cause
their own infinite execution unless aborted.

Humans can see that this criteria derives different answers
for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

Nope. If H^.H aborts its simulation on some condition, then H sees >>>>>> exactly the same conditions and will abort its simulation and give >>>>>> the same wrong answer.

*With the infinite loop removed*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn

Execution trace of Ĥ applied to ⟨Ĥ⟩ *infinite loop removed*
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process >>>>>
Simulation invariant: ⟨Ĥ⟩ correctly simulated by Ĥ.H never
reaches its own simulated final state of ⟨Ĥ.Hqy⟩ or ⟨Ĥ.Hqn⟩ >>>>>
Execution trace of H applied to ⟨H⟩ ⟨H⟩
(a) H applied ⟨H⟩ ⟨H⟩ simulates ⟨H⟩ applied to ⟨H⟩
(b) Transitions to H.qy and halts.
*Because no copies are made it runs out of params*

This same reasoning applies to H ⟨Ĥ⟩ ⟨Ĥ⟩ because no
copies are made of any input H cannot possibly get
stuck in infinite simulation by any input.

In. other words, you are admitting you are a moroic idiot.

*I am not the one that can't answer a yes/no question*
Do you understand that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would get stuck in
infinite simulation if its simulated input was not aborted?

Of course,

*This is agreed to*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would get stuck in infinite simulation if its simulated input was not aborted.

I have to ask you these things one at a time or you get overwhelmed
and cannot put the components of this reasoning together.

Can you also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does abort its simulation then Ĥ will halt?

Yes, If the algorithm for the machine H (which is the same algorithm as
the submachibne H^.H) does not abort its simulation of this input, then
it will never halt. And thus that set of algorithms fail to be a
Decider, let alone a Halt Decider.

If the algorithm for the machine H (which is still the same algorithm as
the submachine H^.H) does abort its simulation of the input, and
transition to its reject state (qn), saying it decision of this input is non-halting, then H^ will end in the state qn and Halt, and thus that
set of algorithms fail to be a correct Halt Decider.

And lastly, if the algorithm for the machine H (which would still be the
same algorithm as the submachine H^.H) decides to abort its simulation
of the input, and knowing the other two answers were wrong, decides to
abort its simulation and accept the input (by going to qy), then H^ will
also end up at qy, and then transition into an infinite loop, agaim
showing that that H was not a correct decider.

Note, each of these cases creates a different H, and thus a DIFFERENT
machine H^ and thus a DIFFERENT input (H^) (H^) to give to that decider,
and thus each set is a DIFFERENT QUESTION, and all the cases HAVE
correct answers, so the Halting Question is shown to be valid.

It also shows that no decider can decide it, and thus it is
non-computable. (which for yes/no deciders is also called undecidable).

What's not to understand?

Your problem is you think that if you execute the exact same sequece of deterministic instructions on the exact same data, you can somehow get different results.

That, or you just don't care about facts, and are just showing yourself
to be an ignorant pathological lying idiot.

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

XPost: sci.logic

On 3/4/24 7:37 PM, olcott wrote:

On 3/4/2024 6:12 PM, Richard Damon wrote:

On 3/4/24 3:01 PM, olcott wrote:

On 3/4/2024 6:23 AM, Richard Damon wrote:

On 3/4/24 12:39 AM, olcott wrote:

On 3/3/2024 8:24 PM, Richard Damon wrote:

On 3/3/24 8:47 PM, olcott wrote:

On 3/3/2024 2:40 PM, Richard Damon wrote:

On 3/3/24 11:34 AM, olcott wrote:

On 3/3/2024 6:15 AM, Richard Damon wrote:

On 3/2/24 9:58 PM, olcott wrote:

On 3/2/2024 3:53 PM, Richard Damon wrote:

On 3/2/24 1:00 PM, olcott wrote:

On 3/2/2024 7:52 AM, Richard Damon wrote:

On 3/2/24 12:56 AM, olcott wrote:

<big snip>

Every C function that in any way simulates another C >>>>>>>>>>>>>>> function must use:
u32  DebugStep(Registers* master_state,
                Registers* slave_state, >>>>>>>>>>>>>>>       Decoded_Line_Of_Code* decoded) { return 0; } >>>>>>>>>>>>>>>
Thus when the outermost decider aborts the simulation >>>>>>>>>>>>>>> of its input everything else that this virtual machine >>>>>>>>>>>>>>> invoked at ever recursive depth is no longer pumped by >>>>>>>>>>>>>>> DebugStep().

It is an empirically verified fact that when a simulator >>>>>>>>>>>>>>> stops simulating its own input that ever machine that >>>>>>>>>>>>>>> this machine invoked including recursive simulations >>>>>>>>>>>>>>> no longer has a process that is pumping each simulated >>>>>>>>>>>>>>> step.

of nested simulations that the inner ones no longer have >>>>>>>>>>>>>>> any machine simulating them.

In other words, you are admitting that your system mixes >>>>>>>>>>>>>> up the address space of the programs and doesn't actually >>>>>>>>>>>>>> create a computation.

Note, a simulator aborting a simulation may stop the >>>>>>>>>>>>>> progress of the simulation, but not of the actual behavior >>>>>>>>>>>>>> of the program it is simulating.

THAT ALWAYS continues (mathematically) until it reaches a >>>>>>>>>>>>>> final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
does not halt

When Ĥ.H sees that itself would never stop running unless >>>>>>>>>>>>> it aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ the directly executed
version of Ĥ.H sees this same thing. They both transition >>>>>>>>>>>>> to Ĥ.Hqn correctly preventing their own non-termination >>>>>>>>>>>>> and incorrectly deciding halting for ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>

Right, so H^ (H^) will "determine" with H^.Hq0 (H^) (H^) >>>>>>>>>>>> that its input is non-halting and go to qn and halt, thus H, >>>>>>>>>>>> which made that decision, is wrong.

Remember, the question is does the computation described by >>>>>>>>>>>> the input Halt, and it DOES, so the correct answer should >>>>>>>>>>>> have been HALTING, and thus the non-halting answer was just >>>>>>>>>>>> WRONG and INCORRECT

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
not halt

Humans can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.H >>>>>>>>>>> cannot possibly terminate unless this simulation is aborted. >>>>>>>>>>>
Humans can also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does >>>>>>>>>>> abort its simulation then Ĥ will halt.

It seems quite foolish to believe that computers
cannot possibly ever see this too.

We are not "Computations", and in particular, we are not H. >>>>>>>>>>
And Yes, (if we are smart) we can see that there is no answer >>>>>>>>>> that H can give and be correct.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
not halt

We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩. >>>>>>>>>
H merely needs to correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ to see that Ĥ >>>>>>>>> applied to ⟨Ĥ⟩ halts.

Both H and Ĥ.H use the same algorithm that correctly detects >>>>>>>>> whether or not a correct simulation of their input would cause >>>>>>>>> their own infinite execution unless aborted.

Humans can see that this criteria derives different answers
for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

Nope. If H^.H aborts its simulation on some condition, then H
sees exactly the same conditions and will abort its simulation >>>>>>>> and give the same wrong answer.

*With the infinite loop removed*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn

Execution trace of Ĥ applied to ⟨Ĥ⟩ *infinite loop removed* >>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process >>>>>>>
Simulation invariant: ⟨Ĥ⟩ correctly simulated by Ĥ.H never >>>>>>> reaches its own simulated final state of ⟨Ĥ.Hqy⟩ or ⟨Ĥ.Hqn⟩ >>>>>>>
Execution trace of H applied to ⟨H⟩ ⟨H⟩
(a) H applied ⟨H⟩ ⟨H⟩ simulates ⟨H⟩ applied to ⟨H⟩ >>>>>>> (b) Transitions to H.qy and halts.
*Because no copies are made it runs out of params*

This same reasoning applies to H ⟨Ĥ⟩ ⟨Ĥ⟩ because no
copies are made of any input H cannot possibly get
stuck in infinite simulation by any input.

In. other words, you are admitting you are a moroic idiot.

*I am not the one that can't answer a yes/no question*
Do you understand that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would get stuck in
infinite simulation if its simulated input was not aborted?

Of course,

*This is agreed to*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would get stuck in infinite simulation if its
simulated input was not aborted.

I have to ask you these things one at a time or you get overwhelmed
and cannot put the components of this reasoning together.

Can you also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does abort its
simulation then Ĥ will halt?

<snip answer to wrong question>

If the algorithm for the machine H (which is still the same algorithm
as the submachine H^.H) does abort its simulation of the input, and
transition to its reject state (qn), saying it decision of this input
is non-halting, then H^ will end in the state qn and Halt, and thus
that set of algorithms fail to be a correct Halt Decider.

So simulating termination analyzer Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition
to Ĥ.Hqn or fail to halt.

And in doing so, gives the wrong answer, since then the input machine
WILL Halt.

When its sole criterion measure is to always say NO to every input
that would prevent it from halting then it must say NO to ⟨Ĥ⟩ ⟨Ĥ⟩.

So, your are admitting to using a strawman, and thus LYING about working
on the halting problem

When H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly uses this exact same criterion measure then the "abort simulation" criteria <is not> met thus providing
the correct basis for a different answer.

And thus your H is NOT a Halt Decider, and you are proved to be a
pathological liar, as you claim you have solving the Halting Problem.

You can't solve a problem by lying about it.

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

XPost: sci.logic

On 3/4/24 11:37 PM, olcott wrote:

On 3/4/2024 8:03 PM, Richard Damon wrote:

On 3/4/24 7:37 PM, olcott wrote:

On 3/4/2024 6:12 PM, Richard Damon wrote:

On 3/4/24 3:01 PM, olcott wrote:

On 3/4/2024 6:23 AM, Richard Damon wrote:

On 3/4/24 12:39 AM, olcott wrote:

On 3/3/2024 8:24 PM, Richard Damon wrote:

On 3/3/24 8:47 PM, olcott wrote:

On 3/3/2024 2:40 PM, Richard Damon wrote:

On 3/3/24 11:34 AM, olcott wrote:

On 3/3/2024 6:15 AM, Richard Damon wrote:

On 3/2/24 9:58 PM, olcott wrote:

On 3/2/2024 3:53 PM, Richard Damon wrote:

On 3/2/24 1:00 PM, olcott wrote:

On 3/2/2024 7:52 AM, Richard Damon wrote:

On 3/2/24 12:56 AM, olcott wrote:

<big snip>

Every C function that in any way simulates another C >>>>>>>>>>>>>>>>> function must use:
u32  DebugStep(Registers* master_state,
                Registers* slave_state, >>>>>>>>>>>>>>>>>       Decoded_Line_Of_Code* decoded) { return 0; } >>>>>>>>>>>>>>>>>
Thus when the outermost decider aborts the simulation >>>>>>>>>>>>>>>>> of its input everything else that this virtual machine >>>>>>>>>>>>>>>>> invoked at ever recursive depth is no longer pumped by >>>>>>>>>>>>>>>>> DebugStep().

It is an empirically verified fact that when a simulator >>>>>>>>>>>>>>>>> stops simulating its own input that ever machine that >>>>>>>>>>>>>>>>> this machine invoked including recursive simulations >>>>>>>>>>>>>>>>> no longer has a process that is pumping each simulated >>>>>>>>>>>>>>>>> step.

of nested simulations that the inner ones no longer have >>>>>>>>>>>>>>>>> any machine simulating them.

In other words, you are admitting that your system mixes >>>>>>>>>>>>>>>> up the address space of the programs and doesn't >>>>>>>>>>>>>>>> actually create a computation.

Note, a simulator aborting a simulation may stop the >>>>>>>>>>>>>>>> progress of the simulation, but not of the actual >>>>>>>>>>>>>>>> behavior of the program it is simulating.

THAT ALWAYS continues (mathematically) until it reaches >>>>>>>>>>>>>>>> a final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩
halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
does not halt

When Ĥ.H sees that itself would never stop running unless >>>>>>>>>>>>>>> it aborts its simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ the directly executed
version of Ĥ.H sees this same thing. They both transition >>>>>>>>>>>>>>> to Ĥ.Hqn correctly preventing their own non-termination >>>>>>>>>>>>>>> and incorrectly deciding halting for ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>

Right, so H^ (H^) will "determine" with H^.Hq0 (H^) (H^) >>>>>>>>>>>>>> that its input is non-halting and go to qn and halt, thus >>>>>>>>>>>>>> H, which made that decision, is wrong.

Remember, the question is does the computation described >>>>>>>>>>>>>> by the input Halt, and it DOES, so the correct answer >>>>>>>>>>>>>> should have been HALTING, and thus the non-halting answer >>>>>>>>>>>>>> was just WRONG and INCORRECT

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
does not halt

Humans can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.H >>>>>>>>>>>>> cannot possibly terminate unless this simulation is aborted. >>>>>>>>>>>>>
Humans can also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does >>>>>>>>>>>>> abort its simulation then Ĥ will halt.

It seems quite foolish to believe that computers
cannot possibly ever see this too.

We are not "Computations", and in particular, we are not H. >>>>>>>>>>>>
And Yes, (if we are smart) we can see that there is no >>>>>>>>>>>> answer that H can give and be correct.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
not halt

We can see that there is no answer that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
that corresponds to the actual behavior of Ĥ applied to ⟨Ĥ⟩. >>>>>>>>>>>
H merely needs to correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ to see that Ĥ
applied to ⟨Ĥ⟩ halts.

Both H and Ĥ.H use the same algorithm that correctly detects >>>>>>>>>>> whether or not a correct simulation of their input would cause >>>>>>>>>>> their own infinite execution unless aborted.

Humans can see that this criteria derives different answers >>>>>>>>>>> for Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ than for H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

Nope. If H^.H aborts its simulation on some condition, then H >>>>>>>>>> sees exactly the same conditions and will abort its simulation >>>>>>>>>> and give the same wrong answer.

*With the infinite loop removed*
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn

Execution trace of Ĥ applied to ⟨Ĥ⟩ *infinite loop removed* >>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H >>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

Simulation invariant: ⟨Ĥ⟩ correctly simulated by Ĥ.H never >>>>>>>>> reaches its own simulated final state of ⟨Ĥ.Hqy⟩ or ⟨Ĥ.Hqn⟩ >>>>>>>>>
Execution trace of H applied to ⟨H⟩ ⟨H⟩
(a) H applied ⟨H⟩ ⟨H⟩ simulates ⟨H⟩ applied to ⟨H⟩ >>>>>>>>> (b) Transitions to H.qy and halts.
*Because no copies are made it runs out of params*

This same reasoning applies to H ⟨Ĥ⟩ ⟨Ĥ⟩ because no >>>>>>>>> copies are made of any input H cannot possibly get
stuck in infinite simulation by any input.

In. other words, you are admitting you are a moroic idiot.

*I am not the one that can't answer a yes/no question*
Do you understand that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would get stuck in >>>>>>> infinite simulation if its simulated input was not aborted?

Of course,

*This is agreed to*
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would get stuck in infinite simulation if its >>>>> simulated input was not aborted.

I have to ask you these things one at a time or you get overwhelmed
and cannot put the components of this reasoning together.

Can you also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does abort its >>>>> simulation then Ĥ will halt?

<snip answer to wrong question>

If the algorithm for the machine H (which is still the same
algorithm as the submachine H^.H) does abort its simulation of the
input, and transition to its reject state (qn), saying it decision
of this input is non-halting, then H^ will end in the state qn and
Halt, and thus that set of algorithms fail to be a correct Halt
Decider.

So simulating termination analyzer Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must transition >>> to Ĥ.Hqn or fail to halt.

And in doing so, gives the wrong answer, since then the input machine
WILL Halt.

Yes that is correct Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is wrong about Ĥ ⟨Ĥ⟩ yet Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does correctly transition to Ĥ.Hqn indicating
that its "abort criteria" has been met.

In other words, you are just admitting about LYING about working on the
HALTING PROBLEM.

When its sole criterion measure is to always say NO to every input
that would prevent it from halting then it must say NO to ⟨Ĥ⟩ ⟨Ĥ⟩.

So, your are admitting to using a strawman, and thus LYING about
working on the halting problem

Not at all. When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is defined to be contradicted
by Ĥ then the best that it can do is correctly report
that its abort criteria has been met.

In other words, you ADMIT that the HALTING THEOREM is correct.

The gives Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ a correct basis to transition to H.qy.
When Ĥ and H are distinct P's in the same a RASP machine
and every P can determine its own machine address then it
becomes easy for Ĥ to see that it must abort its simulation
and easy for H to see that it need not abort its simulation.

But it CAN'T, unless you are LYING that they are using the same
alrgorithm for the H sub-machine.

You are just proving you are a stupid ignronat pathological lying idiot.

Note, a RASP machine is a SINGLE PROGRAM.

When H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly uses this exact same criterion measure >>> then the "abort simulation" criteria <is not> met thus providing
the correct basis for a different answer.

And thus your H is NOT a Halt Decider, and you are proved to be a
pathological liar, as you claim you have solving the Halting Problem.

You can't solve a problem by lying about it.

Challenging the foundation assumptions of computer science
is not lying. If a RASP machine such that every P can determine
its own address solves halting then Church/Turing also
seems to be refuted.

If provability can be construed as "a function on the natural
numbers" then halting can also be so construed.

Right, and not all functions on the natural numbers are computable.

Simple to see, as there are aleph-1 functions on the natural numbers but
only aleph-0 possible computations.

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