Re: DDD emulated by HHH diverges from DDD emulated by HHH1

Op 04.jun.2025 om 18:38 schreef olcott:

On 6/4/2025 4:20 AM, Fred. Zwarts wrote:

Op 04.jun.2025 om 04:37 schreef olcott:

On 6/3/2025 9:13 PM, Richard Damon wrote:

On 6/3/25 3:47 PM, olcott wrote:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.
>
*HHH1 never emulates itself emulating DDD*
>
void DDD()
{
   HHH(DDD);
   return;
}
>
int main()
{
   HHH1(DDD);
}
>
_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]
>
_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]
>
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1
>
Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9
[00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9
>
Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301
[00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH
>
*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*
>
New slave_stack at:198d21
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0       xor eax,eax ; main()
[000021b5][00103831][00000018] 5d         pop ebp     ; main()
[000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages
>

>
>
Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you still cannot show the first instruction that is interpreted differently by HHH and HHH1. The only difference is that HHH gives up the simulation too early.

>
As soon as HHH begins emulating itself
and HHH1 NEVER begins emulating itself
THIS IS THE DIVERGENCE.
>

>
So, WHAT INSTRUCTION, correctly simulated did that.
>

>
HHH emulates DDD two times and HHH1 emulates DDD one time
the whole second time is the divergence.
>

>
That did not answer the question: WHAT INSTRUCTION, correctly simulated did that?

 When HHH1(DDD) simulates DDD it never simulates itself.
When HHH(DDD) simulates DDD then simulates itself simulating
DDD the first instruction that this simulated HHH simulates
diverges from the simulation that HHH1 did.
 

You cannot point to any instruction interpreted differently by the two simulators.

 There are no instructions interpreted differently. It is
the fact that HHH(DDD) emulates DDD twice and HHH1(DDD)
only emulates DDD once that is the key difference.
 

It seems you understand that the trace does not show a difference, but that the divergence is only in your interpretation of the trace.

 

And you think that a logical system can be built on the meaning of words? You change the meaning of the words again.
When somebody has set out a route through a swamp and he goes with a friend. The path is so narrow that his friend has to place his feet in the footsteps of the first person. Then, when we analyse the traces they left, everybody will agree that they do not diverge, but according to Olcott's definition of 'divergence', they diverge, because the first trace is following his own route, but the other trace is following the route of his friend.
But by the common sense of the meaning of the words, the traces do not diverge when no instructions are interpreted differently.