Re: 195 page execution trace of DDD correctly simulated by HH0

Op 25.jun.2024 om 20:51 schreef olcott:

On 6/25/2024 1:49 PM, Fred. Zwarts wrote:

Op 25.jun.2024 om 20:26 schreef olcott:

On 6/25/2024 1:19 PM, Fred. Zwarts wrote:

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

On 6/25/2024 9:13 AM, Fred. Zwarts wrote:

Op 25.jun.2024 om 15:12 schreef olcott:

On 6/25/2024 7:08 AM, Fred. Zwarts wrote:

Op 24.jun.2024 om 23:04 schreef olcott:

On 6/24/2024 2:36 PM, joes wrote:

Am Mon, 24 Jun 2024 08:48:19 -0500 schrieb olcott:

On 6/24/2024 2:37 AM, Mikko wrote:

On 2024-06-23 13:17:27 +0000, olcott said:

On 6/23/2024 3:22 AM, Mikko wrote:

That code is not from the mentined trace file. In that file _DDD()
is at the addresses 2093..20a4. According to the trace no instruction
at the address is executed (because that address points to the last
byte of a three byte instruction.

>
In order to make my examples I must edit the code and this changes the
addresses of some functions.

>
Why do you need to make an example when you already have one in the
file mentioned in the subject line?
>

I had to make a few more examples such as HH1(DD,DD)

AFACT HH1 is the same as HH0, right? What happens when HH1 tries to
simulate a function DD1 that only calls HH1?
>

>
typedef uint32_t u32;
u32 H(u32 P, u32 I);
>
int P(u32 x)
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
int main()
{
   H(P,P);
}
>
I am going to have to go through my code and standardize my names.
H(P,P) was the original name. Then I had to make a one parameter
version, a version that is identical to H, except P does not call
it and then versions using different algorithms. People have never
been able to understand the different algorithm.
>
typedef void (*ptr)();
typedef int (*ptr2)();
int  HH(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
int HH1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls HH
int  HHH(ptr P);         // used with void DDD() that calls HHH
int HHH1(ptr P);         // used with void DDD() that calls HHH
>
*The different algorithm version has been deprecated*
int  H(ptr2 , ptr2 I);  // used with int D(ptr2 P) that calls H
int H1(ptr2 P, ptr2 I); // used with int D(ptr2 P) that calls H
>
*It is much easier for people to see the infinite recursion*
*behavior pattern when they see it actually cycle through the*
*same instructions twice*

>
Twice is not equal to infinitely. When will you see that?
It is strange that you call that an infinite recursion, when H aborts after two cycles and the simulated H cannot reach its own abort operation, because it is aborted when it had only one more cycle to go.
None of the aborted simulations would cycle more than twice, so infinite recursion is not seen for an H that aborts the simulation of itself.

>
typedef void (*ptr)();
int H0(ptr P);
>
void DDD()
{
   H0(DDD);
}
>
int main()
{
   H0(DDD);
}
>
_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
>
The call from DDD to H0(DDD) when DDD is correctly emulated
by H0 cannot possibly return.

>
Contradictio in terminis. The fact that the simulated H0 does not return shows that the simulation is incorrect.

>
void Infinite_Recursion()
{
   Infinite_Recursion();
}
>
Ah so you simply *DON'T BELIEVE IN* infinite recursion where a
correct simulating termination analyzer would be required to
abort its simulation to correctly report non-terminating behavior.
That seems quite dumb of you.

>
Change of subject ignored.
>

>

The simulated H0 does not return, because it is aborted one cycle too soon. One cycle later it would return.

>
Complete lack of sufficient software engineering skill.

>
Maybe you should study some software engineering to get over it.
>

Unless the outermost directly executed H0 aborts its
simulation after a fixed number of recursive invocations
NONE OF THEM DO.

>
Change of subject. We are talking about an H0 that aborts, so dreaming of one that does not abort is irrelevant.

>
No one here can possibly handle more than one single point
at a time without leaping to the conclusion that I must
be incorrect. Because of this I will not tolerate moving
beyond one single point at a time.

>
You are the one that started to talk about a second point (an H0 that does not abort), when we were talking about an H0 that aborts.
So, I agree, let us forget about that second point (an H0 that does not abort). From now on we only talk about an H0 that aborts after two cycles. So, no infinite recursion, two cycles at most.
>

>

H0 aborts after two cycles. Then it aborts the simulated H0 which at that moment has run only one cycle. One cycle later the simulated H0 would also return, if not aborted.
>

>
This did baffle me for three days 3.5 years ago until
I took the time to THINK IT ALL THE WAY THROUGH.

>
Apparently, your thinking went completely wrong.
>

>
No the actual truth is that you are one of my least competent
reviewers.
>

>
Bad excuse for not showing any error in my reasoning.

 I did and it was over your head.

No, you didn't.

Unless the outer directly executed H aborts NONE-OF-THEM DO.
 _DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
 The call from DDD to H0(DDD) when DDD is correctly emulated
by H0 cannot possibly return.
 Until you acknowledge this is true, this is the
only thing that I am willing to talk to you about.
 

It might be true, but it is irrelevant, because the simulated H0 is aborted prematurely. The simulating H0 aborts after two cycles, when the simulated H0 has one cycle to go before it would return.
So, the only reason that the simulated H0 does not return is that it is aborted prematurely. A correct simulation would show that one cycle later it returns.
It seems that it is over your head that a prematurely aborted simulation is not a correct simulation.
There are a few reasons why a simulation can be incorrect:
1) Some instructions are incorrectly simulated.
2) Instructions are simulated out of order.
3) Some instructions are not simulated at all.
Your problem is 3).
You only prove that your H0 is unable to simulate itself correctly, because it aborts too soon and fails to simulate the end of itself.