^ subject

Can Olcott provide a correct execution trace of the direct execution of
D(D) and show how it differs from the simulation trace?

On 1/13/2024 6:21 AM, immibis wrote:
> ^ subject
>
> Can Olcott provide a correct execution trace of the direct execution of
> D(D) and show how it differs from the simulation trace?

01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }

We already know that the directly executed D(D) reaches
its final state and terminates normally and that D
correctly simulated by H cannot possibly reach its
final state at line 06 and terminate normally.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 2024-01-13 16:50:26 +0000, olcott said:

> On 1/13/2024 6:21 AM, immibis wrote:
>> ^ subject
>>
>> Can Olcott provide a correct execution trace of the direct execution of
>> D(D) and show how it differs from the simulation trace?
>
> 01 int D(ptr x) // ptr is pointer to int function
> 02 {
> 03 int Halt_Status = H(x, x);
> 04 if (Halt_Status)
> 05 HERE: goto HERE;
> 06 return Halt_Status;
> 07 }
>
> We already know that the directly executed D(D) reaches
> its final state and terminates normally and that D
> correctly simulated by H cannot possibly reach its
> final state at line 06 and terminate normally.

In news:unqsrf$3d3ma$1@dont-email.me I have shown how H should simulate
in order to reach the line 06.

Mikko

On 1/15/2024 3:24 AM, Mikko wrote:
> On 2024-01-13 16:50:26 +0000, olcott said:
>
>> On 1/13/2024 6:21 AM, immibis wrote:
>>> ^ subject
>>>
>>> Can Olcott provide a correct execution trace of the direct execution
>>> of D(D) and show how it differs from the simulation trace?
>>
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>>
>> We already know that the directly executed D(D) reaches
>> its final state and terminates normally and that D
>> correctly simulated by H cannot possibly reach its
>> final state at line 06 and terminate normally.
>
> In news:unqsrf$3d3ma$1@dont-email.me I have shown how H should simulate
> in order to reach the line 06.
>
> Mikko
>

That is an invalid Message ID.
<unqsrf$3d3ma$1@dont-email.me> corrected

http://al.howardknight.net/?STYPE=msgid&MSGI=%3Cunqsrf%243d3ma%241%40dont-email.me%3E

Your trace is incorrect here is the x86 machine code
that Mike Terry verified. HH(D,D) correctly simulates
itself simulating D.

_D()
[00001cd2] 55 push ebp
[00001cd3] 8bec mov ebp,esp
[00001cd5] 51 push ecx
[00001cd6] 8b4508 mov eax,[ebp+08]
[00001cd9] 50 push eax
[00001cda] 8b4d08 mov ecx,[ebp+08]
[00001cdd] 51 push ecx
[00001cde] e85ff8ffff call 00001542
[00001ce3] 83c408 add esp,+08
[00001ce6] 8945fc mov [ebp-04],eax
[00001ce9] 837dfc00 cmp dword [ebp-04],+00
[00001ced] 7402 jz 00001cf1
[00001cef] ebfe jmp 00001cef
[00001cf1] 8b45fc mov eax,[ebp-04]
[00001cf4] 8be5 mov esp,ebp
[00001cf6] 5d pop ebp
[00001cf7] c3 ret
Size in bytes:(0038) [00001cf7]

_main()
[00001d02] 55 push ebp
[00001d03] 8bec mov ebp,esp
[00001d05] 68421c0000 push 00001c42
[00001d0a] 68421c0000 push 00001c42
[00001d0f] e84ef6ffff call 00001362
[00001d14] 83c408 add esp,+08
[00001d17] 50 push eax
[00001d18] 6863070000 push 00000763
[00001d1d] e860eaffff call 00000782
[00001d22] 83c408 add esp,+08
[00001d25] 33c0 xor eax,eax
[00001d27] 5d pop ebp
[00001d28] c3 ret
Size in bytes:(0039) [00001d28]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001d02][00102f7b][00000000] 55 push ebp
[00001d03][00102f7b][00000000] 8bec mov ebp,esp
[00001d05][00102f77][00001c42] 68421c0000 push 00001c42 ; D
[00001d0a][00102f73][00001c42] 68421c0000 push 00001c42 ; D
[00001d0f][00102f6f][00001d14] e84ef6ffff Call 00001362 ; HH
New slave_stack at:10301f

