Path: news.eternal-september.org!eternal-september.org!feeder3.eternal-september.org!news.quux.org!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: DDD emulated by HHH diverges from DDD emulated by HHH1
Date: Thu, 5 Jun 2025 07:42:00 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <c55d63283e16122b6e7c0a1db079b723f8174c72@i2pn2.org>
References: <101khcl$3bfvj$6@dont-email.me> <101mbnh$3sodg$1@dont-email.me>
 <101njgb$7qau$3@dont-email.me>
 <4113b5c3cb0e33212819ef36a4de858e40e70cba@i2pn2.org>
 <101noka$8rb8$4@dont-email.me> <101o96g$db96$3@dont-email.me>
 <101ob1t$hd6o$3@dont-email.me> <101obrf$hlr6$1@dont-email.me>
 <101ocan$hd6o$6@dont-email.me>
 <814d8b767f6a7abc0f5e6b45e940f4c628b47fc1@i2pn2.org>
 <101ppd7$ta6v$3@dont-email.me>
 <f3609e2dffa380f745312c5cd2d845c2a4b6b28f@i2pn2.org>
 <101r02l$15bg8$6@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 5 Jun 2025 11:42:27 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="3388420"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <101r02l$15bg8$6@dont-email.me>

On 6/4/25 10:40 PM, olcott wrote:
> On 6/4/2025 8:53 PM, Richard Damon wrote:
>> On 6/4/25 11:40 AM, olcott wrote:
>>> On 6/4/2025 6:22 AM, Richard Damon wrote:
>>>> On 6/3/25 10:51 PM, olcott wrote:
>>>>> On 6/3/2025 9:42 PM, dbush wrote:
>>>>>> On 6/3/2025 10:29 PM, olcott wrote:
>>>>>>> On 6/3/2025 8:57 PM, dbush wrote:
>>>>>>>> On 6/3/2025 5:14 PM, olcott wrote:
>>>>>>>>> On 6/3/2025 3:48 PM, joes wrote:
>>>>>>>>>> Am Tue, 03 Jun 2025 14:47:23 -0500 schrieb olcott:
>>>>>>>>>>> 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*
>>>>>>>>>>
>>>>>>>>>>>>> *This is the beginning of the divergence of the behavior*
>>>>>>>>>>>>> *of DDD emulated by HHH versus DDD emulated by HHH1*
>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>> Yes, that is exactly the point where HHH aborts. 
>>>>>>>>>
>>>>>>>>> Both the divergence and the abort are shown below.
>>>>>>>>>
>>>>>>>>> _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
>>>>>>>>> New slave_stack at:198d21
>>>>>>>>>
>>>>>>>>> THIS IS WHERE THE DIVERGENCE OF DDD EMULATED BY HHH
>>>>>>>>> AND DDD EMULATED BY HHH1 BEGINS
>>>>>>>>
>>>>>>>> So how exactly do HHH and HHH1 emulate the first instruction of 
>>>>>>>> HHH differently?
>>>>>>>>
>>>>>>>
>>>>>>> The question is incorrect.
>>>>>>> HHH emulates DDD two times and HHH1 emulates DDD one time
>>>>>>> the whole second time is the divergence.
>>>>>>
>>>>>> There is no divergence if the instructions are emulated exactly 
>>>>>> the same in both cases. 
>>>>>
>>>>> HHH1(DDD) emulates DDD exactly one time.
>>>>> HHH(DDD) emulates DDD exactly two times.
>>>>>
>>>>> The whole second time that HHH emulates DDD is
>>>>> divergence.
>>>>>
>>>>
>>>> You mean it INCORRECT imagining of what it THINKS HHH should do 
>>>> because it thinks that HHH is just a correct simulator?
>>>>
>>>
>>> The question is:
>>> At exactly what point does DDD simulated by HHH
>>> diverge from DDD simulated by HHH1?
>>
>> Right, which x86 instruction, correctly simulated, had differing results.
>>
>>>
>>> As soon as HHH simulates itself simulating DDD it is
>>> simulating DDD one more time than DDD simulated by
>>> HHH1 ever gets to.
>>>
>>
>> In other words, your idea of "simulation per the language of the x86 
>> language" isn't actually based on actually emulating the actual x86 
>> instrucitons, but instead presuming that HHH is just a pure simulator 
>> that never aborts, and then you let it abort.
>>
> 
> Counter-factual.
> HHH simulates DDD exactly twice
> HHH1 simulates DDD exactly once
> 
> Dennis Bush does not seem to understand that 1 != 2
> 

No, your traces show exactly the opposite.

HHH simuated DDD once, and when it sees DDD calling HHH(DDD) again, it 
presumes this will not halt, and aborts and returns.

HHH1 when it simulates, first simulates DDD, sees it calling HHH(DDD), 
and then HHH1 simulates HHH simulating DDD until that simulated HHH sees 
its simulated DDD calling HHH(DDD), and then aborts its simulated 
simulation and return to the simulated DDD which then halts.

Your "Second time HHH simulated DDD" isn't part of HHH's simulation, but 
part of HHH1s simulation.

You just don't understand how programs work.

Of course, since all your simulations violate the definiton of a correct 
simulation, you are just componding lies on top of lies, showing that 
you just don't know what you are talking about.