Re: Who here understands that the last paragraph is Necessarily true?

On 7/19/24 4:21 PM, olcott wrote:

On 7/19/2024 11:03 AM, joes wrote:

Am Fri, 19 Jul 2024 09:54:07 -0500 schrieb olcott:

On 7/19/2024 1:35 AM, Fred. Zwarts wrote:

Exactly the same input is presented to the direct execution and the
simulation, namely the x86 code of the program.
The semantics of the x86 language does not change in these two cases,
so a correct simulator should interpret the x86 in the same way as the
direct execution.

 No it is not.
Although you are the same person when you are hungry before
you eat after you eat you are no longer in the hungry state.
*Same person transitioning from hungry to not-hungry*
 

I may be the same person, but people, and there hunger state, and mutable and change with time.

Because or actions that HHH does DDD changes its state
from needing to be aborted to not needing to be aborted.

But Programs are fixed, and their "need to be aborted" is an UNCHANGING attribute.
In fact, you CAN'T ask a decider about a changeable attribute, because the map being computed does have time as an input.
So, you are just admitting that you are nothing but an ignorant liar.

 Same program transitioning from needing to be aborted
to not needing to be aborted.

How? Programs are unchangable code.

 

     Before HHH(DDD) aborts its emulation the directly executed DDD()
     cannot possibly halt.
     After HHH(DDD) aborts its emulation the directly executed DDD()
     halts.

What do you mean "after"? The outer DDD called by main? It will halt
even before HHH has aborted, because it is deterministic and actually
does halt. It makes no sense to say that something that will, couldn't.
>

 void DDD()
{
   HHH(DDD);
}
 int main()
{
   DDD();
}
 DDD() is invoked and calls HHH(DDD) that emulates its own
separate DDD instance as a separate process.
 Unless HHH(DDD) aborts its emulated DDD:
HHH, emulated DDD and executed DDD never stop running.
 

You keep on saying that, but you admit that HHH DOES abort its simulation (so it can be a decider) and returns, so it returns to DDD>
Yes, I think we all admit that you you make THE ONLY HHH to not abort, then NEITHER HHH or DDD return, and HHH failts to be a decider.
The problem is since HHH is given a DDD that class the HHH doing the deciding, HHH can't think that it can abort but the one used by DDD does.
You are just using incorrect logic based on your LYING about what the setup is.
You are just proving your total ignorance of the basics of programming.