Re: H(D,D) cannot even be asked about the behavior of D(D) V3 ---IGNORING ALL OTHER REPLIES

Op 19.jun.2024 om 14:58 schreef olcott:

On 6/19/2024 2:58 AM, Fred. Zwarts wrote:

Op 18.jun.2024 om 21:04 schreef olcott:

On 6/18/2024 11:05 AM, Mikko wrote:

On 2024-06-18 12:57:21 +0000, olcott said:
>

On 6/18/2024 3:03 AM, Mikko wrote:

On 2024-06-17 13:03:56 +0000, olcott said:
>

On 6/17/2024 2:20 AM, Mikko wrote:

On 2024-06-16 12:47:09 +0000, olcott said:
>

On 6/16/2024 2:53 AM, Mikko wrote:

On 2024-06-15 16:22:09 +0000, olcott said:
>

On 6/13/2024 8:24 PM, Richard Damon wrote:
 > On 6/13/24 11:32 AM, olcott wrote:
 >>
 >> It is contingent upon you to show the exact steps of how H computes
 >> the mapping from the x86 machine language finite string input to
 >> H(D,D) using the finite string transformation rules specified by
 >> the semantics of the x86 programming language that reaches the
 >> behavior of the directly executed D(D)
 >>
 >
 > Why? I don't claim it can.
>
The first six steps of this mapping are when instructions
at the machine address range of [00000cfc] to [00000d06]
are simulated/executed.
>
After that the behavior of D correctly simulated by H diverges
from the behavior of D(D) because the call to H(D,D) by D
correctly simulated by H cannot possibly return to D.
>
_D()
[00000cfc](01) 55          push ebp
[00000cfd](02) 8bec        mov ebp,esp
[00000cff](03) 8b4508      mov eax,[ebp+08]
[00000d02](01) 50          push eax       ; push D
[00000d03](03) 8b4d08      mov ecx,[ebp+08]
[00000d06](01) 51          push ecx       ; push D
[00000d07](05) e800feffff  call 00000b0c  ; call H
[00000d0c](03) 83c408      add esp,+08
[00000d0f](02) 85c0        test eax,eax
[00000d11](02) 7404        jz 00000d17
[00000d13](02) 33c0        xor eax,eax
[00000d15](02) eb05        jmp 00000d1c
[00000d17](05) b801000000  mov eax,00000001
[00000d1c](01) 5d          pop ebp
[00000d1d](01) c3          ret
Size in bytes:(0034) [00000d1d]

>
When you put "V2" or "V3" or something similar on the subject line
you should tell what is different from the original version.
>

>
I ask what are the steps
I provide 6 steps and then ask what are the next steps.
I provide all of the steps.

>
In which version?
>

>
*This is the simplest possible version*
>
void DDD()
{
   H0(DDD);
}
>
After six steps of DDD are correctly emulated by H0
what machine address of DDD would it be at?
>
_DDD()
[00001fd2] 55               push ebp      ; housekeeping
[00001fd3] 8bec             mov ebp,esp   ; housekeeping
[00001fd5] 68d21f0000       push 00001fd2 ; push DDD
[00001fda] e8f3f9ffff       call 000019d2 ; call H0
[00001fdf] 83c404           add esp,+04   ; housekeeping
[00001fe2] 5d               pop ebp       ; housekeeping
[00001fe3] c3               ret           ; return to caller
Size in bytes:(0018) [00001fe3]

>
So how is this a difference between the original version and V2 and V3?
>

>
No params thus easier to see that it pushes its own machine address.

>
My question is still unanswered.
>

>
*The simplest possible case*
void DDD()
{
   H0(DDD);
}
>
*The next simplest case*
typedef void (*ptr)();
void DDD(ptr x)
{
   HH(x, x);
}
>
*The conventional case*
typedef int (*ptr2)();
int P(ptr2 x)
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
I had to keep dumbing it down to make it more
difficult to reject out-of-hand without review.

>
No, this is not the simplest case. You are making it unnecessary complex. The simplest case is:
>
        int main()
        {
          return H(main, 0);
        }
>
No D, DD, or DDD is needed.
For this case you proved that main halts, whereas H reports non-halting, i.e. a false negative.
This shows that in your more complex (but equivalent) cases there is also a false negative.
Of course, you prefer the more complex cases, because there you can play your invalid claim that the direct execution and the simulation of DDD(DDD) show different behaviour., but the simplest case shows that it is not true. It is just a false negative.

 _DDD()
[000020a2] 55         push ebp      ; housekeeping
[000020a3] 8bec       mov ebp,esp   ; housekeeping
[000020a5] 68a2200000 push 000020a2 ; push DDD
[000020aa] e8f3f9ffff call 00001aa2 ; call H0
[000020af] 83c404     add esp,+04   ; housekeeping
[000020b2] 5d         pop ebp       ; housekeeping
[000020b3] c3         ret           ; never gets here
Size in bytes:(0018) [000020b3]
 Exactly which step of DDD emulated by H0 was emulated
incorrectly such that this emulation would be complete?
AKA DDD emulated by H0 reaches machine address [000020b3]
 

That has been pointed out to you so many times. It seems really to difficult for you. So, you prefer to forget or ignore it.
The 'call' instruction at 000020aa is incorrectly simulated. H0 is required to halt, i.e. to return, but your simulation does not show the 'ret' instruction of H0.
It seems you are so confused that you do not understand it. Therefore, you think it is a change of subject or gibberish. Showing that it is over your head.
Instead of fixing the problem, you just repeat the claim without any new argument.
The simulation fails, because it is aborted one cycle too soon, before the simulated H0 would reach its 'ret' instruction. A correct simulation would see this. Unfortunately, H0 is unable to correctly simulate itself.