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

Op 28.jun.2024 om 21:01 schreef olcott:

On 6/28/2024 1:48 PM, Fred. Zwarts wrote:

Op 28.jun.2024 om 20:31 schreef olcott:

On 6/28/2024 1:22 PM, Fred. Zwarts wrote:

Op 28.jun.2024 om 18:54 schreef olcott:

On 6/28/2024 10:48 AM, Fred. Zwarts wrote:

Op 28.jun.2024 om 17:32 schreef olcott:

>
<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>
>
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
 > I don't think that is the shell game. PO really /has/ an H
 > (it's trivial to do for this one case) that correctly determines
 > that P(P) *would* never stop running *unless* aborted.
 >
>

>
But there is no correct simulation, so Sipser's approval does not apply.

>
The semantics of the x86 programming language specifies that
N steps of DDD were correctly emulated until the infinite
recursion behavior pattern was correctly matched.

>
What you say is that two equals infinite.
>

>
void Infinite_Loop()
{
   HERE: goto HERE;
}
>
*In that case one = infinite*

>
Change of subject ignored. This loop has more then two iterations. Why claiming falsehoods?
>

>

*We are not talking about infinite recursion. We are talking about a two cycle recursive simulation.*
>

>
This has better color coding than the prior version.
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
>

Let's agree about a two cycle recursive simulation, for which you have not shown any evidence that it can be done correctly.

>
I have proven the verified fact that DDD is correctly emulated by
HHH and HHH correctly emulates itself emulating DDD until the outer
HHH sees that DDD meets the infinite recursion behavior pattern.
>

There is no infinite recursion pattern.

>
Sure there is. Why lie ?

>
Yes, why do you?
>

>
void Infinite_Recursion()
{
   Infinite_Recursion();
}

>
Change of subject ignored.
Why distracting from the truth?
This is an example of infinite recursion. But we agreed to talk about two cycle recursion.
>

>
_Infinite_Recursion()
[00002122] 55               push ebp
[00002123] 8bec             mov ebp,esp
[00002125] e8f8ffffff       call 00002122
[0000212a] 5d               pop ebp
[0000212b] c3               ret
Size in bytes:(0010) [0000212b]
>
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d2
[00002122][001138c2][001138c6] 55         push ebp
[00002123][001138c2][001138c6] 8bec       mov ebp,esp
[00002125][001138be][0000212a] e8f8ffffff call 00002122
[00002122][001138ba][001138c2] 55         push ebp
[00002123][001138ba][001138c2] 8bec       mov ebp,esp
[00002125][001138b6][0000212a] e8f8ffffff call 00002122
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
>
>

The simulated HHH runs one cycle behind the simulating HHH. The simulating HHH aborts the simulated HHH only one cycle before the simulated HHH would return.
Aborting the simulation at this point makes it incorrect.
So, stop talking about infinite, because apparently do not understand what it means. Infinite is much more than two.
>

>

>
So, you are unable to show any error in my reasoning.
>

>
You can ignore the fact that DDD correctly simulated by HHH
meets this criteria and ignorance may be bliss yet cannot
be used as a basis for a rebuttal.
>
<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>
>

 I already proved that Sipser's word do not apply here. You simply ignore it and repeat the irrelevant text. Apparently unable to show any error in my reasoning.
You really want it to be a correct simulation, but that is not a proof.
Maybe you once were a genius, but now you do not even know the difference between two and infinite.
 void Finite_Recursion()
{

   static int Level = 0;
   if (++Level <= 2) Finite_Recursion();
}
 I am afraid that you think even this example (comparable to HHH simulating itself) shows an infinite recursion.