Re: Who knows that DDD correctly simulated by HHH cannot possibly reach its own return instruction final state?

On 8/3/24 12:35 PM, olcott wrote:

On 8/3/2024 11:32 AM, Richard Damon wrote:

On 8/3/24 12:16 PM, olcott wrote:

On 8/3/2024 11:12 AM, Richard Damon wrote:

On 8/3/24 12:03 PM, olcott wrote:

On 8/3/2024 10:33 AM, Richard Damon wrote:

On 8/3/24 10:26 AM, olcott wrote:

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.

>
Nope, the PARTIAL SIMULATION of DDD never reaches the return instruction.
>

>
For N = 0; while N <= googolplex; N++
N instructions of DDD correctly emulated by HHH[N] never
reach their own "return" instruction final state.
>
∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
>
Thus any HHH that takes a wild guess that DDD emulated
by itself never halts is always correct.
>

>
The SIMULATION of DDD never reaches the return instruction.
>

>
Great! Finally.
When we understand that the return instruction is halt state
of DDD then DDD correctly simulated by HHH never halts.
>

No, you are just proving you are incapable of learning.
>
The PARTIAL simulation of DDD done by HHH doesn't reach the return instruction.
>

 ∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
 So you are saying that the infinite one does?
 

I said for the HHH's that do a partial simulation it does.
I did not say the one that did an infinite number of steps does, but each HHH has a different DDD.
a *FACT* you don't seem to understand due to your stupidity and self-brainwashing.
Your problem is it seems you INTENTIONALLY made yourself IGNORANT of the facts of the domain, out of a fear that it would "brainwash" you, but instead chose to brainwash yourself with your ignorance.
Sorry you ruined your life that way.