Re: Defining a correct simulating halt decider

On 9/4/24 9:04 AM, olcott wrote:

On 9/4/2024 4:34 AM, Fred. Zwarts wrote:

Op 03.sep.2024 om 20:40 schreef 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.
>

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.
>

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 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");
}
>

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 !!!
>

>
Yes it does. HHH simulates only a few recursions, then it sees a 'special condition', stops the simulation, returns to DDD and DDD halts.

 void DDD()
{
   HHH(DDD); // Fred lacks the software engineering skill to understand
   OutputString("This code is unreachable from DDD emulated by HHH");
}
 

But, sincd that DDD *IS* the DDD emulated by HHH, and when we directly run it, which is what the "behavior of DDD" MEANS, we reach that statement. thus proving you are nothing but a lying idiot that refuses to learn the meaning of the words he is using because that would make him see he is wrong.
Only IDIOTS refuse to learn to avoid being proved wrong, SMART people understand what they don't understand and learn from their mistakes, which is the exact opposite of what you do.