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

Op 19.jun.2024 om 16:55 schreef olcott:

On 6/19/2024 8:46 AM, Fred. Zwarts wrote:

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.

 When falsehoods are pointed out an unlimited number of times
they still remain falsehoods.
 

It seems really to difficult for you. So, you prefer to forget or ignore it.
The 'call' instruction at 000020aa is incorrectly simulated.

 As a matter of fact it is not incorrectly simulated.
I am showing this with HH0 instead of H0 because
the trace provided by HH0 is easier to understand.
 void DDD()
{
   HH0(DDD);
}
 int main()
{
   HH0(DDD);
}
 _DDD()
[00002093] 55         push ebp
[00002094] 8bec       mov ebp,esp
[00002096] 6893200000 push 00002093 ; push DDD
[0000209b] e853f4ffff call 000014f3 ; call HH0
[000020a0] 83c404     add esp,+04
[000020a3] 5d         pop ebp
[000020a4] c3         ret
Size in bytes:(0018) [000020a4]
 _main()
[000020b3] 55         push ebp
[000020b4] 8bec       mov ebp,esp
[000020b6] 6893200000 push 00002093 ; push DDD
[000020bb] e833f4ffff call 000014f3 ; call HH0
[000020c0] 83c404     add esp,+04
[000020c3] eb04       jmp 000020c9
[000020c5] 33c0       xor eax,eax
[000020c7] eb02       jmp 000020cb
[000020c9] 33c0       xor eax,eax
[000020cb] 5d         pop ebp
[000020cc] c3         ret
Size in bytes:(0026) [000020cc]
   machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[000020b3][00103680][00000000] 55         push ebp      ; begin main
[000020b4][00103680][00000000] 8bec       mov ebp,esp
[000020b6][0010367c][00002093] 6893200000 push 00002093 ; push DDD
[000020bb][00103678][000020c0] e833f4ffff call 000014f3 ; call HH0
New slave_stack at:103724
 Begin Local Halt Decider Simulation   Execution Trace Stored at:11372c
[00002093][0011371c][00113720] 55         push ebp      ; begin DDD
[00002094][0011371c][00113720] 8bec       mov ebp,esp
[00002096][00113718][00002093] 6893200000 push 00002093 ; push DDD
[0000209b][00113714][000020a0] e853f4ffff call 000014f3 ; call HH0
New slave_stack at:14e14c
[00002093][0015e144][0015e148] 55         push ebp      ; begin DDD
[00002094][0015e144][0015e148] 8bec       mov ebp,esp
[00002096][0015e140][00002093] 6893200000 push 00002093 ; push DDD
[0000209b][0015e13c][000020a0] e853f4ffff call 000014f3 ; call HH0
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
 [000020c0][00103680][00000000] 83c404     add esp,+04   ; return to main
[000020c3][00103680][00000000] eb04       jmp 000020c9
[000020c9][00103680][00000000] 33c0       xor eax,eax
[000020cb][00103684][00000018] 5d         pop ebp
[000020cc][00103688][00000000] c3         ret           ; end main
Number of Instructions Executed(10067) == 150 Pages
 

H0 is required to halt, i.e. to return, but your simulation does not show the 'ret' instruction of H0.

 Yes it does not show this yet HH0 does simulate itself simulating DDD.
 If the eight lines of DDD correctly simulated by HH0 were mixed in
with the 150 pages of HH0 simulating itself it would be too difficult
to see the behavior of DDD. The reader would have to carefully search
for the machine addresses of DDD that only occur every 19 pages.
 I will adapt HH0 so that it does show HH0 simulating itself
simulating DDD.
 

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.

 Because the executed HH0 always has at least one more execution trace
than any of its simulated instances unless it aborts the simulation
after a fixed number of repeating states, none of them do.

What is your problem:
1) You say: 'HH0 always has at least one more execution trace than any of its simulated instances'. That is correct. That is true even if it does abort. Is that over your head?
2) If it aborts, it misses the fact that the simulation of itself would also abort one execution trace later. Is that over your head?
3) If it misses the fact that its simulation of itself would halt one execution trace later, it is incorrect to report non-halting. Is that over your head?
What is your problem: 1, 2, or 3.
If you do not even understand it, you better stop talking about it.