Re: 197 page execution trace of DDD correctly simulated by HHH

Op 01.jul.2024 om 20:25 schreef olcott:

On 7/1/2024 1:01 PM, Fred. Zwarts wrote:

Op 01.jul.2024 om 17:15 schreef olcott:

On 7/1/2024 10:02 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 16:35 schreef olcott:

On 7/1/2024 9:27 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 14:57 schreef olcott:

On 7/1/2024 3:27 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:25 schreef olcott:

On 6/30/2024 3:42 AM, joes wrote:
>

No, I mean: why does the inner simulator repeat instead of aborting,
the same as the outer one does?
>

Technically it is called detecting a repeating state.

Yeah, I know. My point is: all recursive calls both enter and detect
a repeating state.
>

>
The inner ones always see one less execution trace
than the next outer one, thus could only meet their
abort criteria after they have already been aborted.
>

>
Which indicates that they were aborted too soon, showing that the emulation was incorrect.

>
Unless the outer HHH aborts its simulation after some
fixed number of correct emulations or none of the HHH
ever aborts and HHH never stops running.

>
But that does not make the result of the abort correct.

>
>

Not aborting will loop infinitely.

>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted
>
THEN H IS NECESSARILY CORRECT TO ABORT
THEN H IS NECESSARILY CORRECT TO ABORT
THEN H IS NECESSARILY CORRECT TO ABORT

>
It is inevitable to abort, but that does not make the simulation correct, because:
>

>
Of every possibility that can possibly be is is absolutely
not inevitable to abort.
>
DDD correctly emulated by HHH is either aborted at some point
or crashes due to out-of-memory error.

>
Which shows that both simulations are incorrect. The aborted one and the crashed one.
>

>
You just aren't very good at these things are you?

Even here your opinion is incorrect.
>
It seems that you do not quite understand the theory. When talking about correct simulation, we can ignore memory limits.
That may be too complex for you already.
>
It is not relevant whether HHH must abort, but it is relevant that HHH *does* abort and halt.

 *YOU ARE NOT ALLOWED TO CHANGE THE MEANING OF THESE WORDS*
 <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then
      H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
 

Therefore, a correct simulation of HHH, should not abort. This proves that HHH is unable to simulate itself, because it does abort (too soon).
>
>

 

Another way to distract from the fact that you are proved to be incorrect.
Repeating the same irrelevant words does not help.
Since your simulation is incorrect, Sipser's opinion does not apply here, because that is about a correct simulation.
We are talking about an HHH that *does* abort and therefore cannot simulate itself up to its simulated return, which makes the simulation incorrect.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
HHH aborts after two cycles, therefore, it is equivalent to Finite_Recursion (2).
I would not be surprised if you (or your simulator) do not see the difference between Finite_Recursion and Infinite_Recursion. Since you seem to think that two equals infinity.