Begin Local Halt Decider Simulation Execution Trace Stored at:113027
[00001c42][00113013][00113017] 55 push ebp
[00001c43][00113013][00113017] 8bec mov ebp,esp
[00001c45][0011300f][00102fe3] 51 push ecx
[00001c46][0011300f][00102fe3] 8b4508 mov eax,[ebp+08] ; D
[00001c49][0011300b][00001c42] 50 push eax
[00001c4a][0011300b][00001c42] 8b4d08 mov ecx,[ebp+08] ; D
[00001c4d][00113007][00001c42] 51 push ecx
[00001c4e][00113003][00001c53] e80ff7ffff call 00001362 ; HH
New slave_stack at:14da47
[00001c42][0015da3b][0015da3f] 55 push ebp
[00001c43][0015da3b][0015da3f] 8bec mov ebp,esp
[00001c45][0015da37][0014da0b] 51 push ecx
[00001c46][0015da37][0014da0b] 8b4508 mov eax,[ebp+08] ; D
[00001c49][0015da33][00001c42] 50 push eax
[00001c4a][0015da33][00001c42] 8b4d08 mov ecx,[ebp+08] ; D
[00001c4d][0015da2f][00001c42] 51 push ecx
[00001c4e][0015da2b][00001c53] e80ff7ffff call 00001362 ; HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00001d14][00102f7b][00000000] 83c408 add esp,+08
[00001d17][00102f77][00000000] 50 push eax
[00001d18][00102f73][00000763] 6863070000 push 00000763
[00001d1d][00102f73][00000763] e860eaffff call 00000782 ; Output()
Input_Halts = 0
[00001d22][00102f7b][00000000] 83c408 add esp,+08
[00001d25][00102f7b][00000000] 33c0 xor eax,eax
[00001d27][00102f7f][00000018] 5d pop ebp
[00001d28][00102f83][00000000] c3 ret
Number of Instructions Executed(16828) == 251 Pages

01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = HH(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 HH(D,D);
12 }

*Simulation invariant*
D correctly simulated by HH cannot possibly reach past its own line 03.

*Execution Trace*
Line 11: main() invokes H(D,D);

Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
executed HH matches this repeating pattern and aborts its simulation
executed HH reports: Infinite "Recursion Detected Simulation Stopped"
executed HH returns to main()

*The recursive simulation call from D to HH(D,D) cannot be ignored*
*and does prevent the simulated D from reaches its own line 06*

H matches the non-halting behavior pattern when D first calls
H(D,D) and aborts the simulation of D at that point.

HH matches the non-halting behavior pattern (repeating state)
after it fully simulates itself simulating D.

