Re: Proof that DDD specifies non-halting behavior --- Mike correcting Joes

Op 16.aug.2024 om 14:51 schreef olcott:

On 8/16/2024 1:42 AM, Fred. Zwarts wrote:

Op 16.aug.2024 om 04:24 schreef olcott:

On 8/15/2024 8:57 PM, Richard Damon wrote:

On 8/15/24 8:12 AM, olcott wrote:

On 8/15/2024 2:00 AM, joes wrote:

Am Wed, 14 Aug 2024 16:07:43 +0100 schrieb Mike Terry:

On 14/08/2024 08:43, joes wrote:

Am Tue, 13 Aug 2024 21:38:07 -0500 schrieb olcott:

On 8/13/2024 9:29 PM, Richard Damon wrote:

On 8/13/24 8:52 PM, olcott wrote:

>

A simulation of N instructions of DDD by HHH according to the
semantics of the x86 language is necessarily correct.

Nope, it is just the correct PARTIAL emulation of the first N
instructions of DDD, and not of all of DDD,

That is what I said dufuss.

You were trying to label an incomplete/partial/aborted simulation as
correct.
>

A correct simulation of N instructions of DDD by HHH is sufficient
to correctly predict the behavior of an unlimited simulation.

Nope, if a HHH returns to its caller,

*Try to show exactly how DDD emulated by HHH returns to its caller*

how *HHH* returns

>

HHH simulates DDD    enter the matrix
    DDD calls HHH(DDD)    Fred: could be eliminated HHH simulates

DDD

    second level
      DDD calls HHH(DDD)    recursion detected
    HHH aborts, returns    outside interference DDD halts

voila

HHH halts

>
You're misunderstanding the scenario?  If your simulated HHH aborts its
simulation [line 5 above],

>
>

then the outer level H would have aborted its identical simulation
earlier.  You know that, right?

>
That is the part that Joes and Fred do not understand.
>

>
You do not understand what we say. I have repeated many times that the simulated HHH is aborted before it would halt by itself.

 void DDD()
{
   HHH(DDD);
   return;
}
 DDD emulated by HHH according to the semantics of the
x86 language would never halt by itself.

Exactly, which proves that the simulation is incomplete. We are speaking of a HHH that aborts. The HHH that does not abort is only in your dreams (and maybe in you cheating program code if you still use the Root variable to change the behaviour of the input to that of a non-input).
The input for the simulator, therefore, is the HHH that aborts and halts (if you do not cheat).
When the simulating HHH aborts, the simulated HHH is only one cycle away from its own abort.

 

The simulating HHH fails to reach that point, proving an incomplete simulation.

 void Infinite_Recursion()
{
   Infinite_Recursion();
   OutputString("I never make it here!\n");
}
 Unreachable code is unreachable code.
 

If you do not cheat with the Root variable, the HHH looks more like:
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}