Re: Defining a correct simulating halt decider

On 9/3/24 4:25 PM, olcott wrote:

On 9/3/2024 2:01 PM, joes wrote:

Am Tue, 03 Sep 2024 13:40:08 -0500 schrieb olcott:

On 9/3/2024 9:42 AM, joes wrote:

Am Mon, 02 Sep 2024 16:06:24 -0500 schrieb olcott:

On 9/2/2024 12:52 PM, Fred. Zwarts wrote:

Op 02.sep.2024 om 18:38 schreef olcott:

A halt decider is a Turing machine that computes the mapping from
its finite string input to the behavior that this finite string
specifies.
If the finite string machine string machine description specifies
that it cannot possibly reach its own final halt state then this
machine description specifies non-halting behavior.

Which DDD does not.

DDD emulated by HHH cannot possibly reach its final halt state no matter
what HHH does.

But DDD halts, so it „specifies halting behaviour”.
HHH can’t simulate itself.
>

 HHH does simulate itself simulating DDD
why do you insist on lying about this?
 https://github.com/plolcott/x86utm/blob/master/Halt7.c

But then it either IGNORES that simulation or lies about what it sees, as it claims that there were no condition instructions in the code is emulated when there were.
Sorry, but ignoring the facts of the emulation doesn't make a "correct emulation", (or at least incorrect logic)

 

A halt decider never ever computes the mapping for the computation
that itself is contained within.

Then it is not total.

Yes it is you are wrong.

How? It should work for all inputs.
>

Unless there is a pathological relationship between the halt decider
H and its input D the direct execution of this input D will always
have identical behavior to D correctly simulated by simulating halt
decider H.

Which makes this pathological input a counterexample.

Which makes the pathological input a counter-example to the false
assumption that the direct execution of a machine always has the same
behavior as the machine simulated by its pathological simulator.

… a counterexample to the false assumption that a decider exists.
>

A correct emulation of DDD by HHH only requires that HHH emulate the
instructions of DDD** including when DDD calls HHH in recursive
emulation such that HHH emulates itself emulating DDD.

Indeed, it should simulate *itself* and not a hypothetical other HHH
with different behaviour.

It is emulating the exact same freaking machine code that the x86utm
operating system is emulating.

It is not simulating the abort because of a static variable. Why?

void DDD()
{
    HHH(DDD);
    OutputString("This code is unreachable by DDD emulated by HHH");
}

I don’t understand what this is supposed to explain? The output is
clearly wrong, as evidenced by actually running HHH on it.
>

If HHH includes code to see a 'special condition' and aborts and
halts,
then it should also simulate the HHH that includes this same code and

DDD has itself and the emulated HHH stuck in recursive emulation.

Your HHH incorrectly changes behaviour.

No you are wrong !!!

Have you fixed the Root bug?
>