Your trace is incorrect D correctly simulated by H or HH
cannot possibly reach past its own line 03.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 1/15/24 10:25 AM, olcott wrote:
> On 1/15/2024 3:24 AM, Mikko wrote:
>> On 2024-01-13 16:50:26 +0000, olcott said:
>>
>>> On 1/13/2024 6:21 AM, immibis wrote:
>>>> ^ subject
>>>>
>>>> Can Olcott provide a correct execution trace of the direct execution
>>>> of D(D) and show how it differs from the simulation trace?
>>>
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>>
>>> We already know that the directly executed D(D) reaches
>>> its final state and terminates normally and that D
>>> correctly simulated by H cannot possibly reach its
>>> final state at line 06 and terminate normally.
>>
>> In news:unqsrf$3d3ma$1@dont-email.me I have shown how H should simulate
>> in order to reach the line 06.
>>
>> Mikko
>>
>
> That is an invalid Message ID.
> <unqsrf$3d3ma$1@dont-email.me> corrected
>
> http://al.howardknight.net/?STYPE=msgid&MSGI=%3Cunqsrf%243d3ma%241%40dont-email.me%3E
>
> Your trace is incorrect here is the x86 machine code
> that Mike Terry verified. HH(D,D) correctly simulates
> itself simulating D.
>
> _D()
> [00001cd2] 55         push ebp
> [00001cd3] 8bec       mov ebp,esp
> [00001cd5] 51         push ecx
> [00001cd6] 8b4508     mov eax,[ebp+08]
> [00001cd9] 50         push eax
> [00001cda] 8b4d08     mov ecx,[ebp+08]
> [00001cdd] 51         push ecx
> [00001cde] e85ff8ffff call 00001542
> [00001ce3] 83c408     add esp,+08
> [00001ce6] 8945fc     mov [ebp-04],eax
> [00001ce9] 837dfc00   cmp dword [ebp-04],+00
> [00001ced] 7402       jz 00001cf1
> [00001cef] ebfe       jmp 00001cef
> [00001cf1] 8b45fc     mov eax,[ebp-04]
> [00001cf4] 8be5       mov esp,ebp
> [00001cf6] 5d         pop ebp
> [00001cf7] c3         ret
> Size in bytes:(0038) [00001cf7]
>
> _main()
> [00001d02] 55         push ebp
> [00001d03] 8bec       mov ebp,esp
> [00001d05] 68421c0000 push 00001c42
> [00001d0a] 68421c0000 push 00001c42
> [00001d0f] e84ef6ffff call 00001362
> [00001d14] 83c408     add esp,+08
> [00001d17] 50         push eax
> [00001d18] 6863070000 push 00000763
> [00001d1d] e860eaffff call 00000782
> [00001d22] 83c408     add esp,+08
> [00001d25] 33c0       xor eax,eax
> [00001d27] 5d         pop ebp
> [00001d28] c3         ret
> Size in bytes:(0039) [00001d28]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001d02][00102f7b][00000000] 55         push ebp
> [00001d03][00102f7b][00000000] 8bec       mov ebp,esp
> [00001d05][00102f77][00001c42] 68421c0000 push 00001c42 ; D
> [00001d0a][00102f73][00001c42] 68421c0000 push 00001c42 ; D
> [00001d0f][00102f6f][00001d14] e84ef6ffff Call 00001362 ; HH
> New slave_stack at:10301f
>
> Begin Local Halt Decider Simulation        Execution Trace Stored at:113027
> [00001c42][00113013][00113017] 55          push ebp
> [00001c43][00113013][00113017] 8bec        mov ebp,esp
> [00001c45][0011300f][00102fe3] 51          push ecx
> [00001c46][0011300f][00102fe3] 8b4508      mov eax,[ebp+08] ; D
> [00001c49][0011300b][00001c42] 50          push eax
> [00001c4a][0011300b][00001c42] 8b4d08      mov ecx,[ebp+08] ; D
> [00001c4d][00113007][00001c42] 51          push ecx
> [00001c4e][00113003][00001c53] e80ff7ffff  call 00001362    ; HH
> New slave_stack at:14da47
> [00001c42][0015da3b][0015da3f] 55          push ebp
> [00001c43][0015da3b][0015da3f] 8bec        mov ebp,esp
> [00001c45][0015da37][0014da0b] 51          push ecx
> [00001c46][0015da37][0014da0b] 8b4508      mov eax,[ebp+08] ; D
> [00001c49][0015da33][00001c42] 50          push eax
> [00001c4a][0015da33][00001c42] 8b4d08      mov ecx,[ebp+08] ; D
> [00001c4d][0015da2f][00001c42] 51          push ecx
> [00001c4e][0015da2b][00001c53] e80ff7ffff  call 00001362    ; HH
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> [00001d14][00102f7b][00000000] 83c408      add esp,+08
> [00001d17][00102f77][00000000] 50          push eax
> [00001d18][00102f73][00000763] 6863070000  push 00000763
> [00001d1d][00102f73][00000763] e860eaffff  call 00000782 ; Output()
> Input_Halts = 0
> [00001d22][00102f7b][00000000] 83c408      add esp,+08
> [00001d25][00102f7b][00000000] 33c0        xor eax,eax
> [00001d27][00102f7f][00000018] 5d          pop ebp
> [00001d28][00102f83][00000000] c3          ret
> Number of Instructions Executed(16828) == 251 Pages
>
> 01 int D(ptr x)  // ptr is pointer to int function
> 02 {
> 03   int Halt_Status = HH(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   HH(D,D);
> 12 }
>
> *Simulation invariant*
> D correctly simulated by HH cannot possibly reach past its own line 03.
>
> *Execution Trace*
> Line 11: main() invokes H(D,D);
>
> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
> executed HH matches this repeating pattern and aborts its simulation
> executed HH reports: Infinite "Recursion Detected Simulation Stopped"
> executed HH returns to main()
>
> *The recursive simulation call from D to HH(D,D) cannot be ignored*
> *and does prevent the simulated D from reaches its own line 06*
>
> H matches the non-halting behavior pattern when D first calls
> H(D,D) and aborts the simulation of D at that point.
>
> HH matches the non-halting behavior pattern (repeating state)
> after it fully simulates itself simulating D.
>
> Your trace is incorrect D correctly simulated by H or HH
> cannot possibly reach past its own line 03.
>

But the pattern isn't a non-halting pattern, as the actual correct
simulation of either D by a real UTM (or x86 UTM with main calling D(D))
shows that same initial pattern, and then it halting.

So, INCORRECT is INCORRECT.