Re: Who here is too stupid to know that DDD correctly simulated by HHH cannot possibly reach its own return instruction?

Op 03.aug.2024 om 16:26 schreef olcott:

On 8/3/2024 9:04 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:50 schreef olcott:

On 8/3/2024 3:14 AM, Fred. Zwarts wrote:

Op 02.aug.2024 om 22:57 schreef olcott:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?
>
void DDD()
{
   HHH(DDD);
   return;
}
>

>
Which proves that the simulation is incorrect.

>
When are you going to understand that you are not allowed
to disagree with the semantics of the x86 language?
>
>

>
I do not disagree.
When are you going to understand that it is a deviation of the semantics of the x86 language to skip instructions of a halting program,

 HHH(DDD) simulates DDD that calls HHH(DDD) to repeat the process.
 If it does this an infinite number of times the simulated DDD
never reaches its own return instruction.
 If it does this a googolplex number of times the simulated DDD
never reaches its own return instruction.

If HHH aborts and halts, it did it one cycle before the simulated HHH would halt and return.
If it would have simulated the *same* input one more cycle, it would have halted.
But i cannot simulate it one cycle longer, because it was programmed to abort after this number of cycles.
So, this HHH's simulation of *itself* is incorrect.

 If the simulation is ever aborted the simulated DDD never reaches
its own return instruction.

Only, because the simulation prevented to reach tat instruction, because it aborts prematurely.

 When we construe the halt state of DDD as its "return"
instruction then the simulated DD never halts.
 

That would be your dream of a HHH that does not halt.
But dreams are no substitute for facts.
HHH *does* abort after N cycles. When it does so, the simulated HHH has done only N-1 cycles. It needs one more cycle.
So, the simulation skipped the last cycle of a halting program, deviating from the semantics of the x86 language, which makes the simulation incorrect.
HHH cannot possibly simulate itself correctly.
It really is not that difficult to understand.