XPost: comp.theory

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. We can also see that for evvery possible program
that could be put in as an (incorrect) H, that H^ (H^) will have a
specific behavior, just one that H doesn't give as its answer, thus the question about what it does is valid.

Most Humans can also tell that you logic is just broken and you have
been nothing but an ignorant pathological liar.

Your "Logic" just shows how little you understand about what you talk
about, and thus no one (with any intelegence) is apt to look into your
ideas about truth, as clearly you don't understand what truth actually is.